tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

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

Pull power supply and reset updates from Sebastian Reichel:
"power-supply core:
- sysfs: constify pointer passed to dev_attr_psp
- extend DT binding documentation for battery cells to allow
describing voltage drop behaviour

power-supply drivers:
- multiple: Remove unused gpio include header
- multiple: Fix potential IRQ use-after-free on driver unload
- bd71828: Add support for ROHM BD72720
- misc small fixes

reset drivers:
- tdx-ec-poweroff: fix restart"

* tag 'for-v7.0' of git://git.kernel.org/pub/scm/linux/kernel/git/sre/linux-power-supply: (30 commits)
power: supply: bd71828: Use dev_err_probe()
dt-bindings: power: supply: google,goldfish-battery: Convert to DT schema
power: supply: qcom_battmgr: Recognize "LiP" as lithium-polymer
power: supply: wm97xx: Use devm_power_supply_register()
power: supply: wm97xx: Use devm_kcalloc()
power: supply: pm8916_lbc: Fix use-after-free for extcon in IRQ handler
power: reset: tdx-ec-poweroff: fix restart
docs: power: update documentation about removed function
power: supply: wm97xx: Fix NULL pointer dereference in power_supply_changed()
MAINTAINERS: adjust file entry in ROHM BD71828 CHARGER
power: supply: ab8500_chargalg: improve kernel-doc
power: supply: sysfs: Constify pointer passed to dev_attr_psp()
power: supply: bq27xxx: fix wrong errno when bus ops are unsupported
power: reset: nvmem-reboot-mode: respect cell size for nvmem_cell_write
power: supply: sbs-battery: Fix use-after-free in power_supply_changed()
power: supply: rt9455: Fix use-after-free in power_supply_changed()
power: supply: pm8916_lbc: Fix use-after-free in power_supply_changed()
power: supply: pm8916_bms_vm: Fix use-after-free in power_supply_changed()
power: supply: pf1550: Fix use-after-free in power_supply_changed()
power: supply: goldfish: Fix use-after-free in power_supply_changed()
...

Linus Torvalds 7563f7e0 7449f86b

+221 -190
-17
Documentation/devicetree/bindings/goldfish/battery.txt
··· 1 - Android Goldfish Battery 2 - 3 - Android goldfish battery device generated by android emulator. 4 - 5 - Required properties: 6 - 7 - - compatible : should contain "google,goldfish-battery" to match emulator 8 - - reg : <registers mapping> 9 - - interrupts : <interrupt mapping> 10 - 11 - Example: 12 - 13 - goldfish_battery@9020000 { 14 - compatible = "google,goldfish-battery"; 15 - reg = <0x9020000 0x1000>; 16 - interrupts = <0x3>; 17 - };
+41
Documentation/devicetree/bindings/power/supply/google,goldfish-battery.yaml
··· 1 + # SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) 2 + %YAML 1.2 3 + --- 4 + $id: http://devicetree.org/schemas/power/supply/google,goldfish-battery.yaml# 5 + $schema: http://devicetree.org/meta-schemas/core.yaml# 6 + 7 + title: Android Goldfish Battery 8 + 9 + maintainers: 10 + - Kuan-Wei Chiu <visitorckw@gmail.com> 11 + 12 + allOf: 13 + - $ref: power-supply.yaml# 14 + 15 + description: 16 + Android goldfish battery device generated by Android emulator. 17 + 18 + properties: 19 + compatible: 20 + const: google,goldfish-battery 21 + 22 + reg: 23 + maxItems: 1 24 + 25 + interrupts: 26 + maxItems: 1 27 + 28 + required: 29 + - compatible 30 + - reg 31 + - interrupts 32 + 33 + unevaluatedProperties: false 34 + 35 + examples: 36 + - | 37 + battery@9020000 { 38 + compatible = "google,goldfish-battery"; 39 + reg = <0x9020000 0x1000>; 40 + interrupts = <3>; 41 + };
+1 -11
Documentation/power/charger-manager.rst
··· 183 183 the value of measure_battery_temp. 184 184 185 185 186 - 5. Notify Charger-Manager of charger events: cm_notify_event() 187 - ============================================================== 188 - If there is an charger event is required to notify 189 - Charger Manager, a charger device driver that triggers the event can call 190 - cm_notify_event(psy, type, msg) to notify the corresponding Charger Manager. 191 - In the function, psy is the charger driver's power_supply pointer, which is 192 - associated with Charger-Manager. The parameter "type" 193 - is the same as irq's type (enum cm_event_types). The event message "msg" is 194 - optional and is effective only if the event type is "UNDESCRIBED" or "OTHERS". 195 - 196 - 6. Other Considerations 186 + 5. Other Considerations 197 187 ======================= 198 188 199 189 At the charger/battery-related events such as battery-pulled-out,
+1 -1
MAINTAINERS
··· 22899 22899 M: Andreas Kemnade <andreas@kemnade.info> 22900 22900 M: Matti Vaittinen <mazziesaccount@gmail.com> 22901 22901 S: Maintained 22902 - F: drivers/power/supply/bd71828-charger.c 22902 + F: drivers/power/supply/bd71828-power.c 22903 22903 22904 22904 ROHM BD79703 DAC 22905 22905 M: Matti Vaittinen <mazziesaccount@gmail.com>
+13 -2
drivers/power/reset/nvmem-reboot-mode.c
··· 10 10 #include <linux/nvmem-consumer.h> 11 11 #include <linux/platform_device.h> 12 12 #include <linux/reboot-mode.h> 13 + #include <linux/slab.h> 13 14 14 15 struct nvmem_reboot_mode { 15 16 struct reboot_mode_driver reboot; ··· 20 19 static int nvmem_reboot_mode_write(struct reboot_mode_driver *reboot, 21 20 unsigned int magic) 22 21 { 23 - int ret; 24 22 struct nvmem_reboot_mode *nvmem_rbm; 23 + size_t buf_len; 24 + void *buf; 25 + int ret; 25 26 26 27 nvmem_rbm = container_of(reboot, struct nvmem_reboot_mode, reboot); 27 28 28 - ret = nvmem_cell_write(nvmem_rbm->cell, &magic, sizeof(magic)); 29 + buf = nvmem_cell_read(nvmem_rbm->cell, &buf_len); 30 + if (IS_ERR(buf)) 31 + return PTR_ERR(buf); 32 + kfree(buf); 33 + 34 + if (buf_len > sizeof(magic)) 35 + return -EINVAL; 36 + 37 + ret = nvmem_cell_write(nvmem_rbm->cell, &magic, buf_len); 29 38 if (ret < 0) 30 39 dev_err(reboot->dev, "update reboot mode bits failed\n"); 31 40
+19
drivers/power/reset/tdx-ec-poweroff.c
··· 8 8 */ 9 9 10 10 #include <linux/array_size.h> 11 + #include <linux/bug.h> 12 + #include <linux/delay.h> 11 13 #include <linux/device.h> 14 + #include <linux/dev_printk.h> 12 15 #include <linux/err.h> 13 16 #include <linux/i2c.h> 14 17 #include <linux/mod_devicetable.h> ··· 33 30 #define EC_CMD_RESET 0x02 34 31 35 32 #define EC_REG_MAX 0xD0 33 + 34 + #define EC_CMD_TIMEOUT_MS 1000 36 35 37 36 static const struct regmap_range volatile_ranges[] = { 38 37 regmap_reg_range(EC_CMD_REG, EC_CMD_REG), ··· 80 75 81 76 err = tdx_ec_cmd(regmap, EC_CMD_POWEROFF); 82 77 78 + if (err) { 79 + dev_err(data->dev, "Failed to send power off command\n"); 80 + } else { 81 + mdelay(EC_CMD_TIMEOUT_MS); 82 + WARN_ONCE(1, "Unable to power off system\n"); 83 + } 84 + 83 85 return err ? NOTIFY_BAD : NOTIFY_DONE; 84 86 } 85 87 ··· 96 84 int err; 97 85 98 86 err = tdx_ec_cmd(regmap, EC_CMD_RESET); 87 + 88 + if (err) { 89 + dev_err(data->dev, "Failed to send restart command\n"); 90 + } else { 91 + mdelay(EC_CMD_TIMEOUT_MS); 92 + WARN_ONCE(1, "Unable to restart system\n"); 93 + } 99 94 100 95 return err ? NOTIFY_BAD : NOTIFY_DONE; 101 96 }
+9 -6
drivers/power/supply/ab8500_chargalg.c
··· 170 170 * @original_iset_ua: the non optimized/maximised charger current 171 171 * @current_iset_ua: the charging current used at this moment 172 172 * @condition_cnt: number of iterations needed before a new charger current 173 - is set 173 + * is set 174 174 * @max_current_ua: maximum charger current 175 175 * @wait_cnt: to avoid too fast current step down in case of charger 176 176 * voltage collapse, we insert this delay between step 177 177 * down 178 178 * @level: tells in how many steps the charging current has been 179 - increased 179 + * increased 180 180 */ 181 181 struct ab8500_charge_curr_maximization { 182 182 int original_iset_ua; ··· 199 199 * @charge_status: battery operating status 200 200 * @eoc_cnt: counter used to determine end-of_charge 201 201 * @maintenance_chg: indicate if maintenance charge is active 202 - * @t_hyst_norm temperature hysteresis when the temperature has been 202 + * @t_hyst_norm: temperature hysteresis when the temperature has been 203 203 * over or under normal limits 204 - * @t_hyst_lowhigh temperature hysteresis when the temperature has been 204 + * @t_hyst_lowhigh: temperature hysteresis when the temperature has been 205 205 * over or under the high or low limits 206 206 * @charge_state: current state of the charging algorithm 207 - * @ccm charging current maximization parameters 207 + * @ccm: charging current maximization parameters 208 208 * @chg_info: information about connected charger types 209 209 * @batt_data: data of the battery 210 210 * @bm: Platform specific battery management information 211 211 * @parent: pointer to the struct ab8500 212 212 * @chargalg_psy: structure that holds the battery properties exposed by 213 213 * the charging algorithm 214 + * @ac_chg: AC charger power supply 215 + * @usb_chg: USB charger power supply 214 216 * @events: structure for information about events triggered 215 217 * @chargalg_wq: work queue for running the charging algorithm 216 218 * @chargalg_periodic_work: work to run the charging algorithm periodically ··· 302 300 /** 303 301 * ab8500_chargalg_state_to() - Change charge state 304 302 * @di: pointer to the ab8500_chargalg structure 303 + * @state: new charge algorithm state 305 304 * 306 305 * This function gets called when a charge state change should occur 307 306 */ ··· 766 763 /** 767 764 * ab8500_chargalg_chg_curr_maxim - increases the charger current to 768 765 * compensate for the system load 769 - * @di pointer to the ab8500_chargalg structure 766 + * @di: pointer to the ab8500_chargalg structure 770 767 * 771 768 * This maximization function is used to raise the charger current to get the 772 769 * battery current as close to the optimal value as possible. The battery
+20 -20
drivers/power/supply/ab8500_charger.c
··· 3466 3466 return ret; 3467 3467 } 3468 3468 3469 - /* Request interrupts */ 3470 - for (i = 0; i < ARRAY_SIZE(ab8500_charger_irq); i++) { 3471 - irq = platform_get_irq_byname(pdev, ab8500_charger_irq[i].name); 3472 - if (irq < 0) 3473 - return irq; 3474 - 3475 - ret = devm_request_threaded_irq(dev, 3476 - irq, NULL, ab8500_charger_irq[i].isr, 3477 - IRQF_SHARED | IRQF_NO_SUSPEND | IRQF_ONESHOT, 3478 - ab8500_charger_irq[i].name, di); 3479 - 3480 - if (ret != 0) { 3481 - dev_err(dev, "failed to request %s IRQ %d: %d\n" 3482 - , ab8500_charger_irq[i].name, irq, ret); 3483 - return ret; 3484 - } 3485 - dev_dbg(dev, "Requested %s IRQ %d: %d\n", 3486 - ab8500_charger_irq[i].name, irq, ret); 3487 - } 3488 - 3489 3469 /* initialize lock */ 3490 3470 spin_lock_init(&di->usb_state.usb_lock); 3491 3471 mutex_init(&di->usb_ipt_crnt_lock); ··· 3592 3612 if (IS_ERR(di->usb_chg.psy)) { 3593 3613 dev_err(dev, "failed to register USB charger\n"); 3594 3614 return PTR_ERR(di->usb_chg.psy); 3615 + } 3616 + 3617 + /* Request interrupts */ 3618 + for (i = 0; i < ARRAY_SIZE(ab8500_charger_irq); i++) { 3619 + irq = platform_get_irq_byname(pdev, ab8500_charger_irq[i].name); 3620 + if (irq < 0) 3621 + return irq; 3622 + 3623 + ret = devm_request_threaded_irq(dev, 3624 + irq, NULL, ab8500_charger_irq[i].isr, 3625 + IRQF_SHARED | IRQF_NO_SUSPEND | IRQF_ONESHOT, 3626 + ab8500_charger_irq[i].name, di); 3627 + 3628 + if (ret != 0) { 3629 + dev_err(dev, "failed to request %s IRQ %d: %d\n" 3630 + , ab8500_charger_irq[i].name, irq, ret); 3631 + return ret; 3632 + } 3633 + dev_dbg(dev, "Requested %s IRQ %d: %d\n", 3634 + ab8500_charger_irq[i].name, irq, ret); 3595 3635 } 3596 3636 3597 3637 /*
+8 -8
drivers/power/supply/act8945a_charger.c
··· 597 597 return irq ?: -ENXIO; 598 598 } 599 599 600 - ret = devm_request_irq(&pdev->dev, irq, act8945a_status_changed, 601 - IRQF_TRIGGER_FALLING, "act8945a_interrupt", 602 - charger); 603 - if (ret) { 604 - dev_err(&pdev->dev, "failed to request nIRQ pin IRQ\n"); 605 - return ret; 606 - } 607 - 608 600 charger->desc.name = "act8945a-charger"; 609 601 charger->desc.get_property = act8945a_charger_get_property; 610 602 charger->desc.properties = act8945a_charger_props; ··· 615 623 if (IS_ERR(charger->psy)) { 616 624 dev_err(&pdev->dev, "failed to register power supply\n"); 617 625 return PTR_ERR(charger->psy); 626 + } 627 + 628 + ret = devm_request_irq(&pdev->dev, irq, act8945a_status_changed, 629 + IRQF_TRIGGER_FALLING, "act8945a_interrupt", 630 + charger); 631 + if (ret) { 632 + dev_err(&pdev->dev, "failed to request nIRQ pin IRQ\n"); 633 + return ret; 618 634 } 619 635 620 636 platform_set_drvdata(pdev, charger);
+3 -6
drivers/power/supply/bd71828-power.c
··· 1058 1058 pwr->regmap = dev_get_regmap(pdev->dev.parent, NULL); 1059 1059 else 1060 1060 pwr->regmap = dev_get_regmap(pdev->dev.parent, "wrap-map"); 1061 - if (!pwr->regmap) { 1062 - dev_err(&pdev->dev, "No parent regmap\n"); 1063 - return -EINVAL; 1064 - } 1061 + if (!pwr->regmap) 1062 + return dev_err_probe(&pdev->dev, -EINVAL, "No parent regmap\n"); 1065 1063 1066 1064 pwr->dev = &pdev->dev; 1067 1065 ··· 1081 1083 dev_dbg(pwr->dev, "Found ROHM BD72720\n"); 1082 1084 break; 1083 1085 default: 1084 - dev_err(pwr->dev, "Unknown PMIC\n"); 1085 - return -EINVAL; 1086 + return dev_err_probe(pwr->dev, -EINVAL, "Unknown PMIC\n"); 1086 1087 } 1087 1088 1088 1089 ret = bd7182x_get_rsens(pwr);
-1
drivers/power/supply/bd99954-charger.c
··· 56 56 */ 57 57 58 58 #include <linux/delay.h> 59 - #include <linux/gpio/consumer.h> 60 59 #include <linux/interrupt.h> 61 60 #include <linux/i2c.h> 62 61 #include <linux/kernel.h>
+6 -7
drivers/power/supply/bq256xx_charger.c
··· 8 8 #include <linux/interrupt.h> 9 9 #include <linux/kernel.h> 10 10 #include <linux/module.h> 11 - #include <linux/gpio/consumer.h> 12 11 #include <linux/power_supply.h> 13 12 #include <linux/regmap.h> 14 13 #include <linux/types.h> ··· 1740 1741 usb_register_notifier(bq->usb3_phy, &bq->usb_nb); 1741 1742 } 1742 1743 1744 + ret = bq256xx_power_supply_init(bq, &psy_cfg, dev); 1745 + if (ret) { 1746 + dev_err(dev, "Failed to register power supply\n"); 1747 + return ret; 1748 + } 1749 + 1743 1750 if (client->irq) { 1744 1751 ret = devm_request_threaded_irq(dev, client->irq, NULL, 1745 1752 bq256xx_irq_handler_thread, ··· 1756 1751 dev_err(dev, "get irq fail: %d\n", ret); 1757 1752 return ret; 1758 1753 } 1759 - } 1760 - 1761 - ret = bq256xx_power_supply_init(bq, &psy_cfg, dev); 1762 - if (ret) { 1763 - dev_err(dev, "Failed to register power supply\n"); 1764 - return ret; 1765 1754 } 1766 1755 1767 1756 ret = bq256xx_hw_init(bq);
+6 -7
drivers/power/supply/bq25980_charger.c
··· 8 8 #include <linux/interrupt.h> 9 9 #include <linux/kernel.h> 10 10 #include <linux/module.h> 11 - #include <linux/gpio/consumer.h> 12 11 #include <linux/power_supply.h> 13 12 #include <linux/regmap.h> 14 13 #include <linux/types.h> ··· 1240 1241 return ret; 1241 1242 } 1242 1243 1244 + ret = bq25980_power_supply_init(bq, dev); 1245 + if (ret) { 1246 + dev_err(dev, "Failed to register power supply\n"); 1247 + return ret; 1248 + } 1249 + 1243 1250 if (client->irq) { 1244 1251 ret = devm_request_threaded_irq(dev, client->irq, NULL, 1245 1252 bq25980_irq_handler_thread, ··· 1254 1249 dev_name(&client->dev), bq); 1255 1250 if (ret) 1256 1251 return ret; 1257 - } 1258 - 1259 - ret = bq25980_power_supply_init(bq, dev); 1260 - if (ret) { 1261 - dev_err(dev, "Failed to register power supply\n"); 1262 - return ret; 1263 1252 } 1264 1253 1265 1254 ret = bq25980_hw_init(bq);
+3 -3
drivers/power/supply/bq27xxx_battery.c
··· 1172 1172 return -EINVAL; 1173 1173 1174 1174 if (!di->bus.write) 1175 - return -EPERM; 1175 + return -EOPNOTSUPP; 1176 1176 1177 1177 ret = di->bus.write(di, di->regs[reg_index], value, single); 1178 1178 if (ret < 0) ··· 1191 1191 return -EINVAL; 1192 1192 1193 1193 if (!di->bus.read_bulk) 1194 - return -EPERM; 1194 + return -EOPNOTSUPP; 1195 1195 1196 1196 ret = di->bus.read_bulk(di, di->regs[reg_index], data, len); 1197 1197 if (ret < 0) ··· 1210 1210 return -EINVAL; 1211 1211 1212 1212 if (!di->bus.write_bulk) 1213 - return -EPERM; 1213 + return -EOPNOTSUPP; 1214 1214 1215 1215 ret = di->bus.write_bulk(di, di->regs[reg_index], data, len); 1216 1216 if (ret < 0)
+4 -4
drivers/power/supply/cpcap-battery.c
··· 1122 1122 1123 1123 platform_set_drvdata(pdev, ddata); 1124 1124 1125 - error = cpcap_battery_init_interrupts(pdev, ddata); 1126 - if (error) 1127 - return error; 1128 - 1129 1125 error = cpcap_battery_init_iio(ddata); 1130 1126 if (error) 1131 1127 return error; ··· 1137 1141 dev_err(ddata->dev, "failed to register power supply\n"); 1138 1142 return error; 1139 1143 } 1144 + 1145 + error = cpcap_battery_init_interrupts(pdev, ddata); 1146 + if (error) 1147 + return error; 1140 1148 1141 1149 atomic_set(&ddata->active, 1); 1142 1150
-1
drivers/power/supply/cw2015_battery.c
··· 13 13 #include <linux/delay.h> 14 14 #include <linux/i2c.h> 15 15 #include <linux/gfp.h> 16 - #include <linux/gpio/consumer.h> 17 16 #include <linux/kernel.h> 18 17 #include <linux/module.h> 19 18 #include <linux/power_supply.h>
+6 -6
drivers/power/supply/goldfish_battery.c
··· 224 224 if (data->irq < 0) 225 225 return -ENODEV; 226 226 227 - ret = devm_request_irq(&pdev->dev, data->irq, 228 - goldfish_battery_interrupt, 229 - IRQF_SHARED, pdev->name, data); 230 - if (ret) 231 - return ret; 232 - 233 227 psy_cfg.drv_data = data; 234 228 235 229 data->ac = devm_power_supply_register(&pdev->dev, ··· 237 243 &psy_cfg); 238 244 if (IS_ERR(data->battery)) 239 245 return PTR_ERR(data->battery); 246 + 247 + ret = devm_request_irq(&pdev->dev, data->irq, 248 + goldfish_battery_interrupt, 249 + IRQF_SHARED, pdev->name, data); 250 + if (ret) 251 + return ret; 240 252 241 253 GOLDFISH_BATTERY_WRITE(data, BATTERY_INT_ENABLE, BATTERY_INT_MASK); 242 254 return 0;
+16 -16
drivers/power/supply/pf1550-charger.c
··· 584 584 return dev_err_probe(chg->dev, ret, 585 585 "failed to add battery sense work\n"); 586 586 587 - for (i = 0; i < PF1550_CHARGER_IRQ_NR; i++) { 588 - irq = platform_get_irq(pdev, i); 589 - if (irq < 0) 590 - return irq; 591 - 592 - chg->virqs[i] = irq; 593 - 594 - ret = devm_request_threaded_irq(&pdev->dev, irq, NULL, 595 - pf1550_charger_irq_handler, 596 - IRQF_NO_SUSPEND, 597 - "pf1550-charger", chg); 598 - if (ret) 599 - return dev_err_probe(&pdev->dev, ret, 600 - "failed irq request\n"); 601 - } 602 - 603 587 psy_cfg.drv_data = chg; 604 588 605 589 chg->charger = devm_power_supply_register(&pdev->dev, ··· 599 615 if (IS_ERR(chg->battery)) 600 616 return dev_err_probe(&pdev->dev, PTR_ERR(chg->battery), 601 617 "failed: power supply register\n"); 618 + 619 + for (i = 0; i < PF1550_CHARGER_IRQ_NR; i++) { 620 + irq = platform_get_irq(pdev, i); 621 + if (irq < 0) 622 + return irq; 623 + 624 + chg->virqs[i] = irq; 625 + 626 + ret = devm_request_threaded_irq(&pdev->dev, irq, NULL, 627 + pf1550_charger_irq_handler, 628 + IRQF_NO_SUSPEND, 629 + "pf1550-charger", chg); 630 + if (ret) 631 + return dev_err_probe(&pdev->dev, ret, 632 + "failed irq request\n"); 633 + } 602 634 603 635 pf1550_dt_parse_dev_info(chg); 604 636
+9 -9
drivers/power/supply/pm8916_bms_vm.c
··· 167 167 if (ret < 0) 168 168 return -EINVAL; 169 169 170 - irq = platform_get_irq_byname(pdev, "fifo"); 171 - if (irq < 0) 172 - return irq; 173 - 174 - ret = devm_request_threaded_irq(dev, irq, NULL, pm8916_bms_vm_fifo_update_done_irq, 175 - IRQF_ONESHOT, "pm8916_vm_bms", bat); 176 - if (ret) 177 - return ret; 178 - 179 170 ret = regmap_bulk_read(bat->regmap, bat->reg + PM8916_PERPH_TYPE, &tmp, 2); 180 171 if (ret) 181 172 goto comm_error; ··· 210 219 ret = power_supply_get_battery_info(bat->battery, &bat->info); 211 220 if (ret) 212 221 return dev_err_probe(dev, ret, "Unable to get battery info\n"); 222 + 223 + irq = platform_get_irq_byname(pdev, "fifo"); 224 + if (irq < 0) 225 + return irq; 226 + 227 + ret = devm_request_threaded_irq(dev, irq, NULL, pm8916_bms_vm_fifo_update_done_irq, 228 + IRQF_ONESHOT, "pm8916_vm_bms", bat); 229 + if (ret) 230 + return ret; 213 231 214 232 platform_set_drvdata(pdev, bat); 215 233
+9 -9
drivers/power/supply/pm8916_lbc.c
··· 274 274 return dev_err_probe(dev, -EINVAL, 275 275 "Wrong amount of reg values: %d (4 expected)\n", len); 276 276 277 - irq = platform_get_irq_byname(pdev, "usb_vbus"); 278 - if (irq < 0) 279 - return irq; 280 - 281 - ret = devm_request_threaded_irq(dev, irq, NULL, pm8916_lbc_charger_state_changed_irq, 282 - IRQF_ONESHOT, "pm8916_lbc", chg); 283 - if (ret) 284 - return ret; 285 - 286 277 ret = device_property_read_u32_array(dev, "reg", chg->reg, len); 287 278 if (ret) 288 279 return ret; ··· 323 332 if (ret) 324 333 return dev_err_probe(dev, ret, "Unable to get battery info\n"); 325 334 335 + irq = platform_get_irq_byname(pdev, "usb_vbus"); 336 + if (irq < 0) 337 + return irq; 338 + 326 339 chg->edev = devm_extcon_dev_allocate(dev, pm8916_lbc_charger_cable); 327 340 if (IS_ERR(chg->edev)) 328 341 return PTR_ERR(chg->edev); ··· 334 339 ret = devm_extcon_dev_register(dev, chg->edev); 335 340 if (ret < 0) 336 341 return dev_err_probe(dev, ret, "failed to register extcon device\n"); 342 + 343 + ret = devm_request_threaded_irq(dev, irq, NULL, pm8916_lbc_charger_state_changed_irq, 344 + IRQF_ONESHOT, "pm8916_lbc", chg); 345 + if (ret) 346 + return ret; 337 347 338 348 ret = regmap_read(chg->regmap, chg->reg[LBC_USB] + PM8916_INT_RT_STS, &tmp); 339 349 if (ret)
+3 -3
drivers/power/supply/power_supply_sysfs.c
··· 235 235 static struct attribute * 236 236 __power_supply_attrs[POWER_SUPPLY_ATTR_CNT + 1] __ro_after_init; 237 237 238 - static const struct power_supply_attr *to_ps_attr(struct device_attribute *attr) 238 + static const struct power_supply_attr *to_ps_attr(const struct device_attribute *attr) 239 239 { 240 - return container_of(attr, struct power_supply_attr, dev_attr); 240 + return container_of_const(attr, struct power_supply_attr, dev_attr); 241 241 } 242 242 243 - static enum power_supply_property dev_attr_psp(struct device_attribute *attr) 243 + static enum power_supply_property dev_attr_psp(const struct device_attribute *attr) 244 244 { 245 245 return to_ps_attr(attr) - power_supply_attrs; 246 246 }
+2 -1
drivers/power/supply/qcom_battmgr.c
··· 1240 1240 if ((!strncmp(chemistry, "LIO", BATTMGR_CHEMISTRY_LEN)) || 1241 1241 (!strncmp(chemistry, "OOI", BATTMGR_CHEMISTRY_LEN))) 1242 1242 return POWER_SUPPLY_TECHNOLOGY_LION; 1243 - if (!strncmp(chemistry, "LIP", BATTMGR_CHEMISTRY_LEN)) 1243 + if (!strncmp(chemistry, "LIP", BATTMGR_CHEMISTRY_LEN) || 1244 + !strncmp(chemistry, "LiP", BATTMGR_CHEMISTRY_LEN)) 1244 1245 return POWER_SUPPLY_TECHNOLOGY_LIPO; 1245 1246 1246 1247 pr_err("Unknown battery technology '%s'\n", chemistry);
+9 -8
drivers/power/supply/rt9455_charger.c
··· 1663 1663 rt9455_charger_config.supplied_to = rt9455_charger_supplied_to; 1664 1664 rt9455_charger_config.num_supplicants = 1665 1665 ARRAY_SIZE(rt9455_charger_supplied_to); 1666 + 1667 + info->charger = devm_power_supply_register(dev, &rt9455_charger_desc, 1668 + &rt9455_charger_config); 1669 + if (IS_ERR(info->charger)) { 1670 + dev_err(dev, "Failed to register charger\n"); 1671 + ret = PTR_ERR(info->charger); 1672 + goto put_usb_notifier; 1673 + } 1674 + 1666 1675 ret = devm_request_threaded_irq(dev, client->irq, NULL, 1667 1676 rt9455_irq_handler_thread, 1668 1677 IRQF_TRIGGER_LOW | IRQF_ONESHOT, ··· 1684 1675 ret = rt9455_hw_init(info, ichrg, ieoc_percentage, mivr, iaicr); 1685 1676 if (ret) { 1686 1677 dev_err(dev, "Failed to set charger to its default values\n"); 1687 - goto put_usb_notifier; 1688 - } 1689 - 1690 - info->charger = devm_power_supply_register(dev, &rt9455_charger_desc, 1691 - &rt9455_charger_config); 1692 - if (IS_ERR(info->charger)) { 1693 - dev_err(dev, "Failed to register charger\n"); 1694 - ret = PTR_ERR(info->charger); 1695 1678 goto put_usb_notifier; 1696 1679 } 1697 1680
+18 -18
drivers/power/supply/sbs-battery.c
··· 1174 1174 1175 1175 i2c_set_clientdata(client, chip); 1176 1176 1177 - if (!chip->gpio_detect) 1178 - goto skip_gpio; 1179 - 1180 - irq = gpiod_to_irq(chip->gpio_detect); 1181 - if (irq <= 0) { 1182 - dev_warn(&client->dev, "Failed to get gpio as irq: %d\n", irq); 1183 - goto skip_gpio; 1184 - } 1185 - 1186 - rc = devm_request_threaded_irq(&client->dev, irq, NULL, sbs_irq, 1187 - IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT, 1188 - dev_name(&client->dev), chip); 1189 - if (rc) { 1190 - dev_warn(&client->dev, "Failed to request irq: %d\n", rc); 1191 - goto skip_gpio; 1192 - } 1193 - 1194 - skip_gpio: 1195 1177 /* 1196 1178 * Before we register, we might need to make sure we can actually talk 1197 1179 * to the battery. ··· 1199 1217 return dev_err_probe(&client->dev, PTR_ERR(chip->power_supply), 1200 1218 "Failed to register power supply\n"); 1201 1219 1220 + if (!chip->gpio_detect) 1221 + goto out; 1222 + 1223 + irq = gpiod_to_irq(chip->gpio_detect); 1224 + if (irq <= 0) { 1225 + dev_warn(&client->dev, "Failed to get gpio as irq: %d\n", irq); 1226 + goto out; 1227 + } 1228 + 1229 + rc = devm_request_threaded_irq(&client->dev, irq, NULL, sbs_irq, 1230 + IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT, 1231 + dev_name(&client->dev), chip); 1232 + if (rc) { 1233 + dev_warn(&client->dev, "Failed to request irq: %d\n", rc); 1234 + goto out; 1235 + } 1236 + 1237 + out: 1202 1238 dev_info(&client->dev, 1203 1239 "%s: battery gas gauge device registered\n", client->name); 1204 1240
-1
drivers/power/supply/ucs1002_power.c
··· 6 6 */ 7 7 #include <linux/bits.h> 8 8 #include <linux/freezer.h> 9 - #include <linux/gpio/consumer.h> 10 9 #include <linux/i2c.h> 11 10 #include <linux/interrupt.h> 12 11 #include <linux/kernel.h>
+15 -25
drivers/power/supply/wm97xx_battery.c
··· 178 178 "failed to get charge GPIO\n"); 179 179 if (charge_gpiod) { 180 180 gpiod_set_consumer_name(charge_gpiod, "BATT CHRG"); 181 - ret = request_irq(gpiod_to_irq(charge_gpiod), 182 - wm97xx_chrg_irq, 0, 183 - "AC Detect", dev); 184 - if (ret) 185 - return dev_err_probe(&dev->dev, ret, 186 - "failed to request GPIO irq\n"); 187 181 props++; /* POWER_SUPPLY_PROP_STATUS */ 188 182 } 189 183 ··· 192 198 if (pdata->min_voltage >= 0) 193 199 props++; /* POWER_SUPPLY_PROP_VOLTAGE_MIN */ 194 200 195 - prop = kcalloc(props, sizeof(*prop), GFP_KERNEL); 196 - if (!prop) { 197 - ret = -ENOMEM; 198 - goto err3; 199 - } 201 + prop = devm_kcalloc(&dev->dev, props, sizeof(*prop), GFP_KERNEL); 202 + if (!prop) 203 + return -ENOMEM; 200 204 201 205 prop[i++] = POWER_SUPPLY_PROP_PRESENT; 202 206 if (charge_gpiod) ··· 223 231 bat_psy_desc.properties = prop; 224 232 bat_psy_desc.num_properties = props; 225 233 226 - bat_psy = power_supply_register(&dev->dev, &bat_psy_desc, &cfg); 227 - if (!IS_ERR(bat_psy)) { 228 - schedule_work(&bat_work); 229 - } else { 230 - ret = PTR_ERR(bat_psy); 231 - goto err4; 234 + bat_psy = devm_power_supply_register(&dev->dev, &bat_psy_desc, &cfg); 235 + if (IS_ERR(bat_psy)) 236 + return PTR_ERR(bat_psy); 237 + 238 + schedule_work(&bat_work); 239 + 240 + if (charge_gpiod) { 241 + ret = request_irq(gpiod_to_irq(charge_gpiod), wm97xx_chrg_irq, 242 + 0, "AC Detect", dev); 243 + if (ret) 244 + return dev_err_probe(&dev->dev, ret, 245 + "failed to request GPIO irq\n"); 232 246 } 233 247 234 248 return 0; 235 - err4: 236 - kfree(prop); 237 - err3: 238 - if (charge_gpiod) 239 - free_irq(gpiod_to_irq(charge_gpiod), dev); 240 - return ret; 241 249 } 242 250 243 251 static void wm97xx_bat_remove(struct platform_device *dev) ··· 245 253 if (charge_gpiod) 246 254 free_irq(gpiod_to_irq(charge_gpiod), dev); 247 255 cancel_work_sync(&bat_work); 248 - power_supply_unregister(bat_psy); 249 - kfree(prop); 250 256 } 251 257 252 258 static struct platform_driver wm97xx_bat_driver = {