Lines Matching +full:power +full:- +full:manager
1 // SPDX-License-Identifier: GPL-2.0-only
7 * during suspend-to-mem.
8 * Charger manager depends on other devices. Register this later than
23 #include <linux/power/charger-manager.h>
36 { "USB-HOST", EXTCON_USB_HOST },
41 { "FAST-CHARGER", EXTCON_CHG_USB_FAST },
42 { "SLOW-CHARGER", EXTCON_CHG_USB_SLOW },
50 { "CHARGE-DOWNSTREAM", EXTCON_CHG_USB_CDP },
79 /* About in-suspend (suspend-again) monitoring */
93 * is_batt_present - See if the battery presents in place.
94 * @cm: the Charger Manager representing the battery.
103 switch (cm->desc->battery_present) {
110 psy = power_supply_get_by_name(cm->desc->psy_fuel_gauge);
121 for (i = 0; cm->desc->psy_charger_stat[i]; i++) {
123 cm->desc->psy_charger_stat[i]);
125 dev_err(cm->dev, "Cannot find power supply \"%s\"\n",
126 cm->desc->psy_charger_stat[i]);
145 * is_ext_pwr_online - See if an external power source is attached to charge
146 * @cm: the Charger Manager representing the battery.
149 * power source attached to charge the battery regardless of whether it is
160 for (i = 0; cm->desc->psy_charger_stat[i]; i++) {
161 psy = power_supply_get_by_name(cm->desc->psy_charger_stat[i]);
163 dev_err(cm->dev, "Cannot find power supply \"%s\"\n",
164 cm->desc->psy_charger_stat[i]);
181 * get_batt_uV - Get the voltage level of the battery
182 * @cm: the Charger Manager representing the battery.
194 fuel_gauge = power_supply_get_by_name(cm->desc->psy_fuel_gauge);
196 return -ENODEV;
209 * is_charging - Returns true if the battery is being charged.
210 * @cm: the Charger Manager representing the battery.
224 for (i = 0; cm->desc->psy_charger_stat[i]; i++) {
226 if (cm->emergency_stop)
228 if (!cm->charger_enabled)
231 psy = power_supply_get_by_name(cm->desc->psy_charger_stat[i]);
233 dev_err(cm->dev, "Cannot find power supply \"%s\"\n",
234 cm->desc->psy_charger_stat[i]);
238 /* 2. The charger should be online (ext-power) */
242 dev_warn(cm->dev, "Cannot read ONLINE value from %s\n",
243 cm->desc->psy_charger_stat[i]);
260 dev_warn(cm->dev, "Cannot read STATUS value from %s\n",
261 cm->desc->psy_charger_stat[i]);
278 * is_full_charged - Returns true if the battery is fully charged.
279 * @cm: the Charger Manager representing the battery.
283 struct charger_desc *desc = cm->desc;
294 fuel_gauge = power_supply_get_by_name(cm->desc->psy_fuel_gauge);
299 if (desc->fullbatt_uV > 0) {
303 if (cm->battery_status == POWER_SUPPLY_STATUS_FULL
304 && desc->fullbatt_vchkdrop_uV)
305 uV += desc->fullbatt_vchkdrop_uV;
306 if (uV >= desc->fullbatt_uV)
311 if (desc->fullbatt_full_capacity > 0) {
317 if (!ret && val.intval > desc->fullbatt_full_capacity) {
324 if (desc->fullbatt_soc > 0) {
329 if (!ret && val.intval >= desc->fullbatt_soc) {
341 * is_polling_required - Return true if need to continue polling for this CM.
342 * @cm: the Charger Manager representing the battery.
346 switch (cm->desc->polling_mode) {
356 dev_warn(cm->dev, "Incorrect polling_mode (%d)\n",
357 cm->desc->polling_mode);
364 * try_charger_enable - Enable/Disable chargers altogether
365 * @cm: the Charger Manager representing the battery.
368 * Note that Charger Manager keeps the charger enabled regardless whether
370 * power source exists) except when CM needs to disable chargers forcibly
376 struct charger_desc *desc = cm->desc;
379 if (enable == cm->charger_enabled)
383 if (cm->emergency_stop)
384 return -EAGAIN;
390 cm->charging_start_time = ktime_to_ms(ktime_get());
391 cm->charging_end_time = 0;
393 for (i = 0 ; i < desc->num_charger_regulators ; i++) {
394 if (desc->charger_regulators[i].externally_control)
397 err = regulator_enable(desc->charger_regulators[i].consumer);
399 dev_warn(cm->dev, "Cannot enable %s regulator\n",
400 desc->charger_regulators[i].regulator_name);
406 * of battery after full-batt.
408 cm->charging_start_time = 0;
409 cm->charging_end_time = ktime_to_ms(ktime_get());
411 for (i = 0 ; i < desc->num_charger_regulators ; i++) {
412 if (desc->charger_regulators[i].externally_control)
415 err = regulator_disable(desc->charger_regulators[i].consumer);
417 dev_warn(cm->dev, "Cannot disable %s regulator\n",
418 desc->charger_regulators[i].regulator_name);
423 * Abnormal battery state - Stop charging forcibly,
426 for (i = 0; i < desc->num_charger_regulators; i++) {
428 desc->charger_regulators[i].consumer)) {
430 desc->charger_regulators[i].consumer);
431 dev_warn(cm->dev, "Disable regulator(%s) forcibly\n",
432 desc->charger_regulators[i].regulator_name);
438 cm->charger_enabled = enable;
444 * check_charging_duration - Monitor charging/discharging duration
445 * @cm: the Charger Manager representing the battery.
450 * attached, after full-batt, cm start charging to maintain fully
455 struct charger_desc *desc = cm->desc;
460 if (!desc->charging_max_duration_ms &&
461 !desc->discharging_max_duration_ms)
464 if (cm->charger_enabled) {
465 duration = curr - cm->charging_start_time;
467 if (duration > desc->charging_max_duration_ms) {
468 dev_info(cm->dev, "Charging duration exceed %ums\n",
469 desc->charging_max_duration_ms);
472 } else if (cm->battery_status == POWER_SUPPLY_STATUS_NOT_CHARGING) {
473 duration = curr - cm->charging_end_time;
475 if (duration > desc->discharging_max_duration_ms) {
476 dev_info(cm->dev, "Discharging duration exceed %ums\n",
477 desc->discharging_max_duration_ms);
491 fuel_gauge = power_supply_get_by_name(cm->desc->psy_fuel_gauge);
493 return -ENODEV;
508 if (!cm->desc->measure_battery_temp)
509 return -ENODEV;
512 if (cm->tzd_batt) {
513 ret = thermal_zone_get_temp(cm->tzd_batt, temp);
520 /* if-else continued from CONFIG_THERMAL */
529 struct charger_desc *desc = cm->desc;
540 dev_err(cm->dev, "Failed to get battery temperature\n");
544 upper_limit = desc->temp_max;
545 lower_limit = desc->temp_min;
547 if (cm->emergency_stop) {
548 upper_limit -= desc->temp_diff;
549 lower_limit += desc->temp_diff;
559 cm->emergency_stop = ret;
565 * cm_get_target_status - Check current status and get next target status.
566 * @cm: the Charger Manager representing the battery.
580 switch (cm->battery_status) {
600 * _cm_monitor - Monitor the temperature and return true for exceptions.
601 * @cm: the Charger Manager representing the battery.
614 if (cm->battery_status != target) {
615 cm->battery_status = target;
616 power_supply_changed(cm->charger_psy);
619 return (cm->battery_status == POWER_SUPPLY_STATUS_NOT_CHARGING);
623 * cm_monitor - Monitor every battery.
646 * _setup_polling - Setup the next instance of polling.
659 if (is_polling_required(cm) && cm->desc->polling_interval_ms) {
662 if (min > cm->desc->polling_interval_ms)
663 min = cm->desc->polling_interval_ms;
676 WARN(cm_wq == NULL, "charger-manager: workqueue not initialized"
700 * cm_monitor_poller - The Monitor / Poller.
703 * During non-suspended state, cm_monitor_poller is used to poll and monitor
717 struct charger_desc *desc = cm->desc;
724 val->intval = cm->battery_status;
727 if (cm->emergency_stop == CM_BATT_OVERHEAT)
728 val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
729 else if (cm->emergency_stop == CM_BATT_COLD)
730 val->intval = POWER_SUPPLY_HEALTH_COLD;
732 val->intval = POWER_SUPPLY_HEALTH_GOOD;
736 val->intval = 1;
738 val->intval = 0;
741 ret = get_batt_uV(cm, &val->intval);
744 fuel_gauge = power_supply_get_by_name(cm->desc->psy_fuel_gauge);
746 ret = -ENODEV;
753 return cm_get_battery_temperature(cm, &val->intval);
757 val->intval = 100;
761 fuel_gauge = power_supply_get_by_name(cm->desc->psy_fuel_gauge);
763 ret = -ENODEV;
772 if (val->intval > 100) {
773 val->intval = 100;
776 if (val->intval < 0)
777 val->intval = 0;
794 if (desc->fullbatt_uV > 0 && uV >= desc->fullbatt_uV &&
796 val->intval = 100;
803 val->intval = 1;
805 val->intval = 0;
809 fuel_gauge = power_supply_get_by_name(cm->desc->psy_fuel_gauge);
811 ret = -ENODEV;
817 return -EINVAL;
852 * cm_setup_timer - For in-suspend monitoring setup wakeup alarm
855 * Returns true if the alarm is set for Charger Manager to use.
858 * cm_setup_timer does not need to set an alarm for Charger Manager,
869 jiffies_to_msecs(next_polling - jiffies));
874 if (!is_polling_required(cm) && !cm->emergency_stop)
877 if (cm->desc->polling_interval_ms == 0)
879 CM_MIN_VALID(wakeup_ms, cm->desc->polling_interval_ms);
894 pr_info("Charger Manager wakeup timer: %u ms\n", wakeup_ms);
909 * charger_extcon_work - enable/diable charger according to the state
920 if (cable->attached && cable->min_uA != 0 && cable->max_uA != 0) {
921 ret = regulator_set_current_limit(cable->charger->consumer,
922 cable->min_uA, cable->max_uA);
925 cable->charger->regulator_name, cable->name);
930 cable->charger->regulator_name,
931 cable->min_uA, cable->max_uA);
939 * charger_extcon_notifier - receive the state of charger cable
954 * If cable is attached, cable->attached is true.
956 cable->attached = event;
962 schedule_work(&cable->wq);
968 * charger_extcon_init - register external connector to use it
971 * @cm: the Charger Manager representing the battery.
981 * Charger manager use Extcon framework to identify
985 INIT_WORK(&cable->wq, charger_extcon_work);
986 cable->nb.notifier_call = charger_extcon_notifier;
988 cable->extcon_dev = extcon_get_extcon_dev(cable->extcon_name);
989 if (IS_ERR(cable->extcon_dev)) {
991 cable->extcon_name, cable->name);
992 return PTR_ERR(cable->extcon_dev);
996 if (!strcmp(cable->name, extcon_mapping[i].name)) {
1002 pr_err("Cannot find cable for type %s", cable->name);
1003 return -EINVAL;
1006 cable->extcon_type = extcon_type;
1008 ret = devm_extcon_register_notifier(cm->dev, cable->extcon_dev,
1009 cable->extcon_type, &cable->nb);
1012 cable->extcon_name, cable->name);
1020 * charger_manager_register_extcon - Register extcon device to receive state
1022 * @cm: the Charger Manager representing the battery.
1031 struct charger_desc *desc = cm->desc;
1038 for (i = 0; i < desc->num_charger_regulators; i++) {
1039 charger = &desc->charger_regulators[i];
1041 charger->consumer = regulator_get(cm->dev,
1042 charger->regulator_name);
1043 if (IS_ERR(charger->consumer)) {
1044 dev_err(cm->dev, "Cannot find charger(%s)\n",
1045 charger->regulator_name);
1046 return PTR_ERR(charger->consumer);
1048 charger->cm = cm;
1050 for (j = 0; j < charger->num_cables; j++) {
1051 struct charger_cable *cable = &charger->cables[j];
1055 dev_err(cm->dev, "Cannot initialize charger(%s)\n",
1056 charger->regulator_name);
1059 cable->charger = charger;
1060 cable->cm = cm;
1062 event = extcon_get_state(cable->extcon_dev,
1063 cable->extcon_type);
1064 charger_extcon_notifier(&cable->nb,
1079 return sysfs_emit(buf, "%s\n", charger->regulator_name);
1089 if (!charger->externally_control)
1090 state = regulator_is_enabled(charger->consumer);
1101 return sysfs_emit(buf, "%d\n", charger->externally_control);
1111 struct charger_manager *cm = charger->cm;
1112 struct charger_desc *desc = cm->desc;
1120 ret = -EINVAL;
1125 charger->externally_control = 0;
1129 for (i = 0; i < desc->num_charger_regulators; i++) {
1130 if (&desc->charger_regulators[i] != charger &&
1131 !desc->charger_regulators[i].externally_control) {
1134 * charger-manager
1142 if (cm->charger_enabled) {
1143 try_charger_enable(charger->cm, false);
1144 charger->externally_control = externally_control;
1145 try_charger_enable(charger->cm, true);
1147 charger->externally_control = externally_control;
1150 dev_warn(cm->dev,
1151 "'%s' regulator should be controlled in charger-manager because charger-manager must need at least one charger for charging\n",
1152 charger->regulator_name);
1159 * charger_manager_prepare_sysfs - Prepare sysfs entry for each charger
1160 * @cm: the Charger Manager representing the battery.
1163 * user-space. If some development board use one more chargers for charging
1168 * externally_control, this charger isn't controlled from charger-manager and
1173 struct charger_desc *desc = cm->desc;
1180 for (i = 0; i < desc->num_charger_regulators; i++) {
1181 charger = &desc->charger_regulators[i];
1183 name = devm_kasprintf(cm->dev, GFP_KERNEL, "charger.%d", i);
1185 return -ENOMEM;
1187 charger->attrs[0] = &charger->attr_name.attr;
1188 charger->attrs[1] = &charger->attr_state.attr;
1189 charger->attrs[2] = &charger->attr_externally_control.attr;
1190 charger->attrs[3] = NULL;
1192 charger->attr_grp.name = name;
1193 charger->attr_grp.attrs = charger->attrs;
1194 desc->sysfs_groups[i] = &charger->attr_grp;
1196 sysfs_attr_init(&charger->attr_name.attr);
1197 charger->attr_name.attr.name = "name";
1198 charger->attr_name.attr.mode = 0444;
1199 charger->attr_name.show = charger_name_show;
1201 sysfs_attr_init(&charger->attr_state.attr);
1202 charger->attr_state.attr.name = "state";
1203 charger->attr_state.attr.mode = 0444;
1204 charger->attr_state.show = charger_state_show;
1206 sysfs_attr_init(&charger->attr_externally_control.attr);
1207 charger->attr_externally_control.attr.name
1209 charger->attr_externally_control.attr.mode = 0644;
1210 charger->attr_externally_control.show
1212 charger->attr_externally_control.store
1215 if (!desc->charger_regulators[i].externally_control ||
1219 dev_info(cm->dev, "'%s' regulator's externally_control is %d\n",
1220 charger->regulator_name, charger->externally_control);
1224 dev_err(cm->dev, "Cannot register regulator because charger-manager must need at least one charger for charging battery\n");
1225 return -EINVAL;
1236 struct charger_desc *desc = cm->desc;
1247 cm->desc->measure_battery_temp = true;
1250 if (ret && desc->thermal_zone) {
1251 cm->tzd_batt =
1252 thermal_zone_get_zone_by_name(desc->thermal_zone);
1253 if (IS_ERR(cm->tzd_batt))
1254 return PTR_ERR(cm->tzd_batt);
1259 cm->desc->measure_battery_temp = true;
1263 if (cm->desc->measure_battery_temp) {
1265 if (!desc->temp_max)
1266 desc->temp_max = CM_DEFAULT_CHARGE_TEMP_MAX;
1267 if (!desc->temp_diff)
1268 desc->temp_diff = CM_DEFAULT_RECHARGE_TEMP_DIFF;
1276 .compatible = "charger-manager",
1285 struct device_node *np = dev->of_node;
1292 return ERR_PTR(-ENOMEM);
1294 of_property_read_string(np, "cm-name", &desc->psy_name);
1296 of_property_read_u32(np, "cm-poll-mode", &poll_mode);
1297 desc->polling_mode = poll_mode;
1299 of_property_read_u32(np, "cm-poll-interval",
1300 &desc->polling_interval_ms);
1302 of_property_read_u32(np, "cm-fullbatt-vchkdrop-volt",
1303 &desc->fullbatt_vchkdrop_uV);
1304 of_property_read_u32(np, "cm-fullbatt-voltage", &desc->fullbatt_uV);
1305 of_property_read_u32(np, "cm-fullbatt-soc", &desc->fullbatt_soc);
1306 of_property_read_u32(np, "cm-fullbatt-capacity",
1307 &desc->fullbatt_full_capacity);
1309 of_property_read_u32(np, "cm-battery-stat", &battery_stat);
1310 desc->battery_present = battery_stat;
1313 num_chgs = of_property_count_strings(np, "cm-chargers");
1318 desc->psy_charger_stat = devm_kcalloc(dev,
1322 if (!desc->psy_charger_stat)
1323 return ERR_PTR(-ENOMEM);
1326 of_property_read_string_index(np, "cm-chargers",
1327 i, &desc->psy_charger_stat[i]);
1330 of_property_read_string(np, "cm-fuel-gauge", &desc->psy_fuel_gauge);
1332 of_property_read_string(np, "cm-thermal-zone", &desc->thermal_zone);
1334 of_property_read_u32(np, "cm-battery-cold", &desc->temp_min);
1335 if (of_property_read_bool(np, "cm-battery-cold-in-minus"))
1336 desc->temp_min *= -1;
1337 of_property_read_u32(np, "cm-battery-hot", &desc->temp_max);
1338 of_property_read_u32(np, "cm-battery-temp-diff", &desc->temp_diff);
1340 of_property_read_u32(np, "cm-charging-max",
1341 &desc->charging_max_duration_ms);
1342 of_property_read_u32(np, "cm-discharging-max",
1343 &desc->discharging_max_duration_ms);
1346 desc->num_charger_regulators = of_get_child_count(np);
1347 if (desc->num_charger_regulators) {
1352 desc->num_charger_regulators,
1356 return ERR_PTR(-ENOMEM);
1358 desc->charger_regulators = chg_regs;
1360 desc->sysfs_groups = devm_kcalloc(dev,
1361 desc->num_charger_regulators + 1,
1362 sizeof(*desc->sysfs_groups),
1364 if (!desc->sysfs_groups)
1365 return ERR_PTR(-ENOMEM);
1371 of_property_read_string(child, "cm-regulator-name",
1372 &chg_regs->regulator_name);
1375 chg_regs->num_cables = of_get_child_count(child);
1376 if (chg_regs->num_cables) {
1378 chg_regs->num_cables,
1383 return ERR_PTR(-ENOMEM);
1386 chg_regs->cables = cables;
1390 "cm-cable-name", &cables->name);
1392 "cm-cable-extcon",
1393 &cables->extcon_name);
1395 "cm-cable-min",
1396 &cables->min_uA);
1398 "cm-cable-max",
1399 &cables->max_uA);
1411 if (pdev->dev.of_node)
1412 return of_cm_parse_desc(&pdev->dev);
1413 return dev_get_platdata(&pdev->dev);
1433 dev_err(&pdev->dev, "No platform data (desc) found\n");
1437 cm = devm_kzalloc(&pdev->dev, sizeof(*cm), GFP_KERNEL);
1439 return -ENOMEM;
1442 cm->dev = &pdev->dev;
1443 cm->desc = desc;
1448 cm_timer = devm_kzalloc(cm->dev, sizeof(*cm_timer), GFP_KERNEL);
1450 return -ENOMEM;
1458 if (desc->fullbatt_uV == 0) {
1459 dev_info(&pdev->dev, "Ignoring full-battery voltage threshold as it is not supplied\n");
1461 if (!desc->fullbatt_vchkdrop_uV) {
1462 dev_info(&pdev->dev, "Disabling full-battery voltage drop checking mechanism as it is not supplied\n");
1463 desc->fullbatt_vchkdrop_uV = 0;
1465 if (desc->fullbatt_soc == 0) {
1466 dev_info(&pdev->dev, "Ignoring full-battery soc(state of charge) threshold as it is not supplied\n");
1468 if (desc->fullbatt_full_capacity == 0) {
1469 dev_info(&pdev->dev, "Ignoring full-battery full capacity threshold as it is not supplied\n");
1472 if (!desc->charger_regulators || desc->num_charger_regulators < 1) {
1473 dev_err(&pdev->dev, "charger_regulators undefined\n");
1474 return -EINVAL;
1477 if (!desc->psy_charger_stat || !desc->psy_charger_stat[0]) {
1478 dev_err(&pdev->dev, "No power supply defined\n");
1479 return -EINVAL;
1482 if (!desc->psy_fuel_gauge) {
1483 dev_err(&pdev->dev, "No fuel gauge power supply defined\n");
1484 return -EINVAL;
1488 for (i = 0; desc->psy_charger_stat[i]; i++) {
1491 psy = power_supply_get_by_name(desc->psy_charger_stat[i]);
1493 dev_err(&pdev->dev, "Cannot find power supply \"%s\"\n",
1494 desc->psy_charger_stat[i]);
1495 return -ENODEV;
1500 if (cm->desc->polling_mode != CM_POLL_DISABLE &&
1501 (desc->polling_interval_ms == 0 ||
1502 msecs_to_jiffies(desc->polling_interval_ms) <= CM_JIFFIES_SMALL)) {
1503 dev_err(&pdev->dev, "polling_interval_ms is too small\n");
1504 return -EINVAL;
1507 if (!desc->charging_max_duration_ms ||
1508 !desc->discharging_max_duration_ms) {
1509 dev_info(&pdev->dev, "Cannot limit charging duration checking mechanism to prevent overcharge/overheat and control discharging duration\n");
1510 desc->charging_max_duration_ms = 0;
1511 desc->discharging_max_duration_ms = 0;
1516 memcpy(&cm->charger_psy_desc, &psy_default, sizeof(psy_default));
1518 if (!desc->psy_name)
1519 strscpy(cm->psy_name_buf, psy_default.name,
1520 sizeof(cm->psy_name_buf));
1522 strscpy(cm->psy_name_buf, desc->psy_name,
1523 sizeof(cm->psy_name_buf));
1524 cm->charger_psy_desc.name = cm->psy_name_buf;
1527 properties = devm_kcalloc(&pdev->dev,
1532 return -ENOMEM;
1539 /* Find which optional psy-properties are available */
1540 fuel_gauge = power_supply_get_by_name(desc->psy_fuel_gauge);
1542 dev_err(&pdev->dev, "Cannot find power supply \"%s\"\n",
1543 desc->psy_fuel_gauge);
1544 return -ENODEV;
1568 dev_err(&pdev->dev, "Failed to initialize thermal data\n");
1569 cm->desc->measure_battery_temp = false;
1573 cm->charger_psy_desc.properties = properties;
1574 cm->charger_psy_desc.num_properties = num_properties;
1579 dev_err(&pdev->dev,
1583 psy_cfg.attr_grp = desc->sysfs_groups;
1585 cm->charger_psy = power_supply_register(&pdev->dev,
1586 &cm->charger_psy_desc,
1588 if (IS_ERR(cm->charger_psy)) {
1589 dev_err(&pdev->dev, "Cannot register charger-manager with name \"%s\"\n",
1590 cm->charger_psy_desc.name);
1591 return PTR_ERR(cm->charger_psy);
1597 dev_err(&pdev->dev, "Cannot initialize extcon device\n");
1603 list_add(&cm->entry, &cm_list);
1607 * Charger-manager is capable of waking up the system from sleep
1610 device_init_wakeup(&pdev->dev, true);
1611 device_set_wakeup_capable(&pdev->dev, false);
1614 * Charger-manager have to check the charging state right after
1615 * initialization of charger-manager and then update current charging
1625 for (i = 0; i < desc->num_charger_regulators; i++)
1626 regulator_put(desc->charger_regulators[i].consumer);
1628 power_supply_unregister(cm->charger_psy);
1636 struct charger_desc *desc = cm->desc;
1641 list_del(&cm->entry);
1647 for (i = 0 ; i < desc->num_charger_regulators ; i++)
1648 regulator_put(desc->charger_regulators[i].consumer);
1650 power_supply_unregister(cm->charger_psy);
1656 { "charger-manager", 0 },
1665 return -EAGAIN;
1693 return -EBUSY;
1721 cm_suspend_duration_ms -= ktime_to_ms(remain);
1727 device_set_wakeup_capable(cm->dev, false);
1738 .name = "charger-manager",
1751 return -ENOMEM;
1769 MODULE_DESCRIPTION("Charger Manager");