Lines Matching defs:battery
3 * battery.c - ACPI Battery Driver (Revision: 2.0)
11 #define pr_fmt(fmt) "ACPI: battery: " fmt
30 #include <acpi/battery.h>
78 * is running on battery or not. When mAh is the unit, most
134 static inline int acpi_battery_present(struct acpi_battery *battery)
136 return battery->device->status.battery_present;
139 static int acpi_battery_technology(struct acpi_battery *battery)
141 if (!strcasecmp("NiCd", battery->type))
143 if (!strcasecmp("NiMH", battery->type))
145 if (!strcasecmp("LION", battery->type))
147 if (!strncasecmp("LI-ION", battery->type, 6))
149 if (!strcasecmp("LiP", battery->type))
154 static int acpi_battery_get_state(struct acpi_battery *battery);
156 static int acpi_battery_is_charged(struct acpi_battery *battery)
159 if (battery->state != 0)
162 /* battery not reporting charge */
163 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN ||
164 battery->capacity_now == 0)
168 if (battery->full_charge_capacity == battery->capacity_now)
172 if (battery->design_capacity <= battery->capacity_now)
179 static bool acpi_battery_is_degraded(struct acpi_battery *battery)
181 return ACPI_BATTERY_CAPACITY_VALID(battery->full_charge_capacity) &&
182 ACPI_BATTERY_CAPACITY_VALID(battery->design_capacity) &&
183 battery->full_charge_capacity < battery->design_capacity;
186 static int acpi_battery_handle_discharging(struct acpi_battery *battery)
189 * Some devices wrongly report discharging if the battery's charge level
194 battery->rate_now == 0)
205 struct acpi_battery *battery = to_acpi_battery(psy);
207 if (acpi_battery_present(battery)) {
208 /* run battery update only if it is present */
209 acpi_battery_get_state(battery);
214 if (battery->state & ACPI_BATTERY_STATE_DISCHARGING)
215 val->intval = acpi_battery_handle_discharging(battery);
216 else if (battery->state & ACPI_BATTERY_STATE_CHARGING)
218 else if (acpi_battery_is_charged(battery))
224 val->intval = acpi_battery_present(battery);
227 val->intval = acpi_battery_technology(battery);
230 val->intval = battery->cycle_count;
233 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
236 val->intval = battery->design_voltage * 1000;
239 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
242 val->intval = battery->voltage_now * 1000;
246 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
249 val->intval = battery->rate_now * 1000;
253 if (!ACPI_BATTERY_CAPACITY_VALID(battery->design_capacity))
256 val->intval = battery->design_capacity * 1000;
260 if (!ACPI_BATTERY_CAPACITY_VALID(battery->full_charge_capacity))
263 val->intval = battery->full_charge_capacity * 1000;
267 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
270 val->intval = battery->capacity_now * 1000;
273 if (ACPI_BATTERY_CAPACITY_VALID(battery->full_charge_capacity))
274 full_capacity = battery->full_charge_capacity;
275 else if (ACPI_BATTERY_CAPACITY_VALID(battery->design_capacity))
276 full_capacity = battery->design_capacity;
278 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN ||
282 val->intval = battery->capacity_now * 100/
286 if (battery->state & ACPI_BATTERY_STATE_CRITICAL)
288 else if (test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags) &&
289 (battery->capacity_now <= battery->alarm))
291 else if (acpi_battery_is_charged(battery))
297 val->strval = battery->model_number;
300 val->strval = battery->oem_info;
303 val->strval = battery->serial_number;
427 static int extract_package(struct acpi_battery *battery,
441 u8 *ptr = (u8 *)battery + offsets[i].offset;
462 int *x = (int *)((u8 *)battery + offsets[i].offset);
470 static int acpi_battery_get_status(struct acpi_battery *battery)
472 if (acpi_bus_get_status(battery->device)) {
473 acpi_handle_info(battery->device->handle,
482 struct acpi_battery *battery,
488 result = extract_package(battery, buffer->pointer,
492 result = extract_package(battery, buffer->pointer,
496 result = extract_package(battery, buffer->pointer,
498 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
499 battery->full_charge_capacity = battery->design_capacity;
500 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
501 battery->power_unit && battery->design_voltage) {
502 battery->design_capacity = battery->design_capacity *
503 10000 / battery->design_voltage;
504 battery->full_charge_capacity = battery->full_charge_capacity *
505 10000 / battery->design_voltage;
506 battery->design_capacity_warning =
507 battery->design_capacity_warning *
508 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);
545 acpi_handle_info(battery->device->handle,
551 battery,
565 static int acpi_battery_get_state(struct acpi_battery *battery)
571 if (!acpi_battery_present(battery))
574 if (battery->update_time &&
575 time_before(jiffies, battery->update_time +
579 mutex_lock(&battery->lock);
580 status = acpi_evaluate_object(battery->device->handle, "_BST",
582 mutex_unlock(&battery->lock);
585 acpi_handle_info(battery->device->handle,
591 result = extract_package(battery, buffer.pointer,
593 battery->update_time = jiffies;
600 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA &&
601 battery->rate_now != ACPI_BATTERY_VALUE_UNKNOWN &&
602 (s16)(battery->rate_now) < 0) {
603 battery->rate_now = abs((s16)battery->rate_now);
607 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags)
608 && battery->capacity_now >= 0 && battery->capacity_now <= 100)
609 battery->capacity_now = (battery->capacity_now *
610 battery->full_charge_capacity) / 100;
611 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
612 battery->power_unit && battery->design_voltage) {
613 battery->capacity_now = battery->capacity_now *
614 10000 / battery->design_voltage;
616 if (test_bit(ACPI_BATTERY_QUIRK_DEGRADED_FULL_CHARGE, &battery->flags) &&
617 battery->capacity_now > battery->full_charge_capacity)
618 battery->capacity_now = battery->full_charge_capacity;
623 static int acpi_battery_set_alarm(struct acpi_battery *battery)
627 if (!acpi_battery_present(battery) ||
628 !test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags))
631 mutex_lock(&battery->lock);
632 status = acpi_execute_simple_method(battery->device->handle, "_BTP",
633 battery->alarm);
634 mutex_unlock(&battery->lock);
639 acpi_handle_debug(battery->device->handle, "Alarm set to %d\n",
640 battery->alarm);
645 static int acpi_battery_init_alarm(struct acpi_battery *battery)
648 if (!acpi_has_method(battery->device->handle, "_BTP")) {
649 clear_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
652 set_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
653 if (!battery->alarm)
654 battery->alarm = battery->design_capacity_warning;
655 return acpi_battery_set_alarm(battery);
662 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
664 return sprintf(buf, "%d\n", battery->alarm * 1000);
672 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
675 battery->alarm = x/1000;
676 if (acpi_battery_present(battery))
677 acpi_battery_set_alarm(battery);
702 struct acpi_battery *battery;
709 list_for_each_entry(battery, &acpi_battery_list, list) {
710 if (!hook->remove_battery(battery->bat, hook))
711 power_supply_changed(battery->bat);
727 struct acpi_battery *battery;
734 * to notify the hook that a battery is available
735 * for each battery, so that the driver may add
738 list_for_each_entry(battery, &acpi_battery_list, list) {
739 if (hook->add_battery(battery->bat, hook)) {
741 * If a add-battery returns non-zero,
751 power_supply_changed(battery->bat);
760 * This function gets called right after the battery sysfs
764 static void battery_hook_add_battery(struct acpi_battery *battery)
769 INIT_LIST_HEAD(&battery->list);
770 list_add(&battery->list, &acpi_battery_list);
772 * Since we added a new battery to the list, we need to
775 * when a battery gets hotplugged or initialized
776 * during the battery module initialization.
779 if (hook_node->add_battery(battery->bat, hook_node)) {
792 static void battery_hook_remove_battery(struct acpi_battery *battery)
799 * custom attributes from the battery.
802 hook->remove_battery(battery->bat, hook);
804 /* Then, just remove the battery from the list */
805 list_del(&battery->list);
824 static int sysfs_add_battery(struct acpi_battery *battery)
826 struct power_supply_config psy_cfg = { .drv_data = battery, };
829 if (!ACPI_BATTERY_CAPACITY_VALID(battery->full_charge_capacity) &&
830 !ACPI_BATTERY_CAPACITY_VALID(battery->design_capacity))
833 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) {
835 battery->bat_desc.properties =
837 battery->bat_desc.num_properties =
840 battery->bat_desc.properties = charge_battery_props;
841 battery->bat_desc.num_properties =
846 battery->bat_desc.properties =
848 battery->bat_desc.num_properties =
851 battery->bat_desc.properties = energy_battery_props;
852 battery->bat_desc.num_properties =
857 battery->bat_desc.name = acpi_device_bid(battery->device);
858 battery->bat_desc.type = POWER_SUPPLY_TYPE_BATTERY;
859 battery->bat_desc.get_property = acpi_battery_get_property;
861 battery->bat = power_supply_register_no_ws(&battery->device->dev,
862 &battery->bat_desc, &psy_cfg);
864 if (IS_ERR(battery->bat)) {
865 int result = PTR_ERR(battery->bat);
867 battery->bat = NULL;
870 battery_hook_add_battery(battery);
871 return device_create_file(&battery->bat->dev, &alarm_attr);
874 static void sysfs_remove_battery(struct acpi_battery *battery)
876 mutex_lock(&battery->sysfs_lock);
877 if (!battery->bat) {
878 mutex_unlock(&battery->sysfs_lock);
881 battery_hook_remove_battery(battery);
882 device_remove_file(&battery->bat->dev, &alarm_attr);
883 power_supply_unregister(battery->bat);
884 battery->bat = NULL;
885 mutex_unlock(&battery->sysfs_lock);
890 struct acpi_battery *battery = (struct acpi_battery *)private;
900 if (battery->design_capacity * battery->design_voltage / 1000
902 battery->design_capacity * 10 == dmi_capacity)
904 &battery->flags);
910 * report percentage battery remaining capacity directly to OS.
914 * Now we found some battery reports percentage remaining capacity
920 static void acpi_battery_quirks(struct acpi_battery *battery)
922 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
925 if (battery->full_charge_capacity == 100 &&
926 battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN &&
927 battery->capacity_now >= 0 && battery->capacity_now <= 100) {
928 set_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags);
929 battery->full_charge_capacity = battery->design_capacity;
930 battery->capacity_now = (battery->capacity_now *
931 battery->full_charge_capacity) / 100;
934 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags))
937 if (battery->power_unit && dmi_name_in_vendors("LENOVO")) {
942 dmi_walk(find_battery, battery);
944 &battery->flags) &&
945 battery->design_voltage) {
946 battery->design_capacity =
947 battery->design_capacity *
948 10000 / battery->design_voltage;
949 battery->full_charge_capacity =
950 battery->full_charge_capacity *
951 10000 / battery->design_voltage;
952 battery->design_capacity_warning =
953 battery->design_capacity_warning *
954 10000 / battery->design_voltage;
955 battery->capacity_now = battery->capacity_now *
956 10000 / battery->design_voltage;
961 if (test_bit(ACPI_BATTERY_QUIRK_DEGRADED_FULL_CHARGE, &battery->flags))
964 if (acpi_battery_is_degraded(battery) &&
965 battery->capacity_now > battery->full_charge_capacity) {
966 set_bit(ACPI_BATTERY_QUIRK_DEGRADED_FULL_CHARGE, &battery->flags);
967 battery->capacity_now = battery->full_charge_capacity;
971 static int acpi_battery_update(struct acpi_battery *battery, bool resume)
973 int result = acpi_battery_get_status(battery);
978 if (!acpi_battery_present(battery)) {
979 sysfs_remove_battery(battery);
980 battery->update_time = 0;
987 if (!battery->update_time) {
988 result = acpi_battery_get_info(battery);
991 acpi_battery_init_alarm(battery);
994 result = acpi_battery_get_state(battery);
997 acpi_battery_quirks(battery);
999 if (!battery->bat) {
1000 result = sysfs_add_battery(battery);
1006 * Wakeup the system if battery is critical low
1009 if ((battery->state & ACPI_BATTERY_STATE_CRITICAL) ||
1010 (test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags) &&
1011 (battery->capacity_now <= battery->alarm)))
1012 acpi_pm_wakeup_event(&battery->device->dev);
1017 static void acpi_battery_refresh(struct acpi_battery *battery)
1021 if (!battery->bat)
1024 power_unit = battery->power_unit;
1026 acpi_battery_get_info(battery);
1028 if (power_unit == battery->power_unit)
1031 /* The battery has changed its reporting units. */
1032 sysfs_remove_battery(battery);
1033 sysfs_add_battery(battery);
1040 struct acpi_battery *battery = acpi_driver_data(device);
1043 if (!battery)
1045 old = battery->bat;
1049 * triggered, battery state is still reported as "Full", and changes to
1055 acpi_battery_refresh(battery);
1056 acpi_battery_update(battery, false);
1059 acpi_battery_present(battery));
1060 acpi_notifier_call_chain(device, event, acpi_battery_present(battery));
1062 if (old && battery->bat)
1063 power_supply_changed(battery->bat);
1069 struct acpi_battery *battery = container_of(nb, struct acpi_battery,
1076 if (!acpi_battery_present(battery))
1079 if (battery->bat) {
1080 acpi_battery_refresh(battery);
1082 result = acpi_battery_get_info(battery);
1086 result = sysfs_add_battery(battery);
1091 acpi_battery_init_alarm(battery);
1092 acpi_battery_get_state(battery);
1161 * during boot up and this causes battery driver fails to be
1162 * probed due to failure of getting battery information
1167 static int acpi_battery_update_retry(struct acpi_battery *battery)
1172 ret = acpi_battery_update(battery, false);
1184 struct acpi_battery *battery = NULL;
1192 battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
1193 if (!battery)
1195 battery->device = device;
1198 device->driver_data = battery;
1199 mutex_init(&battery->lock);
1200 mutex_init(&battery->sysfs_lock);
1201 if (acpi_has_method(battery->device->handle, "_BIX"))
1202 set_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
1204 result = acpi_battery_update_retry(battery);
1208 pr_info("Slot [%s] (battery %s)\n", acpi_device_bid(device),
1211 battery->pm_nb.notifier_call = battery_notify;
1212 register_pm_notifier(&battery->pm_nb);
1225 unregister_pm_notifier(&battery->pm_nb);
1227 sysfs_remove_battery(battery);
1228 mutex_destroy(&battery->lock);
1229 mutex_destroy(&battery->sysfs_lock);
1230 kfree(battery);
1237 struct acpi_battery *battery = NULL;
1242 battery = acpi_driver_data(device);
1248 unregister_pm_notifier(&battery->pm_nb);
1249 sysfs_remove_battery(battery);
1251 mutex_destroy(&battery->lock);
1252 mutex_destroy(&battery->sysfs_lock);
1253 kfree(battery);
1260 struct acpi_battery *battery;
1265 battery = acpi_driver_data(to_acpi_device(dev));
1266 if (!battery)
1269 battery->update_time = 0;
1270 acpi_battery_update(battery, true);
1280 .name = "battery",