Lines Matching refs:battery
3 * battery.c - ACPI Battery Driver (Revision: 2.0)
30 #include <acpi/battery.h>
49 ACPI_MODULE_NAME("battery");
78 /* Lists of PMIC ACPI HIDs with an (often better) native battery driver */
89 is running on battery or not. When mAh is the unit, most
144 static inline int acpi_battery_present(struct acpi_battery *battery)
146 return battery->device->status.battery_present;
149 static int acpi_battery_technology(struct acpi_battery *battery)
151 if (!strcasecmp("NiCd", battery->type))
153 if (!strcasecmp("NiMH", battery->type))
155 if (!strcasecmp("LION", battery->type))
157 if (!strncasecmp("LI-ION", battery->type, 6))
159 if (!strcasecmp("LiP", battery->type))
164 static int acpi_battery_get_state(struct acpi_battery *battery);
166 static int acpi_battery_is_charged(struct acpi_battery *battery)
169 if (battery->state != 0)
172 /* battery not reporting charge */
173 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN ||
174 battery->capacity_now == 0)
178 if (battery->full_charge_capacity == battery->capacity_now)
182 if (battery->design_capacity <= battery->capacity_now)
189 static bool acpi_battery_is_degraded(struct acpi_battery *battery)
191 return ACPI_BATTERY_CAPACITY_VALID(battery->full_charge_capacity) &&
192 ACPI_BATTERY_CAPACITY_VALID(battery->design_capacity) &&
193 battery->full_charge_capacity < battery->design_capacity;
196 static int acpi_battery_handle_discharging(struct acpi_battery *battery)
199 * Some devices wrongly report discharging if the battery's charge level
204 battery->rate_now == 0)
215 struct acpi_battery *battery = to_acpi_battery(psy);
217 if (acpi_battery_present(battery)) {
218 /* run battery update only if it is present */
219 acpi_battery_get_state(battery);
224 if (battery->state & ACPI_BATTERY_STATE_DISCHARGING)
225 val->intval = acpi_battery_handle_discharging(battery);
226 else if (battery->state & ACPI_BATTERY_STATE_CHARGING)
228 else if (acpi_battery_is_charged(battery))
236 val->intval = acpi_battery_present(battery);
239 val->intval = acpi_battery_technology(battery);
242 val->intval = battery->cycle_count;
245 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
248 val->intval = battery->design_voltage * 1000;
251 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
254 val->intval = battery->voltage_now * 1000;
258 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
261 val->intval = battery->rate_now * 1000;
265 if (!ACPI_BATTERY_CAPACITY_VALID(battery->design_capacity))
268 val->intval = battery->design_capacity * 1000;
272 if (!ACPI_BATTERY_CAPACITY_VALID(battery->full_charge_capacity))
275 val->intval = battery->full_charge_capacity * 1000;
279 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
282 val->intval = battery->capacity_now * 1000;
285 if (ACPI_BATTERY_CAPACITY_VALID(battery->full_charge_capacity))
286 full_capacity = battery->full_charge_capacity;
287 else if (ACPI_BATTERY_CAPACITY_VALID(battery->design_capacity))
288 full_capacity = battery->design_capacity;
290 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN ||
294 val->intval = battery->capacity_now * 100/
298 if (battery->state & ACPI_BATTERY_STATE_CRITICAL)
300 else if (test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags) &&
301 (battery->capacity_now <= battery->alarm))
303 else if (acpi_battery_is_charged(battery))
309 val->strval = battery->model_number;
312 val->strval = battery->oem_info;
315 val->strval = battery->serial_number;
441 static int extract_package(struct acpi_battery *battery,
454 u8 *ptr = (u8 *)battery + offsets[i].offset;
465 int *x = (int *)((u8 *)battery + offsets[i].offset);
473 static int acpi_battery_get_status(struct acpi_battery *battery)
475 if (acpi_bus_get_status(battery->device)) {
484 struct acpi_battery *battery,
490 result = extract_package(battery, buffer->pointer,
494 result = extract_package(battery, buffer->pointer,
498 result = extract_package(battery, buffer->pointer,
500 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
501 battery->full_charge_capacity = battery->design_capacity;
502 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
503 battery->power_unit && battery->design_voltage) {
504 battery->design_capacity = battery->design_capacity *
505 10000 / battery->design_voltage;
506 battery->full_charge_capacity = battery->full_charge_capacity *
507 10000 / battery->design_voltage;
508 battery->design_capacity_warning =
509 battery->design_capacity_warning *
510 10000 / battery->design_voltage;
517 if (test_bit(ACPI_BATTERY_QUIRK_DEGRADED_FULL_CHARGE, &battery->flags) &&
518 battery->capacity_now > battery->full_charge_capacity)
519 battery->capacity_now = battery->full_charge_capacity;
524 static int acpi_battery_get_info(struct acpi_battery *battery)
526 const int xinfo = test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
530 if (!acpi_battery_present(battery))
538 mutex_lock(&battery->lock);
539 status = acpi_evaluate_object(battery->device->handle,
542 mutex_unlock(&battery->lock);
549 battery,
563 static int acpi_battery_get_state(struct acpi_battery *battery)
569 if (!acpi_battery_present(battery))
572 if (battery->update_time &&
573 time_before(jiffies, battery->update_time +
577 mutex_lock(&battery->lock);
578 status = acpi_evaluate_object(battery->device->handle, "_BST",
580 mutex_unlock(&battery->lock);
587 result = extract_package(battery, buffer.pointer,
589 battery->update_time = jiffies;
596 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA &&
597 battery->rate_now != ACPI_BATTERY_VALUE_UNKNOWN &&
598 (s16)(battery->rate_now) < 0) {
599 battery->rate_now = abs((s16)battery->rate_now);
600 pr_warn_once(FW_BUG "battery: (dis)charge rate invalid.\n");
603 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags)
604 && battery->capacity_now >= 0 && battery->capacity_now <= 100)
605 battery->capacity_now = (battery->capacity_now *
606 battery->full_charge_capacity) / 100;
607 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
608 battery->power_unit && battery->design_voltage) {
609 battery->capacity_now = battery->capacity_now *
610 10000 / battery->design_voltage;
612 if (test_bit(ACPI_BATTERY_QUIRK_DEGRADED_FULL_CHARGE, &battery->flags) &&
613 battery->capacity_now > battery->full_charge_capacity)
614 battery->capacity_now = battery->full_charge_capacity;
619 static int acpi_battery_set_alarm(struct acpi_battery *battery)
623 if (!acpi_battery_present(battery) ||
624 !test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags))
627 mutex_lock(&battery->lock);
628 status = acpi_execute_simple_method(battery->device->handle, "_BTP",
629 battery->alarm);
630 mutex_unlock(&battery->lock);
635 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", battery->alarm));
639 static int acpi_battery_init_alarm(struct acpi_battery *battery)
642 if (!acpi_has_method(battery->device->handle, "_BTP")) {
643 clear_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
646 set_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
647 if (!battery->alarm)
648 battery->alarm = battery->design_capacity_warning;
649 return acpi_battery_set_alarm(battery);
656 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
657 return sprintf(buf, "%d\n", battery->alarm * 1000);
665 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
667 battery->alarm = x/1000;
668 if (acpi_battery_present(battery))
669 acpi_battery_set_alarm(battery);
694 struct acpi_battery *battery;
701 list_for_each_entry(battery, &acpi_battery_list, list) {
702 hook->remove_battery(battery->bat);
718 struct acpi_battery *battery;
725 * to notify the hook that a battery is available
726 * for each battery, so that the driver may add
729 list_for_each_entry(battery, &acpi_battery_list, list) {
730 if (hook->add_battery(battery->bat)) {
732 * If a add-battery returns non-zero,
749 * This function gets called right after the battery sysfs
753 static void battery_hook_add_battery(struct acpi_battery *battery)
758 INIT_LIST_HEAD(&battery->list);
759 list_add(&battery->list, &acpi_battery_list);
761 * Since we added a new battery to the list, we need to
764 * when a battery gets hotplugged or initialized
765 * during the battery module initialization.
768 if (hook_node->add_battery(battery->bat)) {
781 static void battery_hook_remove_battery(struct acpi_battery *battery)
788 * custom attributes from the battery.
791 hook->remove_battery(battery->bat);
793 /* Then, just remove the battery from the list */
794 list_del(&battery->list);
813 static int sysfs_add_battery(struct acpi_battery *battery)
815 struct power_supply_config psy_cfg = { .drv_data = battery, };
818 if (!ACPI_BATTERY_CAPACITY_VALID(battery->full_charge_capacity) &&
819 !ACPI_BATTERY_CAPACITY_VALID(battery->design_capacity))
822 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) {
824 battery->bat_desc.properties =
826 battery->bat_desc.num_properties =
829 battery->bat_desc.properties = charge_battery_props;
830 battery->bat_desc.num_properties =
835 battery->bat_desc.properties =
837 battery->bat_desc.num_properties =
840 battery->bat_desc.properties = energy_battery_props;
841 battery->bat_desc.num_properties =
846 battery->bat_desc.name = acpi_device_bid(battery->device);
847 battery->bat_desc.type = POWER_SUPPLY_TYPE_BATTERY;
848 battery->bat_desc.get_property = acpi_battery_get_property;
850 battery->bat = power_supply_register_no_ws(&battery->device->dev,
851 &battery->bat_desc, &psy_cfg);
853 if (IS_ERR(battery->bat)) {
854 int result = PTR_ERR(battery->bat);
856 battery->bat = NULL;
859 battery_hook_add_battery(battery);
860 return device_create_file(&battery->bat->dev, &alarm_attr);
863 static void sysfs_remove_battery(struct acpi_battery *battery)
865 mutex_lock(&battery->sysfs_lock);
866 if (!battery->bat) {
867 mutex_unlock(&battery->sysfs_lock);
870 battery_hook_remove_battery(battery);
871 device_remove_file(&battery->bat->dev, &alarm_attr);
872 power_supply_unregister(battery->bat);
873 battery->bat = NULL;
874 mutex_unlock(&battery->sysfs_lock);
879 struct acpi_battery *battery = (struct acpi_battery *)private;
887 if (battery->design_capacity * battery->design_voltage / 1000
889 battery->design_capacity * 10 == dmi_capacity)
891 &battery->flags);
897 * report percentage battery remaining capacity directly to OS.
901 * Now we found some battery reports percentage remaining capacity
907 static void acpi_battery_quirks(struct acpi_battery *battery)
909 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
912 if (battery->full_charge_capacity == 100 &&
913 battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN &&
914 battery->capacity_now >= 0 && battery->capacity_now <= 100) {
915 set_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags);
916 battery->full_charge_capacity = battery->design_capacity;
917 battery->capacity_now = (battery->capacity_now *
918 battery->full_charge_capacity) / 100;
921 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags))
924 if (battery->power_unit && dmi_name_in_vendors("LENOVO")) {
928 dmi_walk(find_battery, battery);
930 &battery->flags) &&
931 battery->design_voltage) {
932 battery->design_capacity =
933 battery->design_capacity *
934 10000 / battery->design_voltage;
935 battery->full_charge_capacity =
936 battery->full_charge_capacity *
937 10000 / battery->design_voltage;
938 battery->design_capacity_warning =
939 battery->design_capacity_warning *
940 10000 / battery->design_voltage;
941 battery->capacity_now = battery->capacity_now *
942 10000 / battery->design_voltage;
947 if (test_bit(ACPI_BATTERY_QUIRK_DEGRADED_FULL_CHARGE, &battery->flags))
950 if (acpi_battery_is_degraded(battery) &&
951 battery->capacity_now > battery->full_charge_capacity) {
952 set_bit(ACPI_BATTERY_QUIRK_DEGRADED_FULL_CHARGE, &battery->flags);
953 battery->capacity_now = battery->full_charge_capacity;
957 static int acpi_battery_update(struct acpi_battery *battery, bool resume)
959 int result = acpi_battery_get_status(battery);
964 if (!acpi_battery_present(battery)) {
965 sysfs_remove_battery(battery);
966 battery->update_time = 0;
973 if (!battery->update_time) {
974 result = acpi_battery_get_info(battery);
977 acpi_battery_init_alarm(battery);
980 result = acpi_battery_get_state(battery);
983 acpi_battery_quirks(battery);
985 if (!battery->bat) {
986 result = sysfs_add_battery(battery);
992 * Wakeup the system if battery is critical low
995 if ((battery->state & ACPI_BATTERY_STATE_CRITICAL) ||
996 (test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags) &&
997 (battery->capacity_now <= battery->alarm)))
998 acpi_pm_wakeup_event(&battery->device->dev);
1003 static void acpi_battery_refresh(struct acpi_battery *battery)
1007 if (!battery->bat)
1010 power_unit = battery->power_unit;
1012 acpi_battery_get_info(battery);
1014 if (power_unit == battery->power_unit)
1017 /* The battery has changed its reporting units. */
1018 sysfs_remove_battery(battery);
1019 sysfs_add_battery(battery);
1028 struct acpi_battery *battery = acpi_driver_data(device);
1031 if (!battery)
1033 old = battery->bat;
1037 * triggered, battery state is still reported as "Full", and changes to
1043 acpi_battery_refresh(battery);
1044 acpi_battery_update(battery, false);
1047 acpi_battery_present(battery));
1048 acpi_notifier_call_chain(device, event, acpi_battery_present(battery));
1050 if (old && battery->bat)
1051 power_supply_changed(battery->bat);
1057 struct acpi_battery *battery = container_of(nb, struct acpi_battery,
1064 if (!acpi_battery_present(battery))
1067 if (battery->bat) {
1068 acpi_battery_refresh(battery);
1070 result = acpi_battery_get_info(battery);
1074 result = sysfs_add_battery(battery);
1079 acpi_battery_init_alarm(battery);
1080 acpi_battery_get_state(battery);
1191 * during boot up and this causes battery driver fails to be
1192 * probed due to failure of getting battery information
1197 static int acpi_battery_update_retry(struct acpi_battery *battery)
1202 ret = acpi_battery_update(battery, false);
1214 struct acpi_battery *battery = NULL;
1222 battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
1223 if (!battery)
1225 battery->device = device;
1228 device->driver_data = battery;
1229 mutex_init(&battery->lock);
1230 mutex_init(&battery->sysfs_lock);
1231 if (acpi_has_method(battery->device->handle, "_BIX"))
1232 set_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
1234 result = acpi_battery_update_retry(battery);
1238 pr_info(PREFIX "%s Slot [%s] (battery %s)\n",
1242 battery->pm_nb.notifier_call = battery_notify;
1243 register_pm_notifier(&battery->pm_nb);
1250 sysfs_remove_battery(battery);
1251 mutex_destroy(&battery->lock);
1252 mutex_destroy(&battery->sysfs_lock);
1253 kfree(battery);
1259 struct acpi_battery *battery = NULL;
1264 battery = acpi_driver_data(device);
1265 unregister_pm_notifier(&battery->pm_nb);
1266 sysfs_remove_battery(battery);
1267 mutex_destroy(&battery->lock);
1268 mutex_destroy(&battery->sysfs_lock);
1269 kfree(battery);
1277 struct acpi_battery *battery;
1282 battery = acpi_driver_data(to_acpi_device(dev));
1283 if (!battery)
1286 battery->update_time = 0;
1287 acpi_battery_update(battery, true);
1297 .name = "battery",