Merge tag 'for-v6.9' of git://git.kernel.org/pub/scm/linux/kernel/git/sre/linux-power-supply

+11 -19

drivers/power/reset/as3722-poweroff.c

··· 11 11 #include <linux/module.h> 12 12 #include <linux/of.h> 13 13 #include <linux/platform_device.h> 14 + #include <linux/reboot.h> 14 15 #include <linux/slab.h> 15 16 16 17 struct as3722_poweroff { ··· 19 18 struct as3722 *as3722; 20 19 }; 21 20 22 - static struct as3722_poweroff *as3722_pm_poweroff; 23 - 24 - static void as3722_pm_power_off(void) 21 + static int as3722_pm_power_off(struct sys_off_data *data) 25 22 { 23 + struct as3722_poweroff *as3722_pm_poweroff = data->cb_data; 26 24 int ret; 27 - 28 - if (!as3722_pm_poweroff) { 29 - pr_err("AS3722 poweroff is not initialised\n"); 30 - return; 31 - } 32 25 33 26 ret = as3722_update_bits(as3722_pm_poweroff->as3722, 34 27 AS3722_RESET_CONTROL_REG, AS3722_POWER_OFF, AS3722_POWER_OFF); 35 28 if (ret < 0) 36 29 dev_err(as3722_pm_poweroff->dev, 37 30 "RESET_CONTROL_REG update failed, %d\n", ret); 31 + 32 + return NOTIFY_DONE; 38 33 } 39 34 40 35 static int as3722_poweroff_probe(struct platform_device *pdev) ··· 51 54 52 55 as3722_poweroff->as3722 = dev_get_drvdata(pdev->dev.parent); 53 56 as3722_poweroff->dev = &pdev->dev; 54 - as3722_pm_poweroff = as3722_poweroff; 55 - if (!pm_power_off) 56 - pm_power_off = as3722_pm_power_off; 57 + 58 + return devm_register_sys_off_handler(as3722_poweroff->dev, 59 + SYS_OFF_MODE_POWER_OFF, 60 + SYS_OFF_PRIO_DEFAULT, 61 + as3722_pm_power_off, 62 + as3722_poweroff); 57 63 58 64 return 0; 59 - } 60 - 61 - static void as3722_poweroff_remove(struct platform_device *pdev) 62 - { 63 - if (pm_power_off == as3722_pm_power_off) 64 - pm_power_off = NULL; 65 - as3722_pm_poweroff = NULL; 66 65 } 67 66 68 67 static struct platform_driver as3722_poweroff_driver = { ··· 66 73 .name = "as3722-power-off", 67 74 }, 68 75 .probe = as3722_poweroff_probe, 69 - .remove_new = as3722_poweroff_remove, 70 76 }; 71 77 72 78 module_platform_driver(as3722_poweroff_driver);

+21 -34

drivers/power/reset/atc260x-poweroff.c

··· 16 16 struct atc260x_pwrc { 17 17 struct device *dev; 18 18 struct regmap *regmap; 19 - struct notifier_block restart_nb; 20 19 int (*do_poweroff)(const struct atc260x_pwrc *pwrc, bool restart); 21 20 }; 22 - 23 - /* Global variable needed only for pm_power_off */ 24 - static struct atc260x_pwrc *atc260x_pwrc_data; 25 21 26 22 static int atc2603c_do_poweroff(const struct atc260x_pwrc *pwrc, bool restart) 27 23 { ··· 161 165 return ret; 162 166 } 163 167 164 - static void atc260x_pwrc_pm_handler(void) 168 + static int atc260x_pwrc_pm_handler(struct sys_off_data *data) 165 169 { 166 - atc260x_pwrc_data->do_poweroff(atc260x_pwrc_data, false); 170 + struct atc260x_pwrc *pwrc = data->cb_data; 171 + 172 + pwrc->do_poweroff(pwrc, false); 167 173 168 174 WARN_ONCE(1, "Unable to power off system\n"); 175 + 176 + return NOTIFY_DONE; 169 177 } 170 178 171 - static int atc260x_pwrc_restart_handler(struct notifier_block *nb, 172 - unsigned long mode, void *cmd) 179 + static int atc260x_pwrc_restart_handler(struct sys_off_data *data) 173 180 { 174 - struct atc260x_pwrc *pwrc = container_of(nb, struct atc260x_pwrc, 175 - restart_nb); 181 + struct atc260x_pwrc *pwrc = data->cb_data; 176 182 pwrc->do_poweroff(pwrc, true); 177 183 178 184 return NOTIFY_DONE; ··· 192 194 193 195 priv->dev = &pdev->dev; 194 196 priv->regmap = atc260x->regmap; 195 - priv->restart_nb.notifier_call = atc260x_pwrc_restart_handler; 196 - priv->restart_nb.priority = 192; 197 197 198 198 switch (atc260x->ic_type) { 199 199 case ATC2603C: ··· 212 216 if (ret) 213 217 return ret; 214 218 215 - platform_set_drvdata(pdev, priv); 219 + ret = devm_register_sys_off_handler(priv->dev, 220 + SYS_OFF_MODE_POWER_OFF, 221 + SYS_OFF_PRIO_DEFAULT, 222 + atc260x_pwrc_pm_handler, 223 + priv); 224 + if (ret) 225 + dev_err(priv->dev, "failed to register power-off handler: %d\n", 226 + ret); 216 227 217 - if (!pm_power_off) { 218 - atc260x_pwrc_data = priv; 219 - pm_power_off = atc260x_pwrc_pm_handler; 220 - } else { 221 - dev_warn(priv->dev, "Poweroff callback already assigned\n"); 222 - } 223 - 224 - ret = register_restart_handler(&priv->restart_nb); 228 + ret = devm_register_sys_off_handler(priv->dev, 229 + SYS_OFF_MODE_RESTART, 230 + SYS_OFF_PRIO_HIGH, 231 + atc260x_pwrc_restart_handler, 232 + priv); 225 233 if (ret) 226 234 dev_err(priv->dev, "failed to register restart handler: %d\n", 227 235 ret); ··· 233 233 return ret; 234 234 } 235 235 236 - static void atc260x_pwrc_remove(struct platform_device *pdev) 237 - { 238 - struct atc260x_pwrc *priv = platform_get_drvdata(pdev); 239 - 240 - if (atc260x_pwrc_data == priv) { 241 - pm_power_off = NULL; 242 - atc260x_pwrc_data = NULL; 243 - } 244 - 245 - unregister_restart_handler(&priv->restart_nb); 246 - } 247 - 248 236 static struct platform_driver atc260x_pwrc_driver = { 249 237 .probe = atc260x_pwrc_probe, 250 - .remove_new = atc260x_pwrc_remove, 251 238 .driver = { 252 239 .name = "atc260x-pwrc", 253 240 },

+6 -10

drivers/power/reset/axxia-reset.c

··· 26 26 #define SC_EFUSE_INT_STATUS 0x180c 27 27 #define EFUSE_READ_DONE (1<<31) 28 28 29 - static struct regmap *syscon; 30 - 31 - static int axxia_restart_handler(struct notifier_block *this, 32 - unsigned long mode, void *cmd) 29 + static int axxia_restart_handler(struct sys_off_data *data) 33 30 { 31 + struct regmap *syscon = data->cb_data; 32 + 34 33 /* Access Key (0xab) */ 35 34 regmap_write(syscon, SC_CRIT_WRITE_KEY, 0xab); 36 35 /* Select internal boot from 0xffff0000 */ ··· 43 44 return NOTIFY_DONE; 44 45 } 45 46 46 - static struct notifier_block axxia_restart_nb = { 47 - .notifier_call = axxia_restart_handler, 48 - .priority = 128, 49 - }; 50 - 51 47 static int axxia_reset_probe(struct platform_device *pdev) 52 48 { 53 49 struct device *dev = &pdev->dev; 50 + struct regmap *syscon; 54 51 int err; 55 52 56 53 syscon = syscon_regmap_lookup_by_phandle(dev->of_node, "syscon"); ··· 55 60 return PTR_ERR(syscon); 56 61 } 57 62 58 - err = register_restart_handler(&axxia_restart_nb); 63 + err = devm_register_sys_off_handler(&pdev->dev, SYS_OFF_MODE_RESTART, 64 + 128, axxia_restart_handler, syscon); 59 65 if (err) 60 66 dev_err(dev, "cannot register restart handler (err=%d)\n", err); 61 67

+3 -8

drivers/power/reset/brcm-kona-reset.c

··· 15 15 16 16 static void __iomem *kona_reset_base; 17 17 18 - static int kona_reset_handler(struct notifier_block *this, 19 - unsigned long mode, void *cmd) 18 + static int kona_reset_handler(struct sys_off_data *data) 20 19 { 21 20 /* 22 21 * A soft reset is triggered by writing a 0 to bit 0 of the soft reset ··· 30 31 return NOTIFY_DONE; 31 32 } 32 33 33 - static struct notifier_block kona_reset_nb = { 34 - .notifier_call = kona_reset_handler, 35 - .priority = 128, 36 - }; 37 - 38 34 static int kona_reset_probe(struct platform_device *pdev) 39 35 { 40 36 kona_reset_base = devm_platform_ioremap_resource(pdev, 0); 41 37 if (IS_ERR(kona_reset_base)) 42 38 return PTR_ERR(kona_reset_base); 43 39 44 - return register_restart_handler(&kona_reset_nb); 40 + return devm_register_sys_off_handler(&pdev->dev, SYS_OFF_MODE_RESTART, 41 + 128, kona_reset_handler, NULL); 45 42 } 46 43 47 44 static const struct of_device_id of_match[] = {

+9 -7

drivers/power/reset/gemini-poweroff.c

··· 70 70 return IRQ_HANDLED; 71 71 } 72 72 73 - /* This callback needs this static local as it has void as argument */ 74 - static struct gemini_powercon *gpw_poweroff; 75 - 76 - static void gemini_poweroff(void) 73 + static int gemini_poweroff(struct sys_off_data *data) 77 74 { 78 - struct gemini_powercon *gpw = gpw_poweroff; 75 + struct gemini_powercon *gpw = data->cb_data; 79 76 u32 val; 80 77 81 78 dev_crit(gpw->dev, "Gemini power off\n"); ··· 83 86 val &= ~GEMINI_CTRL_ENABLE; 84 87 val |= GEMINI_CTRL_SHUTDOWN; 85 88 writel(val, gpw->base + GEMINI_PWC_CTRLREG); 89 + 90 + return NOTIFY_DONE; 86 91 } 87 92 88 93 static int gemini_poweroff_probe(struct platform_device *pdev) ··· 147 148 if (ret) 148 149 return ret; 149 150 150 - pm_power_off = gemini_poweroff; 151 - gpw_poweroff = gpw; 151 + ret = devm_register_sys_off_handler(dev, SYS_OFF_MODE_POWER_OFF, 152 + SYS_OFF_PRIO_DEFAULT, 153 + gemini_poweroff, gpw); 154 + if (ret) 155 + return ret; 152 156 153 157 dev_info(dev, "Gemini poweroff driver registered\n"); 154 158

+7 -14

drivers/power/reset/msm-poweroff.c

··· 14 14 #include <linux/pm.h> 15 15 16 16 static void __iomem *msm_ps_hold; 17 - static int deassert_pshold(struct notifier_block *nb, unsigned long action, 18 - void *data) 17 + 18 + static int do_msm_poweroff(struct sys_off_data *data) 19 19 { 20 20 writel(0, msm_ps_hold); 21 21 mdelay(10000); 22 22 23 23 return NOTIFY_DONE; 24 - } 25 - 26 - static struct notifier_block restart_nb = { 27 - .notifier_call = deassert_pshold, 28 - .priority = 128, 29 - }; 30 - 31 - static void do_msm_poweroff(void) 32 - { 33 - deassert_pshold(&restart_nb, 0, NULL); 34 24 } 35 25 36 26 static int msm_restart_probe(struct platform_device *pdev) ··· 29 39 if (IS_ERR(msm_ps_hold)) 30 40 return PTR_ERR(msm_ps_hold); 31 41 32 - register_restart_handler(&restart_nb); 42 + devm_register_sys_off_handler(&pdev->dev, SYS_OFF_MODE_RESTART, 43 + 128, do_msm_poweroff, NULL); 33 44 34 - pm_power_off = do_msm_poweroff; 45 + devm_register_sys_off_handler(&pdev->dev, SYS_OFF_MODE_POWER_OFF, 46 + SYS_OFF_PRIO_DEFAULT, do_msm_poweroff, 47 + NULL); 35 48 36 49 return 0; 37 50 }

+13 -13

drivers/power/reset/mt6323-poweroff.c

··· 14 14 #include <linux/platform_device.h> 15 15 #include <linux/mfd/mt6397/core.h> 16 16 #include <linux/mfd/mt6397/rtc.h> 17 + #include <linux/reboot.h> 17 18 18 19 struct mt6323_pwrc { 19 20 struct device *dev; ··· 22 21 u32 base; 23 22 }; 24 23 25 - static struct mt6323_pwrc *mt_pwrc; 26 - 27 - static void mt6323_do_pwroff(void) 24 + static int mt6323_do_pwroff(struct sys_off_data *data) 28 25 { 29 - struct mt6323_pwrc *pwrc = mt_pwrc; 26 + struct mt6323_pwrc *pwrc = data->cb_data; 30 27 unsigned int val; 31 28 int ret; 32 29 ··· 43 44 mdelay(1000); 44 45 45 46 WARN_ONCE(1, "Unable to power off system\n"); 47 + 48 + return NOTIFY_DONE; 46 49 } 47 50 48 51 static int mt6323_pwrc_probe(struct platform_device *pdev) ··· 52 51 struct mt6397_chip *mt6397_chip = dev_get_drvdata(pdev->dev.parent); 53 52 struct mt6323_pwrc *pwrc; 54 53 struct resource *res; 54 + int ret; 55 55 56 56 pwrc = devm_kzalloc(&pdev->dev, sizeof(*pwrc), GFP_KERNEL); 57 57 if (!pwrc) ··· 65 63 pwrc->base = res->start; 66 64 pwrc->regmap = mt6397_chip->regmap; 67 65 pwrc->dev = &pdev->dev; 68 - mt_pwrc = pwrc; 69 66 70 - pm_power_off = &mt6323_do_pwroff; 67 + ret = devm_register_sys_off_handler(pwrc->dev, 68 + SYS_OFF_MODE_POWER_OFF, 69 + SYS_OFF_PRIO_DEFAULT, 70 + mt6323_do_pwroff, 71 + pwrc); 72 + if (ret) 73 + return dev_err_probe(pwrc->dev, ret, "failed to register power-off handler\n"); 71 74 72 75 return 0; 73 - } 74 - 75 - static void mt6323_pwrc_remove(struct platform_device *pdev) 76 - { 77 - if (pm_power_off == &mt6323_do_pwroff) 78 - pm_power_off = NULL; 79 76 } 80 77 81 78 static const struct of_device_id mt6323_pwrc_dt_match[] = { ··· 85 84 86 85 static struct platform_driver mt6323_pwrc_driver = { 87 86 .probe = mt6323_pwrc_probe, 88 - .remove_new = mt6323_pwrc_remove, 89 87 .driver = { 90 88 .name = "mt6323-pwrc", 91 89 .of_match_table = mt6323_pwrc_dt_match,

+13 -23

drivers/power/reset/regulator-poweroff.c

··· 13 13 #include <linux/of.h> 14 14 #include <linux/platform_device.h> 15 15 #include <linux/pm.h> 16 + #include <linux/reboot.h> 16 17 #include <linux/regulator/consumer.h> 17 18 18 19 #define TIMEOUT_MS 3000 19 20 20 - /* 21 - * Hold configuration here, cannot be more than one instance of the driver 22 - * since pm_power_off itself is global. 23 - */ 24 - static struct regulator *cpu_regulator; 25 - 26 - static void regulator_poweroff_do_poweroff(void) 21 + static int regulator_poweroff_do_poweroff(struct sys_off_data *data) 27 22 { 23 + struct regulator *cpu_regulator = data->cb_data; 24 + 28 25 if (cpu_regulator && regulator_is_enabled(cpu_regulator)) 29 26 regulator_force_disable(cpu_regulator); 30 27 ··· 29 32 mdelay(TIMEOUT_MS); 30 33 31 34 WARN_ON(1); 35 + 36 + return NOTIFY_DONE; 32 37 } 33 38 34 39 static int regulator_poweroff_probe(struct platform_device *pdev) 35 40 { 36 - /* If a pm_power_off function has already been added, leave it alone */ 37 - if (pm_power_off != NULL) { 38 - dev_err(&pdev->dev, 39 - "%s: pm_power_off function already registered\n", 40 - __func__); 41 - return -EBUSY; 42 - } 41 + struct regulator *cpu_regulator; 43 42 44 43 cpu_regulator = devm_regulator_get(&pdev->dev, "cpu"); 45 44 if (IS_ERR(cpu_regulator)) 46 45 return PTR_ERR(cpu_regulator); 47 46 48 - pm_power_off = &regulator_poweroff_do_poweroff; 49 - return 0; 50 - } 51 - 52 - static void regulator_poweroff_remove(struct platform_device *pdev) 53 - { 54 - if (pm_power_off == &regulator_poweroff_do_poweroff) 55 - pm_power_off = NULL; 47 + /* Set this handler to low priority to not override an existing handler */ 48 + return devm_register_sys_off_handler(&pdev->dev, 49 + SYS_OFF_MODE_POWER_OFF, 50 + SYS_OFF_PRIO_LOW, 51 + regulator_poweroff_do_poweroff, 52 + cpu_regulator); 56 53 } 57 54 58 55 static const struct of_device_id of_regulator_poweroff_match[] = { ··· 57 66 58 67 static struct platform_driver regulator_poweroff_driver = { 59 68 .probe = regulator_poweroff_probe, 60 - .remove_new = regulator_poweroff_remove, 61 69 .driver = { 62 70 .name = "poweroff-regulator", 63 71 .of_match_table = of_regulator_poweroff_match,

+8 -17

drivers/power/reset/restart-poweroff.c

··· 14 14 #include <linux/module.h> 15 15 #include <linux/reboot.h> 16 16 17 - static void restart_poweroff_do_poweroff(void) 17 + static int restart_poweroff_do_poweroff(struct sys_off_data *data) 18 18 { 19 19 reboot_mode = REBOOT_HARD; 20 20 machine_restart(NULL); 21 + return NOTIFY_DONE; 21 22 } 22 23 23 24 static int restart_poweroff_probe(struct platform_device *pdev) 24 25 { 25 - /* If a pm_power_off function has already been added, leave it alone */ 26 - if (pm_power_off != NULL) { 27 - dev_err(&pdev->dev, 28 - "pm_power_off function already registered"); 29 - return -EBUSY; 30 - } 31 - 32 - pm_power_off = &restart_poweroff_do_poweroff; 33 - return 0; 34 - } 35 - 36 - static void restart_poweroff_remove(struct platform_device *pdev) 37 - { 38 - if (pm_power_off == &restart_poweroff_do_poweroff) 39 - pm_power_off = NULL; 26 + /* Set this handler to low priority to not override an existing handler */ 27 + return devm_register_sys_off_handler(&pdev->dev, 28 + SYS_OFF_MODE_POWER_OFF, 29 + SYS_OFF_PRIO_LOW, 30 + restart_poweroff_do_poweroff, 31 + NULL); 40 32 } 41 33 42 34 static const struct of_device_id of_restart_poweroff_match[] = { ··· 39 47 40 48 static struct platform_driver restart_poweroff_driver = { 41 49 .probe = restart_poweroff_probe, 42 - .remove_new = restart_poweroff_remove, 43 50 .driver = { 44 51 .name = "poweroff-restart", 45 52 .of_match_table = of_restart_poweroff_match,

+12 -26

drivers/power/reset/rmobile-reset.c

··· 19 19 /* Reset Control Register 2 */ 20 20 #define RESCNT2_PRES 0x80000000 /* Soft power-on reset */ 21 21 22 - static void __iomem *sysc_base2; 23 - 24 - static int rmobile_reset_handler(struct notifier_block *this, 25 - unsigned long mode, void *cmd) 22 + static int rmobile_reset_handler(struct sys_off_data *data) 26 23 { 27 - pr_debug("%s %lu\n", __func__, mode); 24 + void __iomem *sysc_base2 = (void __iomem *)data->cb_data; 28 25 29 26 /* Let's assume we have acquired the HPB semaphore */ 30 27 writel(RESCNT2_PRES, sysc_base2 + RESCNT2); ··· 29 32 return NOTIFY_DONE; 30 33 } 31 34 32 - static struct notifier_block rmobile_reset_nb = { 33 - .notifier_call = rmobile_reset_handler, 34 - .priority = 192, 35 - }; 36 - 37 35 static int rmobile_reset_probe(struct platform_device *pdev) 38 36 { 37 + void __iomem *sysc_base2; 39 38 int error; 40 39 41 - sysc_base2 = of_iomap(pdev->dev.of_node, 1); 42 - if (!sysc_base2) 43 - return -ENODEV; 40 + sysc_base2 = devm_platform_ioremap_resource(pdev, 1); 41 + if (IS_ERR(sysc_base2)) 42 + return PTR_ERR(sysc_base2); 44 43 45 - error = register_restart_handler(&rmobile_reset_nb); 44 + error = devm_register_sys_off_handler(&pdev->dev, 45 + SYS_OFF_MODE_RESTART, 46 + SYS_OFF_PRIO_HIGH, 47 + rmobile_reset_handler, 48 + (__force void *)sysc_base2); 46 49 if (error) { 47 50 dev_err(&pdev->dev, 48 51 "cannot register restart handler (err=%d)\n", error); 49 - goto fail_unmap; 52 + return error; 50 53 } 51 54 52 55 return 0; 53 - 54 - fail_unmap: 55 - iounmap(sysc_base2); 56 - return error; 57 - } 58 - 59 - static void rmobile_reset_remove(struct platform_device *pdev) 60 - { 61 - unregister_restart_handler(&rmobile_reset_nb); 62 - iounmap(sysc_base2); 63 56 } 64 57 65 58 static const struct of_device_id rmobile_reset_of_match[] = { ··· 60 73 61 74 static struct platform_driver rmobile_reset_driver = { 62 75 .probe = rmobile_reset_probe, 63 - .remove_new = rmobile_reset_remove, 64 76 .driver = { 65 77 .name = "rmobile_reset", 66 78 .of_match_table = rmobile_reset_of_match,

+33 -33

drivers/power/reset/syscon-poweroff.c

··· 13 13 #include <linux/of.h> 14 14 #include <linux/platform_device.h> 15 15 #include <linux/pm.h> 16 + #include <linux/reboot.h> 16 17 #include <linux/regmap.h> 17 18 18 - static struct regmap *map; 19 - static u32 offset; 20 - static u32 value; 21 - static u32 mask; 19 + struct syscon_poweroff_data { 20 + struct regmap *map; 21 + u32 offset; 22 + u32 value; 23 + u32 mask; 24 + }; 22 25 23 - static void syscon_poweroff(void) 26 + static int syscon_poweroff(struct sys_off_data *off_data) 24 27 { 28 + struct syscon_poweroff_data *data = off_data->cb_data; 29 + 25 30 /* Issue the poweroff */ 26 - regmap_update_bits(map, offset, mask, value); 31 + regmap_update_bits(data->map, data->offset, data->mask, data->value); 27 32 28 33 mdelay(1000); 29 34 30 35 pr_emerg("Unable to poweroff system\n"); 36 + 37 + return NOTIFY_DONE; 31 38 } 32 39 33 40 static int syscon_poweroff_probe(struct platform_device *pdev) 34 41 { 35 42 struct device *dev = &pdev->dev; 43 + struct syscon_poweroff_data *data; 36 44 int mask_err, value_err; 37 45 38 - map = syscon_regmap_lookup_by_phandle(dev->of_node, "regmap"); 39 - if (IS_ERR(map)) { 40 - map = syscon_node_to_regmap(dev->parent->of_node); 41 - if (IS_ERR(map)) { 46 + data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); 47 + if (!data) 48 + return -ENOMEM; 49 + 50 + data->map = syscon_regmap_lookup_by_phandle(dev->of_node, "regmap"); 51 + if (IS_ERR(data->map)) { 52 + data->map = syscon_node_to_regmap(dev->parent->of_node); 53 + if (IS_ERR(data->map)) { 42 54 dev_err(dev, "unable to get syscon"); 43 - return PTR_ERR(map); 55 + return PTR_ERR(data->map); 44 56 } 45 57 } 46 58 47 - if (of_property_read_u32(dev->of_node, "offset", &offset)) { 59 + if (of_property_read_u32(dev->of_node, "offset", &data->offset)) { 48 60 dev_err(dev, "unable to read 'offset'"); 49 61 return -EINVAL; 50 62 } 51 63 52 - value_err = of_property_read_u32(dev->of_node, "value", &value); 53 - mask_err = of_property_read_u32(dev->of_node, "mask", &mask); 64 + value_err = of_property_read_u32(dev->of_node, "value", &data->value); 65 + mask_err = of_property_read_u32(dev->of_node, "mask", &data->mask); 54 66 if (value_err && mask_err) { 55 67 dev_err(dev, "unable to read 'value' and 'mask'"); 56 68 return -EINVAL; ··· 70 58 71 59 if (value_err) { 72 60 /* support old binding */ 73 - value = mask; 74 - mask = 0xFFFFFFFF; 61 + data->value = data->mask; 62 + data->mask = 0xFFFFFFFF; 75 63 } else if (mask_err) { 76 64 /* support value without mask*/ 77 - mask = 0xFFFFFFFF; 65 + data->mask = 0xFFFFFFFF; 78 66 } 79 67 80 - if (pm_power_off) { 81 - dev_err(dev, "pm_power_off already claimed for %ps", 82 - pm_power_off); 83 - return -EBUSY; 84 - } 85 - 86 - pm_power_off = syscon_poweroff; 87 - 88 - return 0; 89 - } 90 - 91 - static void syscon_poweroff_remove(struct platform_device *pdev) 92 - { 93 - if (pm_power_off == syscon_poweroff) 94 - pm_power_off = NULL; 68 + return devm_register_sys_off_handler(&pdev->dev, 69 + SYS_OFF_MODE_POWER_OFF, 70 + SYS_OFF_PRIO_DEFAULT, 71 + syscon_poweroff, data); 95 72 } 96 73 97 74 static const struct of_device_id syscon_poweroff_of_match[] = { ··· 90 89 91 90 static struct platform_driver syscon_poweroff_driver = { 92 91 .probe = syscon_poweroff_probe, 93 - .remove_new = syscon_poweroff_remove, 94 92 .driver = { 95 93 .name = "syscon-poweroff", 96 94 .of_match_table = syscon_poweroff_of_match,

+9 -49

drivers/power/reset/tps65086-restart.c

··· 9 9 #include <linux/platform_device.h> 10 10 #include <linux/reboot.h> 11 11 12 - struct tps65086_restart { 13 - struct notifier_block handler; 14 - struct device *dev; 15 - }; 16 - 17 - static int tps65086_restart_notify(struct notifier_block *this, 18 - unsigned long mode, void *cmd) 12 + static int tps65086_restart_notify(struct sys_off_data *data) 19 13 { 20 - struct tps65086_restart *tps65086_restart = 21 - container_of(this, struct tps65086_restart, handler); 22 - struct tps65086 *tps65086 = dev_get_drvdata(tps65086_restart->dev->parent); 14 + struct tps65086 *tps65086 = data->cb_data; 23 15 int ret; 24 16 25 17 ret = regmap_write(tps65086->regmap, TPS65086_FORCESHUTDN, 1); 26 18 if (ret) { 27 - dev_err(tps65086_restart->dev, "%s: error writing to tps65086 pmic: %d\n", 19 + dev_err(tps65086->dev, "%s: error writing to tps65086 pmic: %d\n", 28 20 __func__, ret); 29 21 return NOTIFY_DONE; 30 22 } ··· 31 39 32 40 static int tps65086_restart_probe(struct platform_device *pdev) 33 41 { 34 - struct tps65086_restart *tps65086_restart; 35 - int ret; 42 + struct tps65086 *tps65086 = dev_get_drvdata(pdev->dev.parent); 36 43 37 - tps65086_restart = devm_kzalloc(&pdev->dev, sizeof(*tps65086_restart), GFP_KERNEL); 38 - if (!tps65086_restart) 39 - return -ENOMEM; 40 - 41 - platform_set_drvdata(pdev, tps65086_restart); 42 - 43 - tps65086_restart->handler.notifier_call = tps65086_restart_notify; 44 - tps65086_restart->handler.priority = 192; 45 - tps65086_restart->dev = &pdev->dev; 46 - 47 - ret = register_restart_handler(&tps65086_restart->handler); 48 - if (ret) { 49 - dev_err(&pdev->dev, "%s: cannot register restart handler: %d\n", 50 - __func__, ret); 51 - return -ENODEV; 52 - } 53 - 54 - return 0; 55 - } 56 - 57 - static void tps65086_restart_remove(struct platform_device *pdev) 58 - { 59 - struct tps65086_restart *tps65086_restart = platform_get_drvdata(pdev); 60 - int ret; 61 - 62 - ret = unregister_restart_handler(&tps65086_restart->handler); 63 - if (ret) { 64 - /* 65 - * tps65086_restart_probe() registered the restart handler. So 66 - * unregistering should work fine. Checking the error code 67 - * shouldn't be needed, still doing it for completeness. 68 - */ 69 - dev_err(&pdev->dev, "%s: cannot unregister restart handler: %d\n", 70 - __func__, ret); 71 - } 44 + return devm_register_sys_off_handler(&pdev->dev, 45 + SYS_OFF_MODE_RESTART, 46 + SYS_OFF_PRIO_HIGH, 47 + tps65086_restart_notify, 48 + tps65086); 72 49 } 73 50 74 51 static const struct platform_device_id tps65086_restart_id_table[] = { ··· 51 90 .name = "tps65086-restart", 52 91 }, 53 92 .probe = tps65086_restart_probe, 54 - .remove_new = tps65086_restart_remove, 55 93 .id_table = tps65086_restart_id_table, 56 94 }; 57 95 module_platform_driver(tps65086_restart_driver);

+9 -16

drivers/power/reset/xgene-reboot.c

··· 22 22 23 23 struct xgene_reboot_context { 24 24 struct device *dev; 25 - void *csr; 25 + void __iomem *csr; 26 26 u32 mask; 27 - struct notifier_block restart_handler; 28 27 }; 29 28 30 - static int xgene_restart_handler(struct notifier_block *this, 31 - unsigned long mode, void *cmd) 29 + static int xgene_restart_handler(struct sys_off_data *data) 32 30 { 33 - struct xgene_reboot_context *ctx = 34 - container_of(this, struct xgene_reboot_context, 35 - restart_handler); 31 + struct xgene_reboot_context *ctx = data->cb_data; 36 32 37 33 /* Issue the reboot */ 38 34 writel(ctx->mask, ctx->csr); ··· 50 54 if (!ctx) 51 55 return -ENOMEM; 52 56 53 - ctx->csr = of_iomap(dev->of_node, 0); 54 - if (!ctx->csr) { 57 + ctx->csr = devm_platform_ioremap_resource(pdev, 0); 58 + if (IS_ERR(ctx->csr)) { 55 59 dev_err(dev, "can not map resource\n"); 56 - return -ENODEV; 60 + return PTR_ERR(ctx->csr); 57 61 } 58 62 59 63 if (of_property_read_u32(dev->of_node, "mask", &ctx->mask)) 60 64 ctx->mask = 0xFFFFFFFF; 61 65 62 66 ctx->dev = dev; 63 - ctx->restart_handler.notifier_call = xgene_restart_handler; 64 - ctx->restart_handler.priority = 128; 65 - err = register_restart_handler(&ctx->restart_handler); 66 - if (err) { 67 - iounmap(ctx->csr); 67 + err = devm_register_sys_off_handler(dev, SYS_OFF_MODE_RESTART, 128, 68 + xgene_restart_handler, ctx); 69 + if (err) 68 70 dev_err(dev, "cannot register restart handler (err=%d)\n", err); 69 - } 70 71 71 72 return err; 72 73 }

+1 -2

drivers/power/supply/ab8500_btemp.c

··· 617 617 */ 618 618 static void ab8500_btemp_external_power_changed(struct power_supply *psy) 619 619 { 620 - class_for_each_device(power_supply_class, NULL, psy, 621 - ab8500_btemp_get_ext_psy_data); 620 + power_supply_for_each_device(psy, ab8500_btemp_get_ext_psy_data); 622 621 } 623 622 624 623 /* ab8500 btemp driver interrupts and their respective isr */

+1 -2

drivers/power/supply/ab8500_chargalg.c

··· 1231 1231 int ret; 1232 1232 1233 1233 /* Collect data from all power_supply class devices */ 1234 - class_for_each_device(power_supply_class, NULL, 1235 - di->chargalg_psy, ab8500_chargalg_get_ext_psy_data); 1234 + power_supply_for_each_device(di->chargalg_psy, ab8500_chargalg_get_ext_psy_data); 1236 1235 1237 1236 ab8500_chargalg_end_of_charge(di); 1238 1237 ab8500_chargalg_check_temp(di);

+1 -2

drivers/power/supply/ab8500_charger.c

··· 1949 1949 struct ab8500_charger *di = container_of(work, 1950 1950 struct ab8500_charger, check_vbat_work.work); 1951 1951 1952 - class_for_each_device(power_supply_class, NULL, 1953 - &di->usb_chg, ab8500_charger_get_ext_psy_data); 1952 + power_supply_for_each_device(&di->usb_chg, ab8500_charger_get_ext_psy_data); 1954 1953 1955 1954 /* First run old_vbat is 0. */ 1956 1955 if (di->old_vbat == 0)

+1 -2

drivers/power/supply/ab8500_fg.c

··· 2407 2407 */ 2408 2408 static void ab8500_fg_external_power_changed(struct power_supply *psy) 2409 2409 { 2410 - class_for_each_device(power_supply_class, NULL, psy, 2411 - ab8500_fg_get_ext_psy_data); 2410 + power_supply_for_each_device(psy, ab8500_fg_get_ext_psy_data); 2412 2411 } 2413 2412 2414 2413 /**

+1 -2

drivers/power/supply/apm_power.c

··· 79 79 main_battery = NULL; 80 80 bp.main = main_battery; 81 81 82 - error = class_for_each_device(power_supply_class, NULL, &bp, 83 - __find_main_battery); 82 + error = power_supply_for_each_device(&bp, __find_main_battery); 84 83 if (error) { 85 84 main_battery = bp.main; 86 85 return;

+131 -16

drivers/power/supply/axp20x_usb_power.c

··· 50 50 const char * const *irq_names; 51 51 unsigned int num_irq_names; 52 52 const int *curr_lim_table; 53 + int curr_lim_table_size; 53 54 struct reg_field curr_lim_fld; 54 55 struct reg_field vbus_valid_bit; 55 56 struct reg_field vbus_mon_bit; 56 57 struct reg_field usb_bc_en_bit; 58 + struct reg_field usb_bc_det_fld; 57 59 struct reg_field vbus_disable_bit; 58 60 bool vbus_needs_polling: 1; 59 61 }; 60 62 61 63 struct axp20x_usb_power { 64 + struct device *dev; 62 65 struct regmap *regmap; 63 66 struct regmap_field *curr_lim_fld; 64 67 struct regmap_field *vbus_valid_bit; 65 68 struct regmap_field *vbus_mon_bit; 66 69 struct regmap_field *usb_bc_en_bit; 70 + struct regmap_field *usb_bc_det_fld; 67 71 struct regmap_field *vbus_disable_bit; 68 72 struct power_supply *supply; 69 73 const struct axp_data *axp_data; ··· 119 115 if (val != power->old_status) 120 116 power_supply_changed(power->supply); 121 117 118 + if (power->usb_bc_en_bit && (val & AXP20X_PWR_STATUS_VBUS_PRESENT) != 119 + (power->old_status & AXP20X_PWR_STATUS_VBUS_PRESENT)) { 120 + dev_dbg(power->dev, "Cable status changed, re-enabling USB BC"); 121 + ret = regmap_field_write(power->usb_bc_en_bit, 1); 122 + if (ret) 123 + dev_err(power->dev, "failed to enable USB BC: errno %d", 124 + ret); 125 + } 126 + 122 127 power->old_status = val; 123 128 power->online = val & AXP20X_PWR_STATUS_VBUS_USED; 124 129 125 130 out: 126 131 if (axp20x_usb_vbus_needs_polling(power)) 127 132 mod_delayed_work(system_power_efficient_wq, &power->vbus_detect, DEBOUNCE_TIME); 133 + } 134 + 135 + static int axp20x_get_usb_type(struct axp20x_usb_power *power, 136 + union power_supply_propval *val) 137 + { 138 + unsigned int reg; 139 + int ret; 140 + 141 + if (!power->usb_bc_det_fld) 142 + return -EINVAL; 143 + 144 + ret = regmap_field_read(power->usb_bc_det_fld, &reg); 145 + if (ret) 146 + return ret; 147 + 148 + switch (reg) { 149 + case 1: 150 + val->intval = POWER_SUPPLY_USB_TYPE_SDP; 151 + break; 152 + case 2: 153 + val->intval = POWER_SUPPLY_USB_TYPE_CDP; 154 + break; 155 + case 3: 156 + val->intval = POWER_SUPPLY_USB_TYPE_DCP; 157 + break; 158 + default: 159 + val->intval = POWER_SUPPLY_USB_TYPE_UNKNOWN; 160 + break; 161 + } 162 + 163 + return 0; 128 164 } 129 165 130 166 static int axp20x_usb_power_get_property(struct power_supply *psy, ··· 204 160 205 161 val->intval = ret * 1700; /* 1 step = 1.7 mV */ 206 162 return 0; 207 - case POWER_SUPPLY_PROP_CURRENT_MAX: 163 + case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT: 208 164 ret = regmap_field_read(power->curr_lim_fld, &v); 209 165 if (ret) 210 166 return ret; 211 167 212 - val->intval = power->axp_data->curr_lim_table[v]; 168 + if (v < power->axp_data->curr_lim_table_size) 169 + val->intval = power->axp_data->curr_lim_table[v]; 170 + else 171 + val->intval = power->axp_data->curr_lim_table[ 172 + power->axp_data->curr_lim_table_size - 1]; 213 173 return 0; 214 174 case POWER_SUPPLY_PROP_CURRENT_NOW: 215 175 if (IS_ENABLED(CONFIG_AXP20X_ADC)) { ··· 237 189 238 190 val->intval = ret * 375; /* 1 step = 0.375 mA */ 239 191 return 0; 192 + 193 + case POWER_SUPPLY_PROP_USB_TYPE: 194 + return axp20x_get_usb_type(power, val); 240 195 default: 241 196 break; 242 197 } ··· 307 256 return -EINVAL; 308 257 } 309 258 310 - static int axp20x_usb_power_set_current_max(struct axp20x_usb_power *power, int intval) 259 + static int axp20x_usb_power_set_input_current_limit(struct axp20x_usb_power *power, 260 + int intval) 311 261 { 312 - const unsigned int max = GENMASK(power->axp_data->curr_lim_fld.msb, 313 - power->axp_data->curr_lim_fld.lsb); 262 + int ret; 263 + unsigned int reg; 264 + const unsigned int max = power->axp_data->curr_lim_table_size; 314 265 315 266 if (intval == -1) 316 267 return -EINVAL; 317 268 318 - for (unsigned int i = 0; i <= max; ++i) 319 - if (power->axp_data->curr_lim_table[i] == intval) 320 - return regmap_field_write(power->curr_lim_fld, i); 269 + /* 270 + * BC1.2 detection can cause a race condition if we try to set a current 271 + * limit while it's in progress. When it finishes it will overwrite the 272 + * current limit we just set. 273 + */ 274 + if (power->usb_bc_en_bit) { 275 + dev_dbg(power->dev, 276 + "disabling BC1.2 detection because current limit was set"); 277 + ret = regmap_field_write(power->usb_bc_en_bit, 0); 278 + if (ret) 279 + return ret; 280 + } 321 281 322 - return -EINVAL; 282 + for (reg = max - 1; reg > 0; reg--) 283 + if (power->axp_data->curr_lim_table[reg] <= intval) 284 + break; 285 + 286 + dev_dbg(power->dev, "setting input current limit reg to %d (%d uA), requested %d uA", 287 + reg, power->axp_data->curr_lim_table[reg], intval); 288 + 289 + return regmap_field_write(power->curr_lim_fld, reg); 323 290 } 324 291 325 292 static int axp20x_usb_power_set_property(struct power_supply *psy, ··· 356 287 case POWER_SUPPLY_PROP_VOLTAGE_MIN: 357 288 return axp20x_usb_power_set_voltage_min(power, val->intval); 358 289 359 - case POWER_SUPPLY_PROP_CURRENT_MAX: 360 - return axp20x_usb_power_set_current_max(power, val->intval); 290 + case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT: 291 + return axp20x_usb_power_set_input_current_limit(power, val->intval); 361 292 362 293 default: 363 294 return -EINVAL; ··· 382 313 return power->vbus_disable_bit != NULL; 383 314 384 315 return psp == POWER_SUPPLY_PROP_VOLTAGE_MIN || 385 - psp == POWER_SUPPLY_PROP_CURRENT_MAX; 316 + psp == POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT; 386 317 } 387 318 388 319 static enum power_supply_property axp20x_usb_power_properties[] = { ··· 391 322 POWER_SUPPLY_PROP_ONLINE, 392 323 POWER_SUPPLY_PROP_VOLTAGE_MIN, 393 324 POWER_SUPPLY_PROP_VOLTAGE_NOW, 394 - POWER_SUPPLY_PROP_CURRENT_MAX, 325 + POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT, 395 326 POWER_SUPPLY_PROP_CURRENT_NOW, 396 327 }; 397 328 ··· 400 331 POWER_SUPPLY_PROP_PRESENT, 401 332 POWER_SUPPLY_PROP_ONLINE, 402 333 POWER_SUPPLY_PROP_VOLTAGE_MIN, 403 - POWER_SUPPLY_PROP_CURRENT_MAX, 334 + POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT, 335 + }; 336 + 337 + static enum power_supply_property axp813_usb_power_properties[] = { 338 + POWER_SUPPLY_PROP_HEALTH, 339 + POWER_SUPPLY_PROP_PRESENT, 340 + POWER_SUPPLY_PROP_ONLINE, 341 + POWER_SUPPLY_PROP_VOLTAGE_MIN, 342 + POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT, 343 + POWER_SUPPLY_PROP_USB_TYPE, 344 + }; 345 + 346 + static enum power_supply_usb_type axp813_usb_types[] = { 347 + POWER_SUPPLY_USB_TYPE_SDP, 348 + POWER_SUPPLY_USB_TYPE_DCP, 349 + POWER_SUPPLY_USB_TYPE_CDP, 350 + POWER_SUPPLY_USB_TYPE_UNKNOWN, 404 351 }; 405 352 406 353 static const struct power_supply_desc axp20x_usb_power_desc = { ··· 437 352 .property_is_writeable = axp20x_usb_power_prop_writeable, 438 353 .get_property = axp20x_usb_power_get_property, 439 354 .set_property = axp20x_usb_power_set_property, 355 + }; 356 + 357 + static const struct power_supply_desc axp813_usb_power_desc = { 358 + .name = "axp20x-usb", 359 + .type = POWER_SUPPLY_TYPE_USB, 360 + .properties = axp813_usb_power_properties, 361 + .num_properties = ARRAY_SIZE(axp813_usb_power_properties), 362 + .property_is_writeable = axp20x_usb_power_prop_writeable, 363 + .get_property = axp20x_usb_power_get_property, 364 + .set_property = axp20x_usb_power_set_property, 365 + .usb_types = axp813_usb_types, 366 + .num_usb_types = ARRAY_SIZE(axp813_usb_types), 440 367 }; 441 368 442 369 static const char * const axp20x_irq_names[] = { ··· 485 388 }; 486 389 487 390 static int axp813_usb_curr_lim_table[] = { 391 + 100000, 392 + 500000, 488 393 900000, 489 394 1500000, 490 395 2000000, 491 396 2500000, 397 + 3000000, 398 + 3500000, 399 + 4000000, 492 400 }; 493 401 494 402 static const struct axp_data axp192_data = { ··· 501 399 .irq_names = axp20x_irq_names, 502 400 .num_irq_names = ARRAY_SIZE(axp20x_irq_names), 503 401 .curr_lim_table = axp192_usb_curr_lim_table, 402 + .curr_lim_table_size = ARRAY_SIZE(axp192_usb_curr_lim_table), 504 403 .curr_lim_fld = REG_FIELD(AXP20X_VBUS_IPSOUT_MGMT, 0, 1), 505 404 .vbus_valid_bit = REG_FIELD(AXP192_USB_OTG_STATUS, 2, 2), 506 405 .vbus_mon_bit = REG_FIELD(AXP20X_VBUS_MON, 3, 3), ··· 512 409 .irq_names = axp20x_irq_names, 513 410 .num_irq_names = ARRAY_SIZE(axp20x_irq_names), 514 411 .curr_lim_table = axp20x_usb_curr_lim_table, 412 + .curr_lim_table_size = ARRAY_SIZE(axp20x_usb_curr_lim_table), 515 413 .curr_lim_fld = REG_FIELD(AXP20X_VBUS_IPSOUT_MGMT, 0, 1), 516 414 .vbus_valid_bit = REG_FIELD(AXP20X_USB_OTG_STATUS, 2, 2), 517 415 .vbus_mon_bit = REG_FIELD(AXP20X_VBUS_MON, 3, 3), ··· 523 419 .irq_names = axp22x_irq_names, 524 420 .num_irq_names = ARRAY_SIZE(axp22x_irq_names), 525 421 .curr_lim_table = axp221_usb_curr_lim_table, 422 + .curr_lim_table_size = ARRAY_SIZE(axp221_usb_curr_lim_table), 526 423 .curr_lim_fld = REG_FIELD(AXP20X_VBUS_IPSOUT_MGMT, 0, 1), 527 424 .vbus_needs_polling = true, 528 425 }; ··· 533 428 .irq_names = axp22x_irq_names, 534 429 .num_irq_names = ARRAY_SIZE(axp22x_irq_names), 535 430 .curr_lim_table = axp20x_usb_curr_lim_table, 431 + .curr_lim_table_size = ARRAY_SIZE(axp20x_usb_curr_lim_table), 536 432 .curr_lim_fld = REG_FIELD(AXP20X_VBUS_IPSOUT_MGMT, 0, 1), 537 433 .vbus_needs_polling = true, 538 434 }; 539 435 540 436 static const struct axp_data axp813_data = { 541 - .power_desc = &axp22x_usb_power_desc, 437 + .power_desc = &axp813_usb_power_desc, 542 438 .irq_names = axp22x_irq_names, 543 439 .num_irq_names = ARRAY_SIZE(axp22x_irq_names), 544 440 .curr_lim_table = axp813_usb_curr_lim_table, 545 - .curr_lim_fld = REG_FIELD(AXP20X_VBUS_IPSOUT_MGMT, 0, 1), 441 + .curr_lim_table_size = ARRAY_SIZE(axp813_usb_curr_lim_table), 442 + .curr_lim_fld = REG_FIELD(AXP22X_CHRG_CTRL3, 4, 7), 546 443 .usb_bc_en_bit = REG_FIELD(AXP288_BC_GLOBAL, 0, 0), 444 + .usb_bc_det_fld = REG_FIELD(AXP288_BC_DET_STAT, 5, 7), 547 445 .vbus_disable_bit = REG_FIELD(AXP20X_VBUS_IPSOUT_MGMT, 7, 7), 548 446 .vbus_needs_polling = true, 549 447 }; ··· 666 558 667 559 platform_set_drvdata(pdev, power); 668 560 561 + power->dev = &pdev->dev; 669 562 power->axp_data = axp_data; 670 563 power->regmap = axp20x->regmap; 671 564 power->num_irqs = axp_data->num_irq_names; ··· 691 582 ret = axp20x_regmap_field_alloc_optional(&pdev->dev, power->regmap, 692 583 axp_data->usb_bc_en_bit, 693 584 &power->usb_bc_en_bit); 585 + if (ret) 586 + return ret; 587 + 588 + ret = axp20x_regmap_field_alloc_optional(&pdev->dev, power->regmap, 589 + axp_data->usb_bc_det_fld, 590 + &power->usb_bc_det_fld); 694 591 if (ret) 695 592 return ret; 696 593

+14 -4

drivers/power/supply/axp288_fuel_gauge.c

··· 550 550 .driver_data = (void *)AXP288_QUIRK_NO_BATTERY, 551 551 }, 552 552 { 553 - /* Intel Cherry Trail Compute Stick, Windows version */ 553 + /* Intel Bay Trail Compute Stick */ 554 554 .matches = { 555 555 DMI_MATCH(DMI_SYS_VENDOR, "Intel"), 556 - DMI_MATCH(DMI_PRODUCT_NAME, "STK1AW32SC"), 556 + /* Partial match for STCK1A32WFC STCK1A32FC, STCK1A8LFC variants */ 557 + DMI_MATCH(DMI_PRODUCT_NAME, "STCK1A"), 557 558 }, 558 559 .driver_data = (void *)AXP288_QUIRK_NO_BATTERY, 559 560 }, 560 561 { 561 - /* Intel Cherry Trail Compute Stick, version without an OS */ 562 + /* Intel Cherry Trail Compute Stick */ 562 563 .matches = { 563 564 DMI_MATCH(DMI_SYS_VENDOR, "Intel"), 564 - DMI_MATCH(DMI_PRODUCT_NAME, "STK1A32SC"), 565 + /* Partial match for STK1AW32SC and STK1A32SC variants */ 566 + DMI_MATCH(DMI_PRODUCT_NAME, "STK1A"), 565 567 }, 566 568 .driver_data = (void *)AXP288_QUIRK_NO_BATTERY, 567 569 }, ··· 600 598 DMI_MATCH(DMI_BIOS_DATE, "06/14/2018"), 601 599 }, 602 600 .driver_data = NULL, 601 + }, 602 + { 603 + /* Radxa ROCK Pi X Single Board Computer */ 604 + .matches = { 605 + DMI_MATCH(DMI_BOARD_NAME, "ROCK Pi X"), 606 + DMI_MATCH(DMI_BOARD_VENDOR, "Radxa"), 607 + }, 608 + .driver_data = (void *)AXP288_QUIRK_NO_BATTERY, 603 609 }, 604 610 { 605 611 /*

+10

drivers/power/supply/bq2415x_charger.c

··· 991 991 /* TODO: maybe add more power supply properties */ 992 992 POWER_SUPPLY_PROP_STATUS, 993 993 POWER_SUPPLY_PROP_MODEL_NAME, 994 + POWER_SUPPLY_PROP_ONLINE, 994 995 }; 995 996 996 997 static int bq2415x_power_supply_get_property(struct power_supply *psy, ··· 1017 1016 break; 1018 1017 case POWER_SUPPLY_PROP_MODEL_NAME: 1019 1018 val->strval = bq->model; 1019 + break; 1020 + case POWER_SUPPLY_PROP_ONLINE: 1021 + /* VBUS is present for all charging and fault states, 1022 + * except the 'Ready' state. 1023 + */ 1024 + ret = bq2415x_exec_command(bq, BQ2415X_CHARGE_STATUS); 1025 + if (ret < 0) 1026 + return ret; 1027 + val->intval = ret > 0; 1020 1028 break; 1021 1029 default: 1022 1030 return -EINVAL;

+35 -21

drivers/power/supply/bq27xxx_battery.c

··· 1595 1595 * Return the Design Capacity in µAh 1596 1596 * Or < 0 if something fails. 1597 1597 */ 1598 - static int bq27xxx_battery_read_dcap(struct bq27xxx_device_info *di) 1598 + static int bq27xxx_battery_read_dcap(struct bq27xxx_device_info *di, 1599 + union power_supply_propval *val) 1599 1600 { 1600 1601 int dcap; 1602 + 1603 + /* We only have to read charge design full once */ 1604 + if (di->charge_design_full > 0) { 1605 + val->intval = di->charge_design_full; 1606 + return 0; 1607 + } 1601 1608 1602 1609 if (di->opts & BQ27XXX_O_ZERO) 1603 1610 dcap = bq27xxx_read(di, BQ27XXX_REG_DCAP, true); ··· 1612 1605 dcap = bq27xxx_read(di, BQ27XXX_REG_DCAP, false); 1613 1606 1614 1607 if (dcap < 0) { 1615 - dev_dbg(di->dev, "error reading initial last measured discharge\n"); 1608 + dev_dbg(di->dev, "error reading design capacity\n"); 1616 1609 return dcap; 1617 1610 } 1618 1611 ··· 1621 1614 else 1622 1615 dcap *= 1000; 1623 1616 1624 - return dcap; 1617 + /* Save for later reads */ 1618 + di->charge_design_full = dcap; 1619 + 1620 + val->intval = dcap; 1621 + 1622 + return 0; 1625 1623 } 1626 1624 1627 1625 /* ··· 1828 1816 val_curr->intval = curr; 1829 1817 1830 1818 if (val_status) { 1831 - if (curr > 0) { 1819 + if (bq27xxx_battery_is_full(di, flags)) 1820 + val_status->intval = POWER_SUPPLY_STATUS_FULL; 1821 + else if (curr > 0) 1832 1822 val_status->intval = POWER_SUPPLY_STATUS_CHARGING; 1833 - } else if (curr < 0) { 1823 + else if (curr < 0) 1834 1824 val_status->intval = POWER_SUPPLY_STATUS_DISCHARGING; 1835 - } else { 1836 - if (bq27xxx_battery_is_full(di, flags)) 1837 - val_status->intval = POWER_SUPPLY_STATUS_FULL; 1838 - else 1839 - val_status->intval = 1840 - POWER_SUPPLY_STATUS_NOT_CHARGING; 1841 - } 1825 + else 1826 + val_status->intval = POWER_SUPPLY_STATUS_NOT_CHARGING; 1842 1827 } 1843 1828 1844 1829 return 0; ··· 1874 1865 */ 1875 1866 if (!(di->opts & BQ27XXX_O_ZERO)) 1876 1867 bq27xxx_battery_current_and_status(di, NULL, &status, &cache); 1877 - 1878 - /* We only have to read charge design full once */ 1879 - if (di->charge_design_full <= 0) 1880 - di->charge_design_full = bq27xxx_battery_read_dcap(di); 1881 1868 } 1882 1869 1883 1870 if ((di->cache.capacity != cache.capacity) || ··· 2067 2062 ret = bq27xxx_simple_value(di->cache.charge_full, val); 2068 2063 break; 2069 2064 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN: 2070 - ret = bq27xxx_simple_value(di->charge_design_full, val); 2065 + ret = bq27xxx_battery_read_dcap(di, val); 2071 2066 break; 2072 2067 /* 2073 2068 * TODO: Implement these to make registers set from ··· 2106 2101 mod_delayed_work(system_wq, &di->work, HZ / 2); 2107 2102 } 2108 2103 2104 + static void bq27xxx_battery_mutex_destroy(void *data) 2105 + { 2106 + struct mutex *lock = data; 2107 + 2108 + mutex_destroy(lock); 2109 + } 2110 + 2109 2111 int bq27xxx_battery_setup(struct bq27xxx_device_info *di) 2110 2112 { 2111 2113 struct power_supply_desc *psy_desc; ··· 2120 2108 .of_node = di->dev->of_node, 2121 2109 .drv_data = di, 2122 2110 }; 2111 + int ret; 2123 2112 2124 2113 INIT_DELAYED_WORK(&di->work, bq27xxx_battery_poll); 2125 2114 mutex_init(&di->lock); 2115 + ret = devm_add_action_or_reset(di->dev, bq27xxx_battery_mutex_destroy, 2116 + &di->lock); 2117 + if (ret) 2118 + return ret; 2126 2119 2127 2120 di->regs = bq27xxx_chip_data[di->chip].regs; 2128 2121 di->unseal_key = bq27xxx_chip_data[di->chip].unseal_key; ··· 2145 2128 psy_desc->get_property = bq27xxx_battery_get_property; 2146 2129 psy_desc->external_power_changed = bq27xxx_external_power_changed; 2147 2130 2148 - di->bat = power_supply_register_no_ws(di->dev, psy_desc, &psy_cfg); 2131 + di->bat = devm_power_supply_register_no_ws(di->dev, psy_desc, &psy_cfg); 2149 2132 if (IS_ERR(di->bat)) 2150 2133 return dev_err_probe(di->dev, PTR_ERR(di->bat), 2151 2134 "failed to register battery\n"); ··· 2173 2156 mutex_unlock(&di->lock); 2174 2157 2175 2158 cancel_delayed_work_sync(&di->work); 2176 - 2177 - power_supply_unregister(di->bat); 2178 - mutex_destroy(&di->lock); 2179 2159 } 2180 2160 EXPORT_SYMBOL_GPL(bq27xxx_battery_teardown); 2181 2161

+20 -26

drivers/power/supply/bq27xxx_battery_i2c.c

··· 13 13 14 14 #include <linux/power/bq27xxx_battery.h> 15 15 16 - static DEFINE_IDR(battery_id); 17 - static DEFINE_MUTEX(battery_mutex); 16 + static DEFINE_IDA(battery_id); 18 17 19 18 static irqreturn_t bq27xxx_battery_irq_handler_thread(int irq, void *data) 20 19 { ··· 135 136 return 0; 136 137 } 137 138 139 + static void bq27xxx_battery_i2c_devm_ida_free(void *data) 140 + { 141 + int num = (long)data; 142 + 143 + ida_free(&battery_id, num); 144 + } 145 + 138 146 static int bq27xxx_battery_i2c_probe(struct i2c_client *client) 139 147 { 140 148 const struct i2c_device_id *id = i2c_client_get_device_id(client); 141 149 struct bq27xxx_device_info *di; 142 150 int ret; 143 151 char *name; 144 - int num; 152 + long num; 145 153 146 154 /* Get new ID for the new battery device */ 147 - mutex_lock(&battery_mutex); 148 - num = idr_alloc(&battery_id, client, 0, 0, GFP_KERNEL); 149 - mutex_unlock(&battery_mutex); 155 + num = ida_alloc(&battery_id, GFP_KERNEL); 150 156 if (num < 0) 151 157 return num; 158 + ret = devm_add_action_or_reset(&client->dev, 159 + bq27xxx_battery_i2c_devm_ida_free, 160 + (void *)num); 161 + if (ret) 162 + return ret; 152 163 153 - name = devm_kasprintf(&client->dev, GFP_KERNEL, "%s-%d", id->name, num); 164 + name = devm_kasprintf(&client->dev, GFP_KERNEL, "%s-%ld", id->name, num); 154 165 if (!name) 155 - goto err_mem; 166 + return -ENOMEM; 156 167 157 168 di = devm_kzalloc(&client->dev, sizeof(*di), GFP_KERNEL); 158 169 if (!di) 159 - goto err_mem; 170 + return -ENOMEM; 160 171 161 - di->id = num; 162 172 di->dev = &client->dev; 163 173 di->chip = id->driver_data; 164 174 di->name = name; ··· 179 171 180 172 ret = bq27xxx_battery_setup(di); 181 173 if (ret) 182 - goto err_failed; 174 + return ret; 183 175 184 176 /* Schedule a polling after about 1 min */ 185 177 schedule_delayed_work(&di->work, 60 * HZ); ··· 196 188 "Unable to register IRQ %d error %d\n", 197 189 client->irq, ret); 198 190 bq27xxx_battery_teardown(di); 199 - goto err_failed; 191 + return ret; 200 192 } 201 193 } 202 194 203 195 return 0; 204 - 205 - err_mem: 206 - ret = -ENOMEM; 207 - 208 - err_failed: 209 - mutex_lock(&battery_mutex); 210 - idr_remove(&battery_id, num); 211 - mutex_unlock(&battery_mutex); 212 - 213 - return ret; 214 196 } 215 197 216 198 static void bq27xxx_battery_i2c_remove(struct i2c_client *client) ··· 211 213 free_irq(client->irq, di); 212 214 213 215 bq27xxx_battery_teardown(di); 214 - 215 - mutex_lock(&battery_mutex); 216 - idr_remove(&battery_id, di->id); 217 - mutex_unlock(&battery_mutex); 218 216 } 219 217 220 218 static const struct i2c_device_id bq27xxx_i2c_id_table[] = {

+3 -3

drivers/power/supply/da9030_battery.c

··· 530 530 531 531 da9030_battery_setup_psy(charger); 532 532 psy_cfg.drv_data = charger; 533 - charger->psy = power_supply_register(&pdev->dev, &charger->psy_desc, 534 - &psy_cfg); 533 + charger->psy = devm_power_supply_register(&pdev->dev, 534 + &charger->psy_desc, 535 + &psy_cfg); 535 536 if (IS_ERR(charger->psy)) { 536 537 ret = PTR_ERR(charger->psy); 537 538 goto err_ps_register; ··· 564 563 DA9030_EVENT_CHIOVER | DA9030_EVENT_TBAT); 565 564 cancel_delayed_work_sync(&charger->work); 566 565 da9030_set_charge(charger, 0); 567 - power_supply_unregister(charger->psy); 568 566 } 569 567 570 568 static struct platform_driver da903x_battery_driver = {

+1 -3

drivers/power/supply/da9052-battery.c

··· 622 622 } 623 623 } 624 624 625 - bat->psy = power_supply_register(&pdev->dev, &psy_desc, &psy_cfg); 625 + bat->psy = devm_power_supply_register(&pdev->dev, &psy_desc, &psy_cfg); 626 626 if (IS_ERR(bat->psy)) { 627 627 ret = PTR_ERR(bat->psy); 628 628 goto err; ··· 644 644 645 645 for (i = 0; i < ARRAY_SIZE(da9052_bat_irqs); i++) 646 646 da9052_free_irq(bat->da9052, da9052_bat_irq_bits[i], bat); 647 - 648 - power_supply_unregister(bat->psy); 649 647 } 650 648 651 649 static struct platform_driver da9052_bat_driver = {

+18 -54

drivers/power/supply/da9150-charger.c

··· 521 521 charger->dev = dev; 522 522 523 523 /* Acquire ADC channels */ 524 - charger->ibus_chan = iio_channel_get(dev, "CHAN_IBUS"); 525 - if (IS_ERR(charger->ibus_chan)) { 526 - ret = PTR_ERR(charger->ibus_chan); 527 - goto ibus_chan_fail; 528 - } 524 + charger->ibus_chan = devm_iio_channel_get(dev, "CHAN_IBUS"); 525 + if (IS_ERR(charger->ibus_chan)) 526 + return PTR_ERR(charger->ibus_chan); 529 527 530 - charger->vbus_chan = iio_channel_get(dev, "CHAN_VBUS"); 531 - if (IS_ERR(charger->vbus_chan)) { 532 - ret = PTR_ERR(charger->vbus_chan); 533 - goto vbus_chan_fail; 534 - } 528 + charger->vbus_chan = devm_iio_channel_get(dev, "CHAN_VBUS"); 529 + if (IS_ERR(charger->vbus_chan)) 530 + return PTR_ERR(charger->vbus_chan); 535 531 536 - charger->tjunc_chan = iio_channel_get(dev, "CHAN_TJUNC"); 537 - if (IS_ERR(charger->tjunc_chan)) { 538 - ret = PTR_ERR(charger->tjunc_chan); 539 - goto tjunc_chan_fail; 540 - } 532 + charger->tjunc_chan = devm_iio_channel_get(dev, "CHAN_TJUNC"); 533 + if (IS_ERR(charger->tjunc_chan)) 534 + return PTR_ERR(charger->tjunc_chan); 541 535 542 - charger->vbat_chan = iio_channel_get(dev, "CHAN_VBAT"); 543 - if (IS_ERR(charger->vbat_chan)) { 544 - ret = PTR_ERR(charger->vbat_chan); 545 - goto vbat_chan_fail; 546 - } 536 + charger->vbat_chan = devm_iio_channel_get(dev, "CHAN_VBAT"); 537 + if (IS_ERR(charger->vbat_chan)) 538 + return PTR_ERR(charger->vbat_chan); 547 539 548 540 /* Register power supplies */ 549 - charger->usb = power_supply_register(dev, &usb_desc, NULL); 550 - if (IS_ERR(charger->usb)) { 551 - ret = PTR_ERR(charger->usb); 552 - goto usb_fail; 553 - } 541 + charger->usb = devm_power_supply_register(dev, &usb_desc, NULL); 542 + if (IS_ERR(charger->usb)) 543 + return PTR_ERR(charger->usb); 554 544 555 - charger->battery = power_supply_register(dev, &battery_desc, NULL); 556 - if (IS_ERR(charger->battery)) { 557 - ret = PTR_ERR(charger->battery); 558 - goto battery_fail; 559 - } 545 + charger->battery = devm_power_supply_register(dev, &battery_desc, NULL); 546 + if (IS_ERR(charger->battery)) 547 + return PTR_ERR(charger->battery); 560 548 561 549 /* Get initial online supply */ 562 550 reg = da9150_reg_read(da9150, DA9150_STATUS_H); ··· 604 616 chg_irq_fail: 605 617 if (!IS_ERR_OR_NULL(charger->usb_phy)) 606 618 usb_unregister_notifier(charger->usb_phy, &charger->otg_nb); 607 - battery_fail: 608 - power_supply_unregister(charger->usb); 609 619 610 - usb_fail: 611 - iio_channel_release(charger->vbat_chan); 612 - 613 - vbat_chan_fail: 614 - iio_channel_release(charger->tjunc_chan); 615 - 616 - tjunc_chan_fail: 617 - iio_channel_release(charger->vbus_chan); 618 - 619 - vbus_chan_fail: 620 - iio_channel_release(charger->ibus_chan); 621 - 622 - ibus_chan_fail: 623 620 return ret; 624 621 } 625 622 ··· 629 656 if (!IS_ERR_OR_NULL(charger->usb_phy)) 630 657 usb_unregister_notifier(charger->usb_phy, &charger->otg_nb); 631 658 cancel_work_sync(&charger->otg_work); 632 - 633 - power_supply_unregister(charger->battery); 634 - power_supply_unregister(charger->usb); 635 - 636 - /* Release ADC channels */ 637 - iio_channel_release(charger->ibus_chan); 638 - iio_channel_release(charger->vbus_chan); 639 - iio_channel_release(charger->tjunc_chan); 640 - iio_channel_release(charger->vbat_chan); 641 659 } 642 660 643 661 static struct platform_driver da9150_charger_driver = {

+1 -3

drivers/power/supply/ds2760_battery.c

··· 739 739 if (current_accum) 740 740 ds2760_battery_set_current_accum(di, current_accum); 741 741 742 - di->bat = power_supply_register(dev, &di->bat_desc, &psy_cfg); 742 + di->bat = devm_power_supply_register(dev, &di->bat_desc, &psy_cfg); 743 743 if (IS_ERR(di->bat)) { 744 744 dev_err(di->dev, "failed to register battery\n"); 745 745 retval = PTR_ERR(di->bat); ··· 762 762 goto success; 763 763 764 764 workqueue_failed: 765 - power_supply_unregister(di->bat); 766 765 batt_failed: 767 766 di_alloc_failed: 768 767 success: ··· 776 777 cancel_delayed_work_sync(&di->monitor_work); 777 778 cancel_delayed_work_sync(&di->set_charged_work); 778 779 destroy_workqueue(di->monitor_wqueue); 779 - power_supply_unregister(di->bat); 780 780 } 781 781 782 782 #ifdef CONFIG_OF

+7 -17

drivers/power/supply/goldfish_battery.c

··· 232 232 233 233 psy_cfg.drv_data = data; 234 234 235 - data->ac = power_supply_register(&pdev->dev, &ac_desc, &psy_cfg); 235 + data->ac = devm_power_supply_register(&pdev->dev, 236 + &ac_desc, 237 + &psy_cfg); 236 238 if (IS_ERR(data->ac)) 237 239 return PTR_ERR(data->ac); 238 240 239 - data->battery = power_supply_register(&pdev->dev, &battery_desc, 240 - &psy_cfg); 241 - if (IS_ERR(data->battery)) { 242 - power_supply_unregister(data->ac); 241 + data->battery = devm_power_supply_register(&pdev->dev, 242 + &battery_desc, 243 + &psy_cfg); 244 + if (IS_ERR(data->battery)) 243 245 return PTR_ERR(data->battery); 244 - } 245 - 246 - platform_set_drvdata(pdev, data); 247 246 248 247 GOLDFISH_BATTERY_WRITE(data, BATTERY_INT_ENABLE, BATTERY_INT_MASK); 249 248 return 0; 250 - } 251 - 252 - static void goldfish_battery_remove(struct platform_device *pdev) 253 - { 254 - struct goldfish_battery_data *data = platform_get_drvdata(pdev); 255 - 256 - power_supply_unregister(data->battery); 257 - power_supply_unregister(data->ac); 258 249 } 259 250 260 251 static const struct of_device_id goldfish_battery_of_match[] = { ··· 264 273 265 274 static struct platform_driver goldfish_battery_device = { 266 275 .probe = goldfish_battery_probe, 267 - .remove_new = goldfish_battery_remove, 268 276 .driver = { 269 277 .name = "goldfish-battery", 270 278 .of_match_table = goldfish_battery_of_match,

+7 -28

drivers/power/supply/lp8727_charger.c

··· 453 453 psy_cfg.supplied_to = battery_supplied_to; 454 454 psy_cfg.num_supplicants = ARRAY_SIZE(battery_supplied_to); 455 455 456 - psy->ac = power_supply_register(pchg->dev, &lp8727_ac_desc, &psy_cfg); 456 + psy->ac = devm_power_supply_register(pchg->dev, &lp8727_ac_desc, &psy_cfg); 457 457 if (IS_ERR(psy->ac)) 458 - goto err_psy_ac; 458 + return -EPERM; 459 459 460 - psy->usb = power_supply_register(pchg->dev, &lp8727_usb_desc, 461 - &psy_cfg); 460 + psy->usb = devm_power_supply_register(pchg->dev, &lp8727_usb_desc, 461 + &psy_cfg); 462 462 if (IS_ERR(psy->usb)) 463 - goto err_psy_usb; 463 + return -EPERM; 464 464 465 - psy->batt = power_supply_register(pchg->dev, &lp8727_batt_desc, NULL); 465 + psy->batt = devm_power_supply_register(pchg->dev, &lp8727_batt_desc, NULL); 466 466 if (IS_ERR(psy->batt)) 467 - goto err_psy_batt; 467 + return -EPERM; 468 468 469 469 return 0; 470 - 471 - err_psy_batt: 472 - power_supply_unregister(psy->usb); 473 - err_psy_usb: 474 - power_supply_unregister(psy->ac); 475 - err_psy_ac: 476 - return -EPERM; 477 - } 478 - 479 - static void lp8727_unregister_psy(struct lp8727_chg *pchg) 480 - { 481 - struct lp8727_psy *psy = pchg->psy; 482 - 483 - if (!psy) 484 - return; 485 - 486 - power_supply_unregister(psy->ac); 487 - power_supply_unregister(psy->usb); 488 - power_supply_unregister(psy->batt); 489 470 } 490 471 491 472 #ifdef CONFIG_OF ··· 564 583 ret = lp8727_setup_irq(pchg); 565 584 if (ret) { 566 585 dev_err(pchg->dev, "irq handler err: %d", ret); 567 - lp8727_unregister_psy(pchg); 568 586 return ret; 569 587 } 570 588 ··· 575 595 struct lp8727_chg *pchg = i2c_get_clientdata(cl); 576 596 577 597 lp8727_release_irq(pchg); 578 - lp8727_unregister_psy(pchg); 579 598 } 580 599 581 600 static const struct of_device_id lp8727_dt_ids[] __maybe_unused = {

+6 -15

drivers/power/supply/lp8788-charger.c

··· 406 406 .get_property = lp8788_battery_get_property, 407 407 }; 408 408 409 - static void lp8788_psy_unregister(struct lp8788_charger *pchg) 410 - { 411 - power_supply_unregister(pchg->battery); 412 - power_supply_unregister(pchg->charger); 413 - } 414 - 415 409 static void lp8788_charger_event(struct work_struct *work) 416 410 { 417 411 struct lp8788_charger *pchg = ··· 660 666 charger_cfg.supplied_to = battery_supplied_to; 661 667 charger_cfg.num_supplicants = ARRAY_SIZE(battery_supplied_to); 662 668 663 - pchg->charger = power_supply_register(&pdev->dev, 664 - &lp8788_psy_charger_desc, 665 - &charger_cfg); 669 + pchg->charger = devm_power_supply_register(&pdev->dev, 670 + &lp8788_psy_charger_desc, 671 + &charger_cfg); 666 672 if (IS_ERR(pchg->charger)) 667 673 return -EPERM; 668 674 669 - pchg->battery = power_supply_register(&pdev->dev, 670 - &lp8788_psy_battery_desc, NULL); 671 - if (IS_ERR(pchg->battery)) { 672 - power_supply_unregister(pchg->charger); 675 + pchg->battery = devm_power_supply_register(&pdev->dev, 676 + &lp8788_psy_battery_desc, NULL); 677 + if (IS_ERR(pchg->battery)) 673 678 return -EPERM; 674 - } 675 679 676 680 return 0; 677 681 } ··· 712 720 713 721 flush_work(&pchg->charger_work); 714 722 lp8788_irq_unregister(pdev, pchg); 715 - lp8788_psy_unregister(pchg); 716 723 } 717 724 718 725 static struct platform_driver lp8788_charger_driver = {

+3 -5

drivers/power/supply/max14577_charger.c

··· 586 586 } 587 587 588 588 psy_cfg.drv_data = chg; 589 - chg->charger = power_supply_register(&pdev->dev, &max14577_charger_desc, 590 - &psy_cfg); 589 + chg->charger = devm_power_supply_register(&pdev->dev, 590 + &max14577_charger_desc, 591 + &psy_cfg); 591 592 if (IS_ERR(chg->charger)) { 592 593 dev_err(&pdev->dev, "failed: power supply register\n"); 593 594 ret = PTR_ERR(chg->charger); ··· 609 608 610 609 static void max14577_charger_remove(struct platform_device *pdev) 611 610 { 612 - struct max14577_charger *chg = platform_get_drvdata(pdev); 613 - 614 611 device_remove_file(&pdev->dev, &dev_attr_fast_charge_timer); 615 - power_supply_unregister(chg->charger); 616 612 } 617 613 618 614 static const struct platform_device_id max14577_charger_id[] = {

+3 -7

drivers/power/supply/max77693_charger.c

··· 709 709 goto err; 710 710 } 711 711 712 - chg->charger = power_supply_register(&pdev->dev, 713 - &max77693_charger_desc, 714 - &psy_cfg); 712 + chg->charger = devm_power_supply_register(&pdev->dev, 713 + &max77693_charger_desc, 714 + &psy_cfg); 715 715 if (IS_ERR(chg->charger)) { 716 716 dev_err(&pdev->dev, "failed: power supply register\n"); 717 717 ret = PTR_ERR(chg->charger); ··· 730 730 731 731 static void max77693_charger_remove(struct platform_device *pdev) 732 732 { 733 - struct max77693_charger *chg = platform_get_drvdata(pdev); 734 - 735 733 device_remove_file(&pdev->dev, &dev_attr_top_off_timer); 736 734 device_remove_file(&pdev->dev, &dev_attr_top_off_threshold_current); 737 735 device_remove_file(&pdev->dev, &dev_attr_fast_charge_timer); 738 - 739 - power_supply_unregister(chg->charger); 740 736 } 741 737 742 738 static const struct platform_device_id max77693_charger_id[] = {

+10 -27

drivers/power/supply/max8925_power.c

··· 507 507 struct power_supply_config psy_cfg = {}; /* Only for ac and usb */ 508 508 struct max8925_power_pdata *pdata = NULL; 509 509 struct max8925_power_info *info; 510 - int ret; 511 510 512 511 pdata = max8925_power_dt_init(pdev); 513 512 if (!pdata) { ··· 527 528 psy_cfg.supplied_to = pdata->supplied_to; 528 529 psy_cfg.num_supplicants = pdata->num_supplicants; 529 530 530 - info->ac = power_supply_register(&pdev->dev, &ac_desc, &psy_cfg); 531 - if (IS_ERR(info->ac)) { 532 - ret = PTR_ERR(info->ac); 533 - goto out; 534 - } 531 + info->ac = devm_power_supply_register(&pdev->dev, &ac_desc, &psy_cfg); 532 + if (IS_ERR(info->ac)) 533 + return PTR_ERR(info->ac); 535 534 info->ac->dev.parent = &pdev->dev; 536 535 537 - info->usb = power_supply_register(&pdev->dev, &usb_desc, &psy_cfg); 538 - if (IS_ERR(info->usb)) { 539 - ret = PTR_ERR(info->usb); 540 - goto out_unregister_ac; 541 - } 536 + info->usb = devm_power_supply_register(&pdev->dev, &usb_desc, &psy_cfg); 537 + if (IS_ERR(info->usb)) 538 + return PTR_ERR(info->usb); 542 539 info->usb->dev.parent = &pdev->dev; 543 540 544 - info->battery = power_supply_register(&pdev->dev, &battery_desc, NULL); 545 - if (IS_ERR(info->battery)) { 546 - ret = PTR_ERR(info->battery); 547 - goto out_unregister_usb; 548 - } 541 + info->battery = devm_power_supply_register(&pdev->dev, &battery_desc, NULL); 542 + if (IS_ERR(info->battery)) 543 + return PTR_ERR(info->battery); 549 544 info->battery->dev.parent = &pdev->dev; 550 545 551 546 info->batt_detect = pdata->batt_detect; ··· 551 558 552 559 max8925_init_charger(chip, info); 553 560 return 0; 554 - out_unregister_usb: 555 - power_supply_unregister(info->usb); 556 - out_unregister_ac: 557 - power_supply_unregister(info->ac); 558 - out: 559 - return ret; 560 561 } 561 562 562 563 static void max8925_power_remove(struct platform_device *pdev) 563 564 { 564 565 struct max8925_power_info *info = platform_get_drvdata(pdev); 565 566 566 - if (info) { 567 - power_supply_unregister(info->ac); 568 - power_supply_unregister(info->usb); 569 - power_supply_unregister(info->battery); 567 + if (info) 570 568 max8925_deinit_charger(info); 571 - } 572 569 } 573 570 574 571 static struct platform_driver max8925_power_driver = {

+2 -11

drivers/power/supply/mm8013.c

··· 71 71 72 72 static enum power_supply_property mm8013_battery_props[] = { 73 73 POWER_SUPPLY_PROP_CAPACITY, 74 - POWER_SUPPLY_PROP_CHARGE_BEHAVIOUR, 75 74 POWER_SUPPLY_PROP_CHARGE_FULL, 76 75 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, 77 76 POWER_SUPPLY_PROP_CHARGE_NOW, ··· 101 102 return ret; 102 103 103 104 val->intval = regval; 104 - break; 105 - case POWER_SUPPLY_PROP_CHARGE_BEHAVIOUR: 106 - ret = regmap_read(chip->regmap, REG_FLAGS, &regval); 107 - if (ret < 0) 108 - return ret; 109 - 110 - if (regval & MM8013_FLAG_CHG_INH) 111 - val->intval = POWER_SUPPLY_CHARGE_BEHAVIOUR_INHIBIT_CHARGE; 112 - else 113 - val->intval = POWER_SUPPLY_CHARGE_BEHAVIOUR_AUTO; 114 105 break; 115 106 case POWER_SUPPLY_PROP_CHARGE_FULL: 116 107 ret = regmap_read(chip->regmap, REG_FULL_CHARGE_CAPACITY, &regval); ··· 176 187 177 188 if (regval & MM8013_FLAG_DSG) 178 189 val->intval = POWER_SUPPLY_STATUS_DISCHARGING; 190 + else if (regval & MM8013_FLAG_CHG_INH) 191 + val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING; 179 192 else if (regval & MM8013_FLAG_CHG) 180 193 val->intval = POWER_SUPPLY_STATUS_CHARGING; 181 194 else if (regval & MM8013_FLAG_FC)

+9 -14

drivers/power/supply/pcf50633-charger.c

··· 404 404 psy_cfg.drv_data = mbc; 405 405 406 406 /* Create power supplies */ 407 - mbc->adapter = power_supply_register(&pdev->dev, 408 - &pcf50633_mbc_adapter_desc, 409 - &psy_cfg); 407 + mbc->adapter = devm_power_supply_register(&pdev->dev, 408 + &pcf50633_mbc_adapter_desc, 409 + &psy_cfg); 410 410 if (IS_ERR(mbc->adapter)) { 411 411 dev_err(mbc->pcf->dev, "failed to register adapter\n"); 412 412 return PTR_ERR(mbc->adapter); ··· 415 415 usb_psy_cfg = psy_cfg; 416 416 usb_psy_cfg.attr_grp = pcf50633_mbc_sysfs_groups; 417 417 418 - mbc->usb = power_supply_register(&pdev->dev, &pcf50633_mbc_usb_desc, 419 - &usb_psy_cfg); 418 + mbc->usb = devm_power_supply_register(&pdev->dev, 419 + &pcf50633_mbc_usb_desc, 420 + &usb_psy_cfg); 420 421 if (IS_ERR(mbc->usb)) { 421 422 dev_err(mbc->pcf->dev, "failed to register usb\n"); 422 - power_supply_unregister(mbc->adapter); 423 423 return PTR_ERR(mbc->usb); 424 424 } 425 425 426 - mbc->ac = power_supply_register(&pdev->dev, &pcf50633_mbc_ac_desc, 427 - &psy_cfg); 426 + mbc->ac = devm_power_supply_register(&pdev->dev, 427 + &pcf50633_mbc_ac_desc, 428 + &psy_cfg); 428 429 if (IS_ERR(mbc->ac)) { 429 430 dev_err(mbc->pcf->dev, "failed to register ac\n"); 430 - power_supply_unregister(mbc->adapter); 431 - power_supply_unregister(mbc->usb); 432 431 return PTR_ERR(mbc->ac); 433 432 } 434 433 ··· 448 449 /* Remove IRQ handlers */ 449 450 for (i = 0; i < ARRAY_SIZE(mbc_irq_handlers); i++) 450 451 pcf50633_free_irq(mbc->pcf, mbc_irq_handlers[i]); 451 - 452 - power_supply_unregister(mbc->usb); 453 - power_supply_unregister(mbc->adapter); 454 - power_supply_unregister(mbc->ac); 455 452 } 456 453 457 454 static struct platform_driver pcf50633_mbc_driver = {

+4 -2

drivers/power/supply/power_supply.h

··· 15 15 16 16 #ifdef CONFIG_SYSFS 17 17 18 - extern void power_supply_init_attrs(struct device_type *dev_type); 18 + extern void power_supply_init_attrs(void); 19 19 extern int power_supply_uevent(const struct device *dev, struct kobj_uevent_env *env); 20 + extern const struct attribute_group *power_supply_attr_groups[]; 20 21 21 22 #else 22 23 23 - static inline void power_supply_init_attrs(struct device_type *dev_type) {} 24 + static inline void power_supply_init_attrs(void) {} 25 + #define power_supply_attr_groups NULL 24 26 #define power_supply_uevent NULL 25 27 26 28 #endif /* CONFIG_SYSFS */

+31 -34

drivers/power/supply/power_supply_core.c

··· 25 25 #include "power_supply.h" 26 26 #include "samsung-sdi-battery.h" 27 27 28 - /* exported for the APM Power driver, APM emulation */ 29 - struct class *power_supply_class; 30 - EXPORT_SYMBOL_GPL(power_supply_class); 28 + static const struct class power_supply_class = { 29 + .name = "power_supply", 30 + .dev_uevent = power_supply_uevent, 31 + }; 31 32 32 33 static BLOCKING_NOTIFIER_HEAD(power_supply_notifier); 33 34 34 - static struct device_type power_supply_dev_type; 35 + static const struct device_type power_supply_dev_type = { 36 + .name = "power_supply", 37 + .groups = power_supply_attr_groups, 38 + }; 35 39 36 40 #define POWER_SUPPLY_DEFERRED_REGISTER_TIME msecs_to_jiffies(10) 37 41 ··· 97 93 if (likely(psy->changed)) { 98 94 psy->changed = false; 99 95 spin_unlock_irqrestore(&psy->changed_lock, flags); 100 - class_for_each_device(power_supply_class, NULL, psy, 101 - __power_supply_changed_work); 96 + power_supply_for_each_device(psy, __power_supply_changed_work); 102 97 power_supply_update_leds(psy); 103 98 blocking_notifier_call_chain(&power_supply_notifier, 104 99 PSY_EVENT_PROP_CHANGED, psy); ··· 114 111 pm_relax(&psy->dev); 115 112 spin_unlock_irqrestore(&psy->changed_lock, flags); 116 113 } 114 + 115 + int power_supply_for_each_device(void *data, int (*fn)(struct device *dev, void *data)) 116 + { 117 + return class_for_each_device(&power_supply_class, NULL, data, fn); 118 + } 119 + EXPORT_SYMBOL_GPL(power_supply_for_each_device); 117 120 118 121 void power_supply_changed(struct power_supply *psy) 119 122 { ··· 196 187 { 197 188 int error; 198 189 199 - error = class_for_each_device(power_supply_class, NULL, psy, 200 - __power_supply_populate_supplied_from); 190 + error = power_supply_for_each_device(psy, __power_supply_populate_supplied_from); 201 191 202 192 dev_dbg(&psy->dev, "%s %d\n", __func__, error); 203 193 ··· 209 201 struct device_node *np = data; 210 202 struct power_supply *epsy = dev_get_drvdata(dev); 211 203 212 - /* returning non-zero breaks out of class_for_each_device loop */ 204 + /* returning non-zero breaks out of power_supply_for_each_device loop */ 213 205 if (epsy->of_node == np) 214 206 return 1; 215 207 ··· 221 213 int error; 222 214 223 215 /* 224 - * class_for_each_device() either returns its own errors or values 216 + * power_supply_for_each_device() either returns its own errors or values 225 217 * returned by __power_supply_find_supply_from_node(). 226 218 * 227 219 * __power_supply_find_supply_from_node() will return 0 (no match) 228 220 * or 1 (match). 229 221 * 230 - * We return 0 if class_for_each_device() returned 1, -EPROBE_DEFER if 222 + * We return 0 if power_supply_for_each_device() returned 1, -EPROBE_DEFER if 231 223 * it returned 0, or error as returned by it. 232 224 */ 233 - error = class_for_each_device(power_supply_class, NULL, supply_node, 234 - __power_supply_find_supply_from_node); 225 + error = power_supply_for_each_device(supply_node, __power_supply_find_supply_from_node); 235 226 236 227 return error ? (error == 1 ? 0 : error) : -EPROBE_DEFER; 237 228 } ··· 336 329 struct psy_am_i_supplied_data data = { psy, 0 }; 337 330 int error; 338 331 339 - error = class_for_each_device(power_supply_class, NULL, &data, 340 - __power_supply_am_i_supplied); 332 + error = power_supply_for_each_device(&data, __power_supply_am_i_supplied); 341 333 342 334 dev_dbg(&psy->dev, "%s count %u err %d\n", __func__, data.count, error); 343 335 ··· 371 365 int error; 372 366 unsigned int count = 0; 373 367 374 - error = class_for_each_device(power_supply_class, NULL, &count, 375 - __power_supply_is_system_supplied); 368 + error = power_supply_for_each_device(&count, __power_supply_is_system_supplied); 376 369 377 370 /* 378 371 * If no system scope power class device was found at all, most probably we ··· 417 412 * This function is not intended for use with a supply with multiple 418 413 * suppliers, we simply pick the first supply to report the psp. 419 414 */ 420 - ret = class_for_each_device(power_supply_class, NULL, &data, 421 - __power_supply_get_supplier_property); 415 + ret = power_supply_for_each_device(&data, __power_supply_get_supplier_property); 422 416 if (ret < 0) 423 417 return ret; 424 418 if (ret == 0) ··· 462 458 struct power_supply *power_supply_get_by_name(const char *name) 463 459 { 464 460 struct power_supply *psy = NULL; 465 - struct device *dev = class_find_device(power_supply_class, NULL, name, 466 - power_supply_match_device_by_name); 461 + struct device *dev = class_find_device(&power_supply_class, NULL, name, 462 + power_supply_match_device_by_name); 467 463 468 464 if (dev) { 469 465 psy = dev_get_drvdata(dev); ··· 519 515 if (!power_supply_np) 520 516 return ERR_PTR(-ENODEV); 521 517 522 - dev = class_find_device(power_supply_class, NULL, power_supply_np, 523 - power_supply_match_device_node); 518 + dev = class_find_device(&power_supply_class, NULL, power_supply_np, 519 + power_supply_match_device_node); 524 520 525 521 of_node_put(power_supply_np); 526 522 ··· 1373 1369 1374 1370 device_initialize(dev); 1375 1371 1376 - dev->class = power_supply_class; 1372 + dev->class = &power_supply_class; 1377 1373 dev->type = &power_supply_dev_type; 1378 1374 dev->parent = parent; 1379 1375 dev->release = power_supply_dev_release; ··· 1621 1617 1622 1618 static int __init power_supply_class_init(void) 1623 1619 { 1624 - power_supply_class = class_create("power_supply"); 1625 - 1626 - if (IS_ERR(power_supply_class)) 1627 - return PTR_ERR(power_supply_class); 1628 - 1629 - power_supply_class->dev_uevent = power_supply_uevent; 1630 - power_supply_init_attrs(&power_supply_dev_type); 1631 - 1632 - return 0; 1620 + power_supply_init_attrs(); 1621 + return class_register(&power_supply_class); 1633 1622 } 1634 1623 1635 1624 static void __exit power_supply_class_exit(void) 1636 1625 { 1637 - class_destroy(power_supply_class); 1626 + class_unregister(&power_supply_class); 1638 1627 } 1639 1628 1640 1629 subsys_initcall(power_supply_class_init);

+29 -11

drivers/power/supply/power_supply_sysfs.c

··· 271 271 return count; 272 272 } 273 273 274 + static ssize_t power_supply_show_charge_behaviour(struct device *dev, 275 + struct power_supply *psy, 276 + union power_supply_propval *value, 277 + char *buf) 278 + { 279 + int ret; 280 + 281 + ret = power_supply_get_property(psy, 282 + POWER_SUPPLY_PROP_CHARGE_BEHAVIOUR, 283 + value); 284 + if (ret < 0) 285 + return ret; 286 + 287 + return power_supply_charge_behaviour_show(dev, psy->desc->charge_behaviours, 288 + value->intval, buf); 289 + } 290 + 274 291 static ssize_t power_supply_show_property(struct device *dev, 275 292 struct device_attribute *attr, 276 293 char *buf) { ··· 315 298 } 316 299 } 317 300 318 - if (ps_attr->text_values_len > 0 && 319 - value.intval < ps_attr->text_values_len && value.intval >= 0) { 320 - return sysfs_emit(buf, "%s\n", ps_attr->text_values[value.intval]); 321 - } 322 - 323 301 switch (psp) { 324 302 case POWER_SUPPLY_PROP_USB_TYPE: 325 303 ret = power_supply_show_usb_type(dev, psy->desc, 326 304 &value, buf); 327 305 break; 306 + case POWER_SUPPLY_PROP_CHARGE_BEHAVIOUR: 307 + ret = power_supply_show_charge_behaviour(dev, psy, &value, buf); 308 + break; 328 309 case POWER_SUPPLY_PROP_MODEL_NAME ... POWER_SUPPLY_PROP_SERIAL_NUMBER: 329 310 ret = sysfs_emit(buf, "%s\n", value.strval); 330 311 break; 331 312 default: 332 - ret = sysfs_emit(buf, "%d\n", value.intval); 313 + if (ps_attr->text_values_len > 0 && 314 + value.intval < ps_attr->text_values_len && value.intval >= 0) { 315 + ret = sysfs_emit(buf, "%s\n", ps_attr->text_values[value.intval]); 316 + } else { 317 + ret = sysfs_emit(buf, "%d\n", value.intval); 318 + } 333 319 } 334 320 335 321 return ret; ··· 414 394 .is_visible = power_supply_attr_is_visible, 415 395 }; 416 396 417 - static const struct attribute_group *power_supply_attr_groups[] = { 397 + const struct attribute_group *power_supply_attr_groups[] = { 418 398 &power_supply_attr_group, 419 - NULL, 399 + NULL 420 400 }; 421 401 422 - void power_supply_init_attrs(struct device_type *dev_type) 402 + void power_supply_init_attrs(void) 423 403 { 424 404 int i; 425 - 426 - dev_type->groups = power_supply_attr_groups; 427 405 428 406 for (i = 0; i < ARRAY_SIZE(power_supply_attrs); i++) { 429 407 struct device_attribute *attr;

+3 -11

drivers/power/supply/rt5033_battery.c

··· 159 159 return -EINVAL; 160 160 } 161 161 162 - i2c_set_clientdata(client, battery); 163 162 psy_cfg.of_node = client->dev.of_node; 164 163 psy_cfg.drv_data = battery; 165 164 166 - battery->psy = power_supply_register(&client->dev, 167 - &rt5033_battery_desc, &psy_cfg); 165 + battery->psy = devm_power_supply_register(&client->dev, 166 + &rt5033_battery_desc, 167 + &psy_cfg); 168 168 if (IS_ERR(battery->psy)) 169 169 return dev_err_probe(&client->dev, PTR_ERR(battery->psy), 170 170 "Failed to register power supply\n"); 171 171 172 172 return 0; 173 - } 174 - 175 - static void rt5033_battery_remove(struct i2c_client *client) 176 - { 177 - struct rt5033_battery *battery = i2c_get_clientdata(client); 178 - 179 - power_supply_unregister(battery->psy); 180 173 } 181 174 182 175 static const struct i2c_device_id rt5033_battery_id[] = { ··· 190 197 .of_match_table = rt5033_battery_of_match, 191 198 }, 192 199 .probe = rt5033_battery_probe, 193 - .remove = rt5033_battery_remove, 194 200 .id_table = rt5033_battery_id, 195 201 }; 196 202 module_i2c_driver(rt5033_battery_driver);

+12 -45

drivers/power/supply/rx51_battery.c

··· 192 192 { 193 193 struct power_supply_config psy_cfg = {}; 194 194 struct rx51_device_info *di; 195 - int ret; 196 195 197 196 di = devm_kzalloc(&pdev->dev, sizeof(*di), GFP_KERNEL); 198 197 if (!di) 199 198 return -ENOMEM; 200 - 201 - platform_set_drvdata(pdev, di); 202 199 203 200 di->dev = &pdev->dev; 204 201 di->bat_desc.name = "rx51-battery"; ··· 206 209 207 210 psy_cfg.drv_data = di; 208 211 209 - di->channel_temp = iio_channel_get(di->dev, "temp"); 210 - if (IS_ERR(di->channel_temp)) { 211 - ret = PTR_ERR(di->channel_temp); 212 - goto error; 213 - } 212 + di->channel_temp = devm_iio_channel_get(di->dev, "temp"); 213 + if (IS_ERR(di->channel_temp)) 214 + return PTR_ERR(di->channel_temp); 214 215 215 - di->channel_bsi = iio_channel_get(di->dev, "bsi"); 216 - if (IS_ERR(di->channel_bsi)) { 217 - ret = PTR_ERR(di->channel_bsi); 218 - goto error_channel_temp; 219 - } 216 + di->channel_bsi = devm_iio_channel_get(di->dev, "bsi"); 217 + if (IS_ERR(di->channel_bsi)) 218 + return PTR_ERR(di->channel_bsi); 220 219 221 - di->channel_vbat = iio_channel_get(di->dev, "vbat"); 222 - if (IS_ERR(di->channel_vbat)) { 223 - ret = PTR_ERR(di->channel_vbat); 224 - goto error_channel_bsi; 225 - } 220 + di->channel_vbat = devm_iio_channel_get(di->dev, "vbat"); 221 + if (IS_ERR(di->channel_vbat)) 222 + return PTR_ERR(di->channel_vbat); 226 223 227 - di->bat = power_supply_register(di->dev, &di->bat_desc, &psy_cfg); 228 - if (IS_ERR(di->bat)) { 229 - ret = PTR_ERR(di->bat); 230 - goto error_channel_vbat; 231 - } 224 + di->bat = devm_power_supply_register(di->dev, &di->bat_desc, &psy_cfg); 225 + if (IS_ERR(di->bat)) 226 + return PTR_ERR(di->bat); 232 227 233 228 return 0; 234 - 235 - error_channel_vbat: 236 - iio_channel_release(di->channel_vbat); 237 - error_channel_bsi: 238 - iio_channel_release(di->channel_bsi); 239 - error_channel_temp: 240 - iio_channel_release(di->channel_temp); 241 - error: 242 - 243 - return ret; 244 - } 245 - 246 - static void rx51_battery_remove(struct platform_device *pdev) 247 - { 248 - struct rx51_device_info *di = platform_get_drvdata(pdev); 249 - 250 - power_supply_unregister(di->bat); 251 - 252 - iio_channel_release(di->channel_vbat); 253 - iio_channel_release(di->channel_bsi); 254 - iio_channel_release(di->channel_temp); 255 229 } 256 230 257 231 #ifdef CONFIG_OF ··· 235 267 236 268 static struct platform_driver rx51_battery_driver = { 237 269 .probe = rx51_battery_probe, 238 - .remove_new = rx51_battery_remove, 239 270 .driver = { 240 271 .name = "rx51-battery", 241 272 .of_match_table = of_match_ptr(n900_battery_of_match),

+6 -12

drivers/power/supply/tps65090-charger.c

··· 262 262 psy_cfg.of_node = pdev->dev.of_node; 263 263 psy_cfg.drv_data = cdata; 264 264 265 - cdata->ac = power_supply_register(&pdev->dev, &tps65090_charger_desc, 265 + cdata->ac = devm_power_supply_register(&pdev->dev, &tps65090_charger_desc, 266 266 &psy_cfg); 267 267 if (IS_ERR(cdata->ac)) { 268 268 dev_err(&pdev->dev, "failed: power supply register\n"); ··· 277 277 ret = tps65090_config_charger(cdata); 278 278 if (ret < 0) { 279 279 dev_err(&pdev->dev, "charger config failed, err %d\n", ret); 280 - goto fail_unregister_supply; 280 + return ret; 281 281 } 282 282 283 283 /* Check for charger presence */ ··· 286 286 if (ret < 0) { 287 287 dev_err(cdata->dev, "%s(): Error in reading reg 0x%x", __func__, 288 288 TPS65090_REG_CG_STATUS1); 289 - goto fail_unregister_supply; 289 + return ret; 290 290 } 291 291 292 292 if (status1 != 0) { 293 293 ret = tps65090_enable_charging(cdata); 294 294 if (ret < 0) { 295 295 dev_err(cdata->dev, "error enabling charger\n"); 296 - goto fail_unregister_supply; 296 + return ret; 297 297 } 298 298 cdata->ac_online = 1; 299 299 power_supply_changed(cdata->ac); ··· 306 306 dev_err(cdata->dev, 307 307 "Unable to register irq %d err %d\n", irq, 308 308 ret); 309 - goto fail_unregister_supply; 309 + return ret; 310 310 } 311 311 } else { 312 312 cdata->poll_task = kthread_run(tps65090_charger_poll_task, ··· 316 316 ret = PTR_ERR(cdata->poll_task); 317 317 dev_err(cdata->dev, 318 318 "Unable to run kthread err %d\n", ret); 319 - goto fail_unregister_supply; 319 + return ret; 320 320 } 321 321 } 322 322 323 323 return 0; 324 - 325 - fail_unregister_supply: 326 - power_supply_unregister(cdata->ac); 327 - 328 - return ret; 329 324 } 330 325 331 326 static void tps65090_charger_remove(struct platform_device *pdev) ··· 329 334 330 335 if (cdata->irq == -ENXIO) 331 336 kthread_stop(cdata->poll_task); 332 - power_supply_unregister(cdata->ac); 333 337 } 334 338 335 339 static const struct of_device_id of_tps65090_charger_match[] = {

+14 -45

drivers/power/supply/twl4030_madc_battery.c

··· 188 188 struct twl4030_madc_battery *twl4030_madc_bat; 189 189 struct twl4030_madc_bat_platform_data *pdata = pdev->dev.platform_data; 190 190 struct power_supply_config psy_cfg = {}; 191 - int ret = 0; 192 191 193 192 twl4030_madc_bat = devm_kzalloc(&pdev->dev, sizeof(*twl4030_madc_bat), 194 193 GFP_KERNEL); 195 194 if (!twl4030_madc_bat) 196 195 return -ENOMEM; 197 196 198 - twl4030_madc_bat->channel_temp = iio_channel_get(&pdev->dev, "temp"); 199 - if (IS_ERR(twl4030_madc_bat->channel_temp)) { 200 - ret = PTR_ERR(twl4030_madc_bat->channel_temp); 201 - goto err; 202 - } 197 + twl4030_madc_bat->channel_temp = devm_iio_channel_get(&pdev->dev, "temp"); 198 + if (IS_ERR(twl4030_madc_bat->channel_temp)) 199 + return PTR_ERR(twl4030_madc_bat->channel_temp); 203 200 204 - twl4030_madc_bat->channel_ichg = iio_channel_get(&pdev->dev, "ichg"); 205 - if (IS_ERR(twl4030_madc_bat->channel_ichg)) { 206 - ret = PTR_ERR(twl4030_madc_bat->channel_ichg); 207 - goto err_temp; 208 - } 201 + twl4030_madc_bat->channel_ichg = devm_iio_channel_get(&pdev->dev, "ichg"); 202 + if (IS_ERR(twl4030_madc_bat->channel_ichg)) 203 + return PTR_ERR(twl4030_madc_bat->channel_ichg); 209 204 210 - twl4030_madc_bat->channel_vbat = iio_channel_get(&pdev->dev, "vbat"); 211 - if (IS_ERR(twl4030_madc_bat->channel_vbat)) { 212 - ret = PTR_ERR(twl4030_madc_bat->channel_vbat); 213 - goto err_ichg; 214 - } 205 + twl4030_madc_bat->channel_vbat = devm_iio_channel_get(&pdev->dev, "vbat"); 206 + if (IS_ERR(twl4030_madc_bat->channel_vbat)) 207 + return PTR_ERR(twl4030_madc_bat->channel_vbat); 215 208 216 209 /* sort charging and discharging calibration data */ 217 210 sort(pdata->charging, pdata->charging_size, ··· 215 222 twl4030_cmp, NULL); 216 223 217 224 twl4030_madc_bat->pdata = pdata; 218 - platform_set_drvdata(pdev, twl4030_madc_bat); 219 225 psy_cfg.drv_data = twl4030_madc_bat; 220 - twl4030_madc_bat->psy = power_supply_register(&pdev->dev, 221 - &twl4030_madc_bat_desc, 222 - &psy_cfg); 223 - if (IS_ERR(twl4030_madc_bat->psy)) { 224 - ret = PTR_ERR(twl4030_madc_bat->psy); 225 - goto err_vbat; 226 - } 226 + twl4030_madc_bat->psy = devm_power_supply_register(&pdev->dev, 227 + &twl4030_madc_bat_desc, 228 + &psy_cfg); 229 + if (IS_ERR(twl4030_madc_bat->psy)) 230 + return PTR_ERR(twl4030_madc_bat->psy); 227 231 228 232 return 0; 229 - 230 - err_vbat: 231 - iio_channel_release(twl4030_madc_bat->channel_vbat); 232 - err_ichg: 233 - iio_channel_release(twl4030_madc_bat->channel_ichg); 234 - err_temp: 235 - iio_channel_release(twl4030_madc_bat->channel_temp); 236 - err: 237 - return ret; 238 - } 239 - 240 - static void twl4030_madc_battery_remove(struct platform_device *pdev) 241 - { 242 - struct twl4030_madc_battery *bat = platform_get_drvdata(pdev); 243 - 244 - power_supply_unregister(bat->psy); 245 - 246 - iio_channel_release(bat->channel_vbat); 247 - iio_channel_release(bat->channel_ichg); 248 - iio_channel_release(bat->channel_temp); 249 233 } 250 234 251 235 static struct platform_driver twl4030_madc_battery_driver = { ··· 230 260 .name = "twl4030_madc_battery", 231 261 }, 232 262 .probe = twl4030_madc_battery_probe, 233 - .remove_new = twl4030_madc_battery_remove, 234 263 }; 235 264 module_platform_driver(twl4030_madc_battery_driver); 236 265

+2 -11

drivers/power/supply/wm831x_backup.c

··· 171 171 return -ENOMEM; 172 172 173 173 devdata->wm831x = wm831x; 174 - platform_set_drvdata(pdev, devdata); 175 174 176 175 /* We ignore configuration failures since we can still read 177 176 * back the status without enabling the charger (which may ··· 190 191 devdata->backup_desc.properties = wm831x_backup_props; 191 192 devdata->backup_desc.num_properties = ARRAY_SIZE(wm831x_backup_props); 192 193 devdata->backup_desc.get_property = wm831x_backup_get_prop; 193 - devdata->backup = power_supply_register(&pdev->dev, 194 - &devdata->backup_desc, NULL); 194 + devdata->backup = devm_power_supply_register(&pdev->dev, 195 + &devdata->backup_desc, NULL); 195 196 196 197 return PTR_ERR_OR_ZERO(devdata->backup); 197 198 } 198 199 199 - static void wm831x_backup_remove(struct platform_device *pdev) 200 - { 201 - struct wm831x_backup *devdata = platform_get_drvdata(pdev); 202 - 203 - power_supply_unregister(devdata->backup); 204 - } 205 - 206 200 static struct platform_driver wm831x_backup_driver = { 207 201 .probe = wm831x_backup_probe, 208 - .remove_new = wm831x_backup_remove, 209 202 .driver = { 210 203 .name = "wm831x-backup", 211 204 },

+9 -15

drivers/power/supply/wm831x_power.c

··· 570 570 power->wall_desc.properties = wm831x_wall_props; 571 571 power->wall_desc.num_properties = ARRAY_SIZE(wm831x_wall_props); 572 572 power->wall_desc.get_property = wm831x_wall_get_prop; 573 - power->wall = power_supply_register(&pdev->dev, &power->wall_desc, 574 - NULL); 573 + power->wall = devm_power_supply_register(&pdev->dev, 574 + &power->wall_desc, 575 + NULL); 575 576 if (IS_ERR(power->wall)) { 576 577 ret = PTR_ERR(power->wall); 577 578 goto err; ··· 583 582 power->usb_desc.properties = wm831x_usb_props; 584 583 power->usb_desc.num_properties = ARRAY_SIZE(wm831x_usb_props); 585 584 power->usb_desc.get_property = wm831x_usb_get_prop; 586 - power->usb = power_supply_register(&pdev->dev, &power->usb_desc, NULL); 585 + power->usb = devm_power_supply_register(&pdev->dev, 586 + &power->usb_desc, 587 + NULL); 587 588 if (IS_ERR(power->usb)) { 588 589 ret = PTR_ERR(power->usb); 589 590 goto err_wall; ··· 602 599 power->battery_desc.num_properties = ARRAY_SIZE(wm831x_bat_props); 603 600 power->battery_desc.get_property = wm831x_bat_get_prop; 604 601 power->battery_desc.use_for_apm = 1; 605 - power->battery = power_supply_register(&pdev->dev, 606 - &power->battery_desc, 607 - NULL); 602 + power->battery = devm_power_supply_register(&pdev->dev, 603 + &power->battery_desc, 604 + NULL); 608 605 if (IS_ERR(power->battery)) { 609 606 ret = PTR_ERR(power->battery); 610 607 goto err_usb; ··· 687 684 irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "SYSLO")); 688 685 free_irq(irq, power); 689 686 err_battery: 690 - if (power->have_battery) 691 - power_supply_unregister(power->battery); 692 687 err_usb: 693 - power_supply_unregister(power->usb); 694 688 err_wall: 695 - power_supply_unregister(power->wall); 696 689 err: 697 690 return ret; 698 691 } ··· 716 717 717 718 irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "SYSLO")); 718 719 free_irq(irq, wm831x_power); 719 - 720 - if (wm831x_power->have_battery) 721 - power_supply_unregister(wm831x_power->battery); 722 - power_supply_unregister(wm831x_power->wall); 723 - power_supply_unregister(wm831x_power->usb); 724 720 } 725 721 726 722 static struct platform_driver wm831x_power_driver = {

+7 -23

drivers/power/supply/wm8350_power.c

··· 540 540 struct wm8350_charger_policy *policy = power->policy; 541 541 int ret; 542 542 543 - power->ac = power_supply_register(&pdev->dev, &wm8350_ac_desc, NULL); 543 + power->ac = devm_power_supply_register(&pdev->dev, &wm8350_ac_desc, NULL); 544 544 if (IS_ERR(power->ac)) 545 545 return PTR_ERR(power->ac); 546 546 547 - power->battery = power_supply_register(&pdev->dev, &wm8350_battery_desc, 548 - NULL); 549 - if (IS_ERR(power->battery)) { 550 - ret = PTR_ERR(power->battery); 551 - goto battery_failed; 552 - } 547 + power->battery = devm_power_supply_register(&pdev->dev, &wm8350_battery_desc, NULL); 548 + if (IS_ERR(power->battery)) 549 + return PTR_ERR(power->battery); 553 550 554 - power->usb = power_supply_register(&pdev->dev, &wm8350_usb_desc, NULL); 555 - if (IS_ERR(power->usb)) { 556 - ret = PTR_ERR(power->usb); 557 - goto usb_failed; 558 - } 551 + power->usb = devm_power_supply_register(&pdev->dev, &wm8350_usb_desc, NULL); 552 + if (IS_ERR(power->usb)) 553 + return PTR_ERR(power->usb); 559 554 560 555 ret = device_create_file(&pdev->dev, &dev_attr_charger_state); 561 556 if (ret < 0) ··· 565 570 } 566 571 567 572 return ret; 568 - 569 - usb_failed: 570 - power_supply_unregister(power->battery); 571 - battery_failed: 572 - power_supply_unregister(power->ac); 573 - 574 - return ret; 575 573 } 576 574 577 575 static void wm8350_power_remove(struct platform_device *pdev) 578 576 { 579 577 struct wm8350 *wm8350 = platform_get_drvdata(pdev); 580 - struct wm8350_power *power = &wm8350->power; 581 578 582 579 free_charger_irq(wm8350); 583 580 device_remove_file(&pdev->dev, &dev_attr_charger_state); 584 - power_supply_unregister(power->battery); 585 - power_supply_unregister(power->ac); 586 - power_supply_unregister(power->usb); 587 581 } 588 582 589 583 static struct platform_driver wm8350_power_driver = {

-1

include/linux/power/bq27xxx_battery.h

··· 61 61 62 62 struct bq27xxx_device_info { 63 63 struct device *dev; 64 - int id; 65 64 enum bq27xxx_chip chip; 66 65 u32 opts; 67 66 const char *name;

+2 -2

include/linux/power_supply.h

··· 242 242 struct power_supply_desc { 243 243 const char *name; 244 244 enum power_supply_type type; 245 + u8 charge_behaviours; 245 246 const enum power_supply_usb_type *usb_types; 246 247 size_t num_usb_types; 247 248 const enum power_supply_property *properties; ··· 895 894 #define to_power_supply(device) container_of(device, struct power_supply, dev) 896 895 897 896 extern void *power_supply_get_drvdata(struct power_supply *psy); 898 - /* For APM emulation, think legacy userspace. */ 899 - extern struct class *power_supply_class; 897 + extern int power_supply_for_each_device(void *data, int (*fn)(struct device *dev, void *data)); 900 898 901 899 static inline bool power_supply_is_amp_property(enum power_supply_property psp) 902 900 {

Configure Feed

Configure Feed