1 /* 2 * battery.c - ACPI Battery Driver (Revision: 2.0) 3 * 4 * Copyright (C) 2007 Alexey Starikovskiy <astarikovskiy@suse.de> 5 * Copyright (C) 2004-2007 Vladimir Lebedev <vladimir.p.lebedev@intel.com> 6 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com> 7 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com> 8 * 9 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 10 * 11 * This program is free software; you can redistribute it and/or modify 12 * it under the terms of the GNU General Public License as published by 13 * the Free Software Foundation; either version 2 of the License, or (at 14 * your option) any later version. 15 * 16 * This program is distributed in the hope that it will be useful, but 17 * WITHOUT ANY WARRANTY; without even the implied warranty of 18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 19 * General Public License for more details. 20 * 21 * You should have received a copy of the GNU General Public License along 22 * with this program; if not, write to the Free Software Foundation, Inc., 23 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. 24 * 25 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 26 */ 27 28 #include <linux/kernel.h> 29 #include <linux/module.h> 30 #include <linux/init.h> 31 #include <linux/types.h> 32 #include <linux/jiffies.h> 33 #include <linux/async.h> 34 #include <linux/dmi.h> 35 #include <linux/slab.h> 36 #include <linux/suspend.h> 37 #include <asm/unaligned.h> 38 39 #include <linux/acpi.h> 40 #include <linux/power_supply.h> 41 42 #include "battery.h" 43 44 #define PREFIX "ACPI: " 45 46 #define ACPI_BATTERY_VALUE_UNKNOWN 0xFFFFFFFF 47 48 #define ACPI_BATTERY_DEVICE_NAME "Battery" 49 50 /* Battery power unit: 0 means mW, 1 means mA */ 51 #define ACPI_BATTERY_POWER_UNIT_MA 1 52 53 #define _COMPONENT ACPI_BATTERY_COMPONENT 54 55 ACPI_MODULE_NAME("battery"); 56 57 MODULE_AUTHOR("Paul Diefenbaugh"); 58 MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>"); 59 MODULE_DESCRIPTION("ACPI Battery Driver"); 60 MODULE_LICENSE("GPL"); 61 62 static int battery_bix_broken_package; 63 static unsigned int cache_time = 1000; 64 module_param(cache_time, uint, 0644); 65 MODULE_PARM_DESC(cache_time, "cache time in milliseconds"); 66 67 static const struct acpi_device_id battery_device_ids[] = { 68 {"PNP0C0A", 0}, 69 {"", 0}, 70 }; 71 72 MODULE_DEVICE_TABLE(acpi, battery_device_ids); 73 74 enum { 75 ACPI_BATTERY_ALARM_PRESENT, 76 ACPI_BATTERY_XINFO_PRESENT, 77 ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, 78 /* On Lenovo Thinkpad models from 2010 and 2011, the power unit 79 switches between mWh and mAh depending on whether the system 80 is running on battery or not. When mAh is the unit, most 81 reported values are incorrect and need to be adjusted by 82 10000/design_voltage. Verified on x201, t410, t410s, and x220. 83 Pre-2010 and 2012 models appear to always report in mWh and 84 are thus unaffected (tested with t42, t61, t500, x200, x300, 85 and x230). Also, in mid-2012 Lenovo issued a BIOS update for 86 the 2011 models that fixes the issue (tested on x220 with a 87 post-1.29 BIOS), but as of Nov. 2012, no such update is 88 available for the 2010 models. */ 89 ACPI_BATTERY_QUIRK_THINKPAD_MAH, 90 }; 91 92 struct acpi_battery { 93 struct mutex lock; 94 struct mutex sysfs_lock; 95 struct power_supply bat; 96 struct acpi_device *device; 97 struct notifier_block pm_nb; 98 unsigned long update_time; 99 int revision; 100 int rate_now; 101 int capacity_now; 102 int voltage_now; 103 int design_capacity; 104 int full_charge_capacity; 105 int technology; 106 int design_voltage; 107 int design_capacity_warning; 108 int design_capacity_low; 109 int cycle_count; 110 int measurement_accuracy; 111 int max_sampling_time; 112 int min_sampling_time; 113 int max_averaging_interval; 114 int min_averaging_interval; 115 int capacity_granularity_1; 116 int capacity_granularity_2; 117 int alarm; 118 char model_number[32]; 119 char serial_number[32]; 120 char type[32]; 121 char oem_info[32]; 122 int state; 123 int power_unit; 124 unsigned long flags; 125 }; 126 127 #define to_acpi_battery(x) container_of(x, struct acpi_battery, bat) 128 129 static inline int acpi_battery_present(struct acpi_battery *battery) 130 { 131 return battery->device->status.battery_present; 132 } 133 134 static int acpi_battery_technology(struct acpi_battery *battery) 135 { 136 if (!strcasecmp("NiCd", battery->type)) 137 return POWER_SUPPLY_TECHNOLOGY_NiCd; 138 if (!strcasecmp("NiMH", battery->type)) 139 return POWER_SUPPLY_TECHNOLOGY_NiMH; 140 if (!strcasecmp("LION", battery->type)) 141 return POWER_SUPPLY_TECHNOLOGY_LION; 142 if (!strncasecmp("LI-ION", battery->type, 6)) 143 return POWER_SUPPLY_TECHNOLOGY_LION; 144 if (!strcasecmp("LiP", battery->type)) 145 return POWER_SUPPLY_TECHNOLOGY_LIPO; 146 return POWER_SUPPLY_TECHNOLOGY_UNKNOWN; 147 } 148 149 static int acpi_battery_get_state(struct acpi_battery *battery); 150 151 static int acpi_battery_is_charged(struct acpi_battery *battery) 152 { 153 /* either charging or discharging */ 154 if (battery->state != 0) 155 return 0; 156 157 /* battery not reporting charge */ 158 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN || 159 battery->capacity_now == 0) 160 return 0; 161 162 /* good batteries update full_charge as the batteries degrade */ 163 if (battery->full_charge_capacity == battery->capacity_now) 164 return 1; 165 166 /* fallback to using design values for broken batteries */ 167 if (battery->design_capacity == battery->capacity_now) 168 return 1; 169 170 /* we don't do any sort of metric based on percentages */ 171 return 0; 172 } 173 174 static int acpi_battery_get_property(struct power_supply *psy, 175 enum power_supply_property psp, 176 union power_supply_propval *val) 177 { 178 int ret = 0; 179 struct acpi_battery *battery = to_acpi_battery(psy); 180 181 if (acpi_battery_present(battery)) { 182 /* run battery update only if it is present */ 183 acpi_battery_get_state(battery); 184 } else if (psp != POWER_SUPPLY_PROP_PRESENT) 185 return -ENODEV; 186 switch (psp) { 187 case POWER_SUPPLY_PROP_STATUS: 188 if (battery->state & 0x01) 189 val->intval = POWER_SUPPLY_STATUS_DISCHARGING; 190 else if (battery->state & 0x02) 191 val->intval = POWER_SUPPLY_STATUS_CHARGING; 192 else if (acpi_battery_is_charged(battery)) 193 val->intval = POWER_SUPPLY_STATUS_FULL; 194 else 195 val->intval = POWER_SUPPLY_STATUS_UNKNOWN; 196 break; 197 case POWER_SUPPLY_PROP_PRESENT: 198 val->intval = acpi_battery_present(battery); 199 break; 200 case POWER_SUPPLY_PROP_TECHNOLOGY: 201 val->intval = acpi_battery_technology(battery); 202 break; 203 case POWER_SUPPLY_PROP_CYCLE_COUNT: 204 val->intval = battery->cycle_count; 205 break; 206 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN: 207 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN) 208 ret = -ENODEV; 209 else 210 val->intval = battery->design_voltage * 1000; 211 break; 212 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 213 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN) 214 ret = -ENODEV; 215 else 216 val->intval = battery->voltage_now * 1000; 217 break; 218 case POWER_SUPPLY_PROP_CURRENT_NOW: 219 case POWER_SUPPLY_PROP_POWER_NOW: 220 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN) 221 ret = -ENODEV; 222 else 223 val->intval = battery->rate_now * 1000; 224 break; 225 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN: 226 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN: 227 if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN) 228 ret = -ENODEV; 229 else 230 val->intval = battery->design_capacity * 1000; 231 break; 232 case POWER_SUPPLY_PROP_CHARGE_FULL: 233 case POWER_SUPPLY_PROP_ENERGY_FULL: 234 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN) 235 ret = -ENODEV; 236 else 237 val->intval = battery->full_charge_capacity * 1000; 238 break; 239 case POWER_SUPPLY_PROP_CHARGE_NOW: 240 case POWER_SUPPLY_PROP_ENERGY_NOW: 241 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN) 242 ret = -ENODEV; 243 else 244 val->intval = battery->capacity_now * 1000; 245 break; 246 case POWER_SUPPLY_PROP_CAPACITY: 247 if (battery->capacity_now && battery->full_charge_capacity) 248 val->intval = battery->capacity_now * 100/ 249 battery->full_charge_capacity; 250 else 251 val->intval = 0; 252 break; 253 case POWER_SUPPLY_PROP_MODEL_NAME: 254 val->strval = battery->model_number; 255 break; 256 case POWER_SUPPLY_PROP_MANUFACTURER: 257 val->strval = battery->oem_info; 258 break; 259 case POWER_SUPPLY_PROP_SERIAL_NUMBER: 260 val->strval = battery->serial_number; 261 break; 262 default: 263 ret = -EINVAL; 264 } 265 return ret; 266 } 267 268 static enum power_supply_property charge_battery_props[] = { 269 POWER_SUPPLY_PROP_STATUS, 270 POWER_SUPPLY_PROP_PRESENT, 271 POWER_SUPPLY_PROP_TECHNOLOGY, 272 POWER_SUPPLY_PROP_CYCLE_COUNT, 273 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN, 274 POWER_SUPPLY_PROP_VOLTAGE_NOW, 275 POWER_SUPPLY_PROP_CURRENT_NOW, 276 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, 277 POWER_SUPPLY_PROP_CHARGE_FULL, 278 POWER_SUPPLY_PROP_CHARGE_NOW, 279 POWER_SUPPLY_PROP_CAPACITY, 280 POWER_SUPPLY_PROP_MODEL_NAME, 281 POWER_SUPPLY_PROP_MANUFACTURER, 282 POWER_SUPPLY_PROP_SERIAL_NUMBER, 283 }; 284 285 static enum power_supply_property energy_battery_props[] = { 286 POWER_SUPPLY_PROP_STATUS, 287 POWER_SUPPLY_PROP_PRESENT, 288 POWER_SUPPLY_PROP_TECHNOLOGY, 289 POWER_SUPPLY_PROP_CYCLE_COUNT, 290 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN, 291 POWER_SUPPLY_PROP_VOLTAGE_NOW, 292 POWER_SUPPLY_PROP_POWER_NOW, 293 POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN, 294 POWER_SUPPLY_PROP_ENERGY_FULL, 295 POWER_SUPPLY_PROP_ENERGY_NOW, 296 POWER_SUPPLY_PROP_CAPACITY, 297 POWER_SUPPLY_PROP_MODEL_NAME, 298 POWER_SUPPLY_PROP_MANUFACTURER, 299 POWER_SUPPLY_PROP_SERIAL_NUMBER, 300 }; 301 302 /* -------------------------------------------------------------------------- 303 Battery Management 304 -------------------------------------------------------------------------- */ 305 struct acpi_offsets { 306 size_t offset; /* offset inside struct acpi_sbs_battery */ 307 u8 mode; /* int or string? */ 308 }; 309 310 static struct acpi_offsets state_offsets[] = { 311 {offsetof(struct acpi_battery, state), 0}, 312 {offsetof(struct acpi_battery, rate_now), 0}, 313 {offsetof(struct acpi_battery, capacity_now), 0}, 314 {offsetof(struct acpi_battery, voltage_now), 0}, 315 }; 316 317 static struct acpi_offsets info_offsets[] = { 318 {offsetof(struct acpi_battery, power_unit), 0}, 319 {offsetof(struct acpi_battery, design_capacity), 0}, 320 {offsetof(struct acpi_battery, full_charge_capacity), 0}, 321 {offsetof(struct acpi_battery, technology), 0}, 322 {offsetof(struct acpi_battery, design_voltage), 0}, 323 {offsetof(struct acpi_battery, design_capacity_warning), 0}, 324 {offsetof(struct acpi_battery, design_capacity_low), 0}, 325 {offsetof(struct acpi_battery, capacity_granularity_1), 0}, 326 {offsetof(struct acpi_battery, capacity_granularity_2), 0}, 327 {offsetof(struct acpi_battery, model_number), 1}, 328 {offsetof(struct acpi_battery, serial_number), 1}, 329 {offsetof(struct acpi_battery, type), 1}, 330 {offsetof(struct acpi_battery, oem_info), 1}, 331 }; 332 333 static struct acpi_offsets extended_info_offsets[] = { 334 {offsetof(struct acpi_battery, revision), 0}, 335 {offsetof(struct acpi_battery, power_unit), 0}, 336 {offsetof(struct acpi_battery, design_capacity), 0}, 337 {offsetof(struct acpi_battery, full_charge_capacity), 0}, 338 {offsetof(struct acpi_battery, technology), 0}, 339 {offsetof(struct acpi_battery, design_voltage), 0}, 340 {offsetof(struct acpi_battery, design_capacity_warning), 0}, 341 {offsetof(struct acpi_battery, design_capacity_low), 0}, 342 {offsetof(struct acpi_battery, cycle_count), 0}, 343 {offsetof(struct acpi_battery, measurement_accuracy), 0}, 344 {offsetof(struct acpi_battery, max_sampling_time), 0}, 345 {offsetof(struct acpi_battery, min_sampling_time), 0}, 346 {offsetof(struct acpi_battery, max_averaging_interval), 0}, 347 {offsetof(struct acpi_battery, min_averaging_interval), 0}, 348 {offsetof(struct acpi_battery, capacity_granularity_1), 0}, 349 {offsetof(struct acpi_battery, capacity_granularity_2), 0}, 350 {offsetof(struct acpi_battery, model_number), 1}, 351 {offsetof(struct acpi_battery, serial_number), 1}, 352 {offsetof(struct acpi_battery, type), 1}, 353 {offsetof(struct acpi_battery, oem_info), 1}, 354 }; 355 356 static int extract_package(struct acpi_battery *battery, 357 union acpi_object *package, 358 struct acpi_offsets *offsets, int num) 359 { 360 int i; 361 union acpi_object *element; 362 if (package->type != ACPI_TYPE_PACKAGE) 363 return -EFAULT; 364 for (i = 0; i < num; ++i) { 365 if (package->package.count <= i) 366 return -EFAULT; 367 element = &package->package.elements[i]; 368 if (offsets[i].mode) { 369 u8 *ptr = (u8 *)battery + offsets[i].offset; 370 if (element->type == ACPI_TYPE_STRING || 371 element->type == ACPI_TYPE_BUFFER) 372 strncpy(ptr, element->string.pointer, 32); 373 else if (element->type == ACPI_TYPE_INTEGER) { 374 strncpy(ptr, (u8 *)&element->integer.value, 375 sizeof(u64)); 376 ptr[sizeof(u64)] = 0; 377 } else 378 *ptr = 0; /* don't have value */ 379 } else { 380 int *x = (int *)((u8 *)battery + offsets[i].offset); 381 *x = (element->type == ACPI_TYPE_INTEGER) ? 382 element->integer.value : -1; 383 } 384 } 385 return 0; 386 } 387 388 static int acpi_battery_get_status(struct acpi_battery *battery) 389 { 390 if (acpi_bus_get_status(battery->device)) { 391 ACPI_EXCEPTION((AE_INFO, AE_ERROR, "Evaluating _STA")); 392 return -ENODEV; 393 } 394 return 0; 395 } 396 397 static int acpi_battery_get_info(struct acpi_battery *battery) 398 { 399 int result = -EFAULT; 400 acpi_status status = 0; 401 char *name = test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags) ? 402 "_BIX" : "_BIF"; 403 404 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 405 406 if (!acpi_battery_present(battery)) 407 return 0; 408 mutex_lock(&battery->lock); 409 status = acpi_evaluate_object(battery->device->handle, name, 410 NULL, &buffer); 411 mutex_unlock(&battery->lock); 412 413 if (ACPI_FAILURE(status)) { 414 ACPI_EXCEPTION((AE_INFO, status, "Evaluating %s", name)); 415 return -ENODEV; 416 } 417 418 if (battery_bix_broken_package) 419 result = extract_package(battery, buffer.pointer, 420 extended_info_offsets + 1, 421 ARRAY_SIZE(extended_info_offsets) - 1); 422 else if (test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags)) 423 result = extract_package(battery, buffer.pointer, 424 extended_info_offsets, 425 ARRAY_SIZE(extended_info_offsets)); 426 else 427 result = extract_package(battery, buffer.pointer, 428 info_offsets, ARRAY_SIZE(info_offsets)); 429 kfree(buffer.pointer); 430 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags)) 431 battery->full_charge_capacity = battery->design_capacity; 432 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) && 433 battery->power_unit && battery->design_voltage) { 434 battery->design_capacity = battery->design_capacity * 435 10000 / battery->design_voltage; 436 battery->full_charge_capacity = battery->full_charge_capacity * 437 10000 / battery->design_voltage; 438 battery->design_capacity_warning = 439 battery->design_capacity_warning * 440 10000 / battery->design_voltage; 441 /* Curiously, design_capacity_low, unlike the rest of them, 442 is correct. */ 443 /* capacity_granularity_* equal 1 on the systems tested, so 444 it's impossible to tell if they would need an adjustment 445 or not if their values were higher. */ 446 } 447 return result; 448 } 449 450 static int acpi_battery_get_state(struct acpi_battery *battery) 451 { 452 int result = 0; 453 acpi_status status = 0; 454 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 455 456 if (!acpi_battery_present(battery)) 457 return 0; 458 459 if (battery->update_time && 460 time_before(jiffies, battery->update_time + 461 msecs_to_jiffies(cache_time))) 462 return 0; 463 464 mutex_lock(&battery->lock); 465 status = acpi_evaluate_object(battery->device->handle, "_BST", 466 NULL, &buffer); 467 mutex_unlock(&battery->lock); 468 469 if (ACPI_FAILURE(status)) { 470 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST")); 471 return -ENODEV; 472 } 473 474 result = extract_package(battery, buffer.pointer, 475 state_offsets, ARRAY_SIZE(state_offsets)); 476 battery->update_time = jiffies; 477 kfree(buffer.pointer); 478 479 /* For buggy DSDTs that report negative 16-bit values for either 480 * charging or discharging current and/or report 0 as 65536 481 * due to bad math. 482 */ 483 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA && 484 battery->rate_now != ACPI_BATTERY_VALUE_UNKNOWN && 485 (s16)(battery->rate_now) < 0) { 486 battery->rate_now = abs((s16)battery->rate_now); 487 printk_once(KERN_WARNING FW_BUG "battery: (dis)charge rate" 488 " invalid.\n"); 489 } 490 491 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags) 492 && battery->capacity_now >= 0 && battery->capacity_now <= 100) 493 battery->capacity_now = (battery->capacity_now * 494 battery->full_charge_capacity) / 100; 495 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) && 496 battery->power_unit && battery->design_voltage) { 497 battery->capacity_now = battery->capacity_now * 498 10000 / battery->design_voltage; 499 } 500 return result; 501 } 502 503 static int acpi_battery_set_alarm(struct acpi_battery *battery) 504 { 505 acpi_status status = 0; 506 507 if (!acpi_battery_present(battery) || 508 !test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags)) 509 return -ENODEV; 510 511 mutex_lock(&battery->lock); 512 status = acpi_execute_simple_method(battery->device->handle, "_BTP", 513 battery->alarm); 514 mutex_unlock(&battery->lock); 515 516 if (ACPI_FAILURE(status)) 517 return -ENODEV; 518 519 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", battery->alarm)); 520 return 0; 521 } 522 523 static int acpi_battery_init_alarm(struct acpi_battery *battery) 524 { 525 /* See if alarms are supported, and if so, set default */ 526 if (!acpi_has_method(battery->device->handle, "_BTP")) { 527 clear_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags); 528 return 0; 529 } 530 set_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags); 531 if (!battery->alarm) 532 battery->alarm = battery->design_capacity_warning; 533 return acpi_battery_set_alarm(battery); 534 } 535 536 static ssize_t acpi_battery_alarm_show(struct device *dev, 537 struct device_attribute *attr, 538 char *buf) 539 { 540 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev)); 541 return sprintf(buf, "%d\n", battery->alarm * 1000); 542 } 543 544 static ssize_t acpi_battery_alarm_store(struct device *dev, 545 struct device_attribute *attr, 546 const char *buf, size_t count) 547 { 548 unsigned long x; 549 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev)); 550 if (sscanf(buf, "%lu\n", &x) == 1) 551 battery->alarm = x/1000; 552 if (acpi_battery_present(battery)) 553 acpi_battery_set_alarm(battery); 554 return count; 555 } 556 557 static struct device_attribute alarm_attr = { 558 .attr = {.name = "alarm", .mode = 0644}, 559 .show = acpi_battery_alarm_show, 560 .store = acpi_battery_alarm_store, 561 }; 562 563 static int sysfs_add_battery(struct acpi_battery *battery) 564 { 565 int result; 566 567 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) { 568 battery->bat.properties = charge_battery_props; 569 battery->bat.num_properties = 570 ARRAY_SIZE(charge_battery_props); 571 } else { 572 battery->bat.properties = energy_battery_props; 573 battery->bat.num_properties = 574 ARRAY_SIZE(energy_battery_props); 575 } 576 577 battery->bat.name = acpi_device_bid(battery->device); 578 battery->bat.type = POWER_SUPPLY_TYPE_BATTERY; 579 battery->bat.get_property = acpi_battery_get_property; 580 581 result = power_supply_register(&battery->device->dev, &battery->bat); 582 if (result) 583 return result; 584 return device_create_file(battery->bat.dev, &alarm_attr); 585 } 586 587 static void sysfs_remove_battery(struct acpi_battery *battery) 588 { 589 mutex_lock(&battery->sysfs_lock); 590 if (!battery->bat.dev) { 591 mutex_unlock(&battery->sysfs_lock); 592 return; 593 } 594 595 device_remove_file(battery->bat.dev, &alarm_attr); 596 power_supply_unregister(&battery->bat); 597 battery->bat.dev = NULL; 598 mutex_unlock(&battery->sysfs_lock); 599 } 600 601 static void find_battery(const struct dmi_header *dm, void *private) 602 { 603 struct acpi_battery *battery = (struct acpi_battery *)private; 604 /* Note: the hardcoded offsets below have been extracted from 605 the source code of dmidecode. */ 606 if (dm->type == DMI_ENTRY_PORTABLE_BATTERY && dm->length >= 8) { 607 const u8 *dmi_data = (const u8 *)(dm + 1); 608 int dmi_capacity = get_unaligned((const u16 *)(dmi_data + 6)); 609 if (dm->length >= 18) 610 dmi_capacity *= dmi_data[17]; 611 if (battery->design_capacity * battery->design_voltage / 1000 612 != dmi_capacity && 613 battery->design_capacity * 10 == dmi_capacity) 614 set_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, 615 &battery->flags); 616 } 617 } 618 619 /* 620 * According to the ACPI spec, some kinds of primary batteries can 621 * report percentage battery remaining capacity directly to OS. 622 * In this case, it reports the Last Full Charged Capacity == 100 623 * and BatteryPresentRate == 0xFFFFFFFF. 624 * 625 * Now we found some battery reports percentage remaining capacity 626 * even if it's rechargeable. 627 * https://bugzilla.kernel.org/show_bug.cgi?id=15979 628 * 629 * Handle this correctly so that they won't break userspace. 630 */ 631 static void acpi_battery_quirks(struct acpi_battery *battery) 632 { 633 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags)) 634 return; 635 636 if (battery->full_charge_capacity == 100 && 637 battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN && 638 battery->capacity_now >= 0 && battery->capacity_now <= 100) { 639 set_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags); 640 battery->full_charge_capacity = battery->design_capacity; 641 battery->capacity_now = (battery->capacity_now * 642 battery->full_charge_capacity) / 100; 643 } 644 645 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags)) 646 return; 647 648 if (battery->power_unit && dmi_name_in_vendors("LENOVO")) { 649 const char *s; 650 s = dmi_get_system_info(DMI_PRODUCT_VERSION); 651 if (s && !strnicmp(s, "ThinkPad", 8)) { 652 dmi_walk(find_battery, battery); 653 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, 654 &battery->flags) && 655 battery->design_voltage) { 656 battery->design_capacity = 657 battery->design_capacity * 658 10000 / battery->design_voltage; 659 battery->full_charge_capacity = 660 battery->full_charge_capacity * 661 10000 / battery->design_voltage; 662 battery->design_capacity_warning = 663 battery->design_capacity_warning * 664 10000 / battery->design_voltage; 665 battery->capacity_now = battery->capacity_now * 666 10000 / battery->design_voltage; 667 } 668 } 669 } 670 } 671 672 static int acpi_battery_update(struct acpi_battery *battery) 673 { 674 int result, old_present = acpi_battery_present(battery); 675 result = acpi_battery_get_status(battery); 676 if (result) 677 return result; 678 if (!acpi_battery_present(battery)) { 679 sysfs_remove_battery(battery); 680 battery->update_time = 0; 681 return 0; 682 } 683 if (!battery->update_time || 684 old_present != acpi_battery_present(battery)) { 685 result = acpi_battery_get_info(battery); 686 if (result) 687 return result; 688 acpi_battery_init_alarm(battery); 689 } 690 if (!battery->bat.dev) { 691 result = sysfs_add_battery(battery); 692 if (result) 693 return result; 694 } 695 result = acpi_battery_get_state(battery); 696 acpi_battery_quirks(battery); 697 return result; 698 } 699 700 static void acpi_battery_refresh(struct acpi_battery *battery) 701 { 702 int power_unit; 703 704 if (!battery->bat.dev) 705 return; 706 707 power_unit = battery->power_unit; 708 709 acpi_battery_get_info(battery); 710 711 if (power_unit == battery->power_unit) 712 return; 713 714 /* The battery has changed its reporting units. */ 715 sysfs_remove_battery(battery); 716 sysfs_add_battery(battery); 717 } 718 719 /* -------------------------------------------------------------------------- 720 Driver Interface 721 -------------------------------------------------------------------------- */ 722 723 static void acpi_battery_notify(struct acpi_device *device, u32 event) 724 { 725 struct acpi_battery *battery = acpi_driver_data(device); 726 struct device *old; 727 728 if (!battery) 729 return; 730 old = battery->bat.dev; 731 if (event == ACPI_BATTERY_NOTIFY_INFO) 732 acpi_battery_refresh(battery); 733 acpi_battery_update(battery); 734 acpi_bus_generate_netlink_event(device->pnp.device_class, 735 dev_name(&device->dev), event, 736 acpi_battery_present(battery)); 737 acpi_notifier_call_chain(device, event, acpi_battery_present(battery)); 738 /* acpi_battery_update could remove power_supply object */ 739 if (old && battery->bat.dev) 740 power_supply_changed(&battery->bat); 741 } 742 743 static int battery_notify(struct notifier_block *nb, 744 unsigned long mode, void *_unused) 745 { 746 struct acpi_battery *battery = container_of(nb, struct acpi_battery, 747 pm_nb); 748 switch (mode) { 749 case PM_POST_HIBERNATION: 750 case PM_POST_SUSPEND: 751 if (battery->bat.dev) { 752 sysfs_remove_battery(battery); 753 sysfs_add_battery(battery); 754 } 755 break; 756 } 757 758 return 0; 759 } 760 761 static struct dmi_system_id bat_dmi_table[] = { 762 { 763 .ident = "NEC LZ750/LS", 764 .matches = { 765 DMI_MATCH(DMI_SYS_VENDOR, "NEC"), 766 DMI_MATCH(DMI_PRODUCT_NAME, "PC-LZ750LS"), 767 }, 768 }, 769 {}, 770 }; 771 772 static int acpi_battery_add(struct acpi_device *device) 773 { 774 int result = 0; 775 struct acpi_battery *battery = NULL; 776 777 if (!device) 778 return -EINVAL; 779 battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL); 780 if (!battery) 781 return -ENOMEM; 782 battery->device = device; 783 strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME); 784 strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS); 785 device->driver_data = battery; 786 mutex_init(&battery->lock); 787 mutex_init(&battery->sysfs_lock); 788 if (acpi_has_method(battery->device->handle, "_BIX")) 789 set_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags); 790 result = acpi_battery_update(battery); 791 if (result) 792 goto fail; 793 794 printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n", 795 ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device), 796 device->status.battery_present ? "present" : "absent"); 797 798 battery->pm_nb.notifier_call = battery_notify; 799 register_pm_notifier(&battery->pm_nb); 800 801 return result; 802 803 fail: 804 sysfs_remove_battery(battery); 805 mutex_destroy(&battery->lock); 806 mutex_destroy(&battery->sysfs_lock); 807 kfree(battery); 808 return result; 809 } 810 811 static int acpi_battery_remove(struct acpi_device *device) 812 { 813 struct acpi_battery *battery = NULL; 814 815 if (!device || !acpi_driver_data(device)) 816 return -EINVAL; 817 battery = acpi_driver_data(device); 818 unregister_pm_notifier(&battery->pm_nb); 819 sysfs_remove_battery(battery); 820 mutex_destroy(&battery->lock); 821 mutex_destroy(&battery->sysfs_lock); 822 kfree(battery); 823 return 0; 824 } 825 826 #ifdef CONFIG_PM_SLEEP 827 /* this is needed to learn about changes made in suspended state */ 828 static int acpi_battery_resume(struct device *dev) 829 { 830 struct acpi_battery *battery; 831 832 if (!dev) 833 return -EINVAL; 834 835 battery = acpi_driver_data(to_acpi_device(dev)); 836 if (!battery) 837 return -EINVAL; 838 839 battery->update_time = 0; 840 acpi_battery_update(battery); 841 return 0; 842 } 843 #else 844 #define acpi_battery_resume NULL 845 #endif 846 847 static SIMPLE_DEV_PM_OPS(acpi_battery_pm, NULL, acpi_battery_resume); 848 849 static struct acpi_driver acpi_battery_driver = { 850 .name = "battery", 851 .class = ACPI_BATTERY_CLASS, 852 .ids = battery_device_ids, 853 .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS, 854 .ops = { 855 .add = acpi_battery_add, 856 .remove = acpi_battery_remove, 857 .notify = acpi_battery_notify, 858 }, 859 .drv.pm = &acpi_battery_pm, 860 }; 861 862 static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie) 863 { 864 if (acpi_disabled) 865 return; 866 867 if (dmi_check_system(bat_dmi_table)) 868 battery_bix_broken_package = 1; 869 acpi_bus_register_driver(&acpi_battery_driver); 870 } 871 872 static int __init acpi_battery_init(void) 873 { 874 async_schedule(acpi_battery_init_async, NULL); 875 return 0; 876 } 877 878 static void __exit acpi_battery_exit(void) 879 { 880 acpi_bus_unregister_driver(&acpi_battery_driver); 881 } 882 883 module_init(acpi_battery_init); 884 module_exit(acpi_battery_exit); 885