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 #ifdef CONFIG_ACPI_PROCFS_POWER 40 #include <linux/proc_fs.h> 41 #include <linux/seq_file.h> 42 #include <asm/uaccess.h> 43 #endif 44 45 #include <acpi/acpi_bus.h> 46 #include <acpi/acpi_drivers.h> 47 #include <linux/power_supply.h> 48 49 #define PREFIX "ACPI: " 50 51 #define ACPI_BATTERY_VALUE_UNKNOWN 0xFFFFFFFF 52 53 #define ACPI_BATTERY_CLASS "battery" 54 #define ACPI_BATTERY_DEVICE_NAME "Battery" 55 #define ACPI_BATTERY_NOTIFY_STATUS 0x80 56 #define ACPI_BATTERY_NOTIFY_INFO 0x81 57 #define ACPI_BATTERY_NOTIFY_THRESHOLD 0x82 58 59 /* Battery power unit: 0 means mW, 1 means mA */ 60 #define ACPI_BATTERY_POWER_UNIT_MA 1 61 62 #define _COMPONENT ACPI_BATTERY_COMPONENT 63 64 ACPI_MODULE_NAME("battery"); 65 66 MODULE_AUTHOR("Paul Diefenbaugh"); 67 MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>"); 68 MODULE_DESCRIPTION("ACPI Battery Driver"); 69 MODULE_LICENSE("GPL"); 70 71 static unsigned int cache_time = 1000; 72 module_param(cache_time, uint, 0644); 73 MODULE_PARM_DESC(cache_time, "cache time in milliseconds"); 74 75 #ifdef CONFIG_ACPI_PROCFS_POWER 76 extern struct proc_dir_entry *acpi_lock_battery_dir(void); 77 extern void *acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir); 78 79 enum acpi_battery_files { 80 info_tag = 0, 81 state_tag, 82 alarm_tag, 83 ACPI_BATTERY_NUMFILES, 84 }; 85 86 #endif 87 88 static const struct acpi_device_id battery_device_ids[] = { 89 {"PNP0C0A", 0}, 90 {"", 0}, 91 }; 92 93 MODULE_DEVICE_TABLE(acpi, battery_device_ids); 94 95 enum { 96 ACPI_BATTERY_ALARM_PRESENT, 97 ACPI_BATTERY_XINFO_PRESENT, 98 ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, 99 /* On Lenovo Thinkpad models from 2010 and 2011, the power unit 100 switches between mWh and mAh depending on whether the system 101 is running on battery or not. When mAh is the unit, most 102 reported values are incorrect and need to be adjusted by 103 10000/design_voltage. Verified on x201, t410, t410s, and x220. 104 Pre-2010 and 2012 models appear to always report in mWh and 105 are thus unaffected (tested with t42, t61, t500, x200, x300, 106 and x230). Also, in mid-2012 Lenovo issued a BIOS update for 107 the 2011 models that fixes the issue (tested on x220 with a 108 post-1.29 BIOS), but as of Nov. 2012, no such update is 109 available for the 2010 models. */ 110 ACPI_BATTERY_QUIRK_THINKPAD_MAH, 111 }; 112 113 struct acpi_battery { 114 struct mutex lock; 115 struct mutex sysfs_lock; 116 struct power_supply bat; 117 struct acpi_device *device; 118 struct notifier_block pm_nb; 119 unsigned long update_time; 120 int revision; 121 int rate_now; 122 int capacity_now; 123 int voltage_now; 124 int design_capacity; 125 int full_charge_capacity; 126 int technology; 127 int design_voltage; 128 int design_capacity_warning; 129 int design_capacity_low; 130 int cycle_count; 131 int measurement_accuracy; 132 int max_sampling_time; 133 int min_sampling_time; 134 int max_averaging_interval; 135 int min_averaging_interval; 136 int capacity_granularity_1; 137 int capacity_granularity_2; 138 int alarm; 139 char model_number[32]; 140 char serial_number[32]; 141 char type[32]; 142 char oem_info[32]; 143 int state; 144 int power_unit; 145 unsigned long flags; 146 }; 147 148 #define to_acpi_battery(x) container_of(x, struct acpi_battery, bat) 149 150 static inline int acpi_battery_present(struct acpi_battery *battery) 151 { 152 return battery->device->status.battery_present; 153 } 154 155 static int acpi_battery_technology(struct acpi_battery *battery) 156 { 157 if (!strcasecmp("NiCd", battery->type)) 158 return POWER_SUPPLY_TECHNOLOGY_NiCd; 159 if (!strcasecmp("NiMH", battery->type)) 160 return POWER_SUPPLY_TECHNOLOGY_NiMH; 161 if (!strcasecmp("LION", battery->type)) 162 return POWER_SUPPLY_TECHNOLOGY_LION; 163 if (!strncasecmp("LI-ION", battery->type, 6)) 164 return POWER_SUPPLY_TECHNOLOGY_LION; 165 if (!strcasecmp("LiP", battery->type)) 166 return POWER_SUPPLY_TECHNOLOGY_LIPO; 167 return POWER_SUPPLY_TECHNOLOGY_UNKNOWN; 168 } 169 170 static int acpi_battery_get_state(struct acpi_battery *battery); 171 172 static int acpi_battery_is_charged(struct acpi_battery *battery) 173 { 174 /* either charging or discharging */ 175 if (battery->state != 0) 176 return 0; 177 178 /* battery not reporting charge */ 179 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN || 180 battery->capacity_now == 0) 181 return 0; 182 183 /* good batteries update full_charge as the batteries degrade */ 184 if (battery->full_charge_capacity == battery->capacity_now) 185 return 1; 186 187 /* fallback to using design values for broken batteries */ 188 if (battery->design_capacity == battery->capacity_now) 189 return 1; 190 191 /* we don't do any sort of metric based on percentages */ 192 return 0; 193 } 194 195 static int acpi_battery_get_property(struct power_supply *psy, 196 enum power_supply_property psp, 197 union power_supply_propval *val) 198 { 199 int ret = 0; 200 struct acpi_battery *battery = to_acpi_battery(psy); 201 202 if (acpi_battery_present(battery)) { 203 /* run battery update only if it is present */ 204 acpi_battery_get_state(battery); 205 } else if (psp != POWER_SUPPLY_PROP_PRESENT) 206 return -ENODEV; 207 switch (psp) { 208 case POWER_SUPPLY_PROP_STATUS: 209 if (battery->state & 0x01) 210 val->intval = POWER_SUPPLY_STATUS_DISCHARGING; 211 else if (battery->state & 0x02) 212 val->intval = POWER_SUPPLY_STATUS_CHARGING; 213 else if (acpi_battery_is_charged(battery)) 214 val->intval = POWER_SUPPLY_STATUS_FULL; 215 else 216 val->intval = POWER_SUPPLY_STATUS_UNKNOWN; 217 break; 218 case POWER_SUPPLY_PROP_PRESENT: 219 val->intval = acpi_battery_present(battery); 220 break; 221 case POWER_SUPPLY_PROP_TECHNOLOGY: 222 val->intval = acpi_battery_technology(battery); 223 break; 224 case POWER_SUPPLY_PROP_CYCLE_COUNT: 225 val->intval = battery->cycle_count; 226 break; 227 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN: 228 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN) 229 ret = -ENODEV; 230 else 231 val->intval = battery->design_voltage * 1000; 232 break; 233 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 234 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN) 235 ret = -ENODEV; 236 else 237 val->intval = battery->voltage_now * 1000; 238 break; 239 case POWER_SUPPLY_PROP_CURRENT_NOW: 240 case POWER_SUPPLY_PROP_POWER_NOW: 241 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN) 242 ret = -ENODEV; 243 else 244 val->intval = battery->rate_now * 1000; 245 break; 246 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN: 247 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN: 248 if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN) 249 ret = -ENODEV; 250 else 251 val->intval = battery->design_capacity * 1000; 252 break; 253 case POWER_SUPPLY_PROP_CHARGE_FULL: 254 case POWER_SUPPLY_PROP_ENERGY_FULL: 255 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN) 256 ret = -ENODEV; 257 else 258 val->intval = battery->full_charge_capacity * 1000; 259 break; 260 case POWER_SUPPLY_PROP_CHARGE_NOW: 261 case POWER_SUPPLY_PROP_ENERGY_NOW: 262 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN) 263 ret = -ENODEV; 264 else 265 val->intval = battery->capacity_now * 1000; 266 break; 267 case POWER_SUPPLY_PROP_CAPACITY: 268 if (battery->capacity_now && battery->full_charge_capacity) 269 val->intval = battery->capacity_now * 100/ 270 battery->full_charge_capacity; 271 else 272 val->intval = 0; 273 break; 274 case POWER_SUPPLY_PROP_MODEL_NAME: 275 val->strval = battery->model_number; 276 break; 277 case POWER_SUPPLY_PROP_MANUFACTURER: 278 val->strval = battery->oem_info; 279 break; 280 case POWER_SUPPLY_PROP_SERIAL_NUMBER: 281 val->strval = battery->serial_number; 282 break; 283 default: 284 ret = -EINVAL; 285 } 286 return ret; 287 } 288 289 static enum power_supply_property charge_battery_props[] = { 290 POWER_SUPPLY_PROP_STATUS, 291 POWER_SUPPLY_PROP_PRESENT, 292 POWER_SUPPLY_PROP_TECHNOLOGY, 293 POWER_SUPPLY_PROP_CYCLE_COUNT, 294 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN, 295 POWER_SUPPLY_PROP_VOLTAGE_NOW, 296 POWER_SUPPLY_PROP_CURRENT_NOW, 297 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, 298 POWER_SUPPLY_PROP_CHARGE_FULL, 299 POWER_SUPPLY_PROP_CHARGE_NOW, 300 POWER_SUPPLY_PROP_CAPACITY, 301 POWER_SUPPLY_PROP_MODEL_NAME, 302 POWER_SUPPLY_PROP_MANUFACTURER, 303 POWER_SUPPLY_PROP_SERIAL_NUMBER, 304 }; 305 306 static enum power_supply_property energy_battery_props[] = { 307 POWER_SUPPLY_PROP_STATUS, 308 POWER_SUPPLY_PROP_PRESENT, 309 POWER_SUPPLY_PROP_TECHNOLOGY, 310 POWER_SUPPLY_PROP_CYCLE_COUNT, 311 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN, 312 POWER_SUPPLY_PROP_VOLTAGE_NOW, 313 POWER_SUPPLY_PROP_POWER_NOW, 314 POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN, 315 POWER_SUPPLY_PROP_ENERGY_FULL, 316 POWER_SUPPLY_PROP_ENERGY_NOW, 317 POWER_SUPPLY_PROP_CAPACITY, 318 POWER_SUPPLY_PROP_MODEL_NAME, 319 POWER_SUPPLY_PROP_MANUFACTURER, 320 POWER_SUPPLY_PROP_SERIAL_NUMBER, 321 }; 322 323 #ifdef CONFIG_ACPI_PROCFS_POWER 324 inline char *acpi_battery_units(struct acpi_battery *battery) 325 { 326 return (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) ? 327 "mA" : "mW"; 328 } 329 #endif 330 331 /* -------------------------------------------------------------------------- 332 Battery Management 333 -------------------------------------------------------------------------- */ 334 struct acpi_offsets { 335 size_t offset; /* offset inside struct acpi_sbs_battery */ 336 u8 mode; /* int or string? */ 337 }; 338 339 static struct acpi_offsets state_offsets[] = { 340 {offsetof(struct acpi_battery, state), 0}, 341 {offsetof(struct acpi_battery, rate_now), 0}, 342 {offsetof(struct acpi_battery, capacity_now), 0}, 343 {offsetof(struct acpi_battery, voltage_now), 0}, 344 }; 345 346 static struct acpi_offsets info_offsets[] = { 347 {offsetof(struct acpi_battery, power_unit), 0}, 348 {offsetof(struct acpi_battery, design_capacity), 0}, 349 {offsetof(struct acpi_battery, full_charge_capacity), 0}, 350 {offsetof(struct acpi_battery, technology), 0}, 351 {offsetof(struct acpi_battery, design_voltage), 0}, 352 {offsetof(struct acpi_battery, design_capacity_warning), 0}, 353 {offsetof(struct acpi_battery, design_capacity_low), 0}, 354 {offsetof(struct acpi_battery, capacity_granularity_1), 0}, 355 {offsetof(struct acpi_battery, capacity_granularity_2), 0}, 356 {offsetof(struct acpi_battery, model_number), 1}, 357 {offsetof(struct acpi_battery, serial_number), 1}, 358 {offsetof(struct acpi_battery, type), 1}, 359 {offsetof(struct acpi_battery, oem_info), 1}, 360 }; 361 362 static struct acpi_offsets extended_info_offsets[] = { 363 {offsetof(struct acpi_battery, revision), 0}, 364 {offsetof(struct acpi_battery, power_unit), 0}, 365 {offsetof(struct acpi_battery, design_capacity), 0}, 366 {offsetof(struct acpi_battery, full_charge_capacity), 0}, 367 {offsetof(struct acpi_battery, technology), 0}, 368 {offsetof(struct acpi_battery, design_voltage), 0}, 369 {offsetof(struct acpi_battery, design_capacity_warning), 0}, 370 {offsetof(struct acpi_battery, design_capacity_low), 0}, 371 {offsetof(struct acpi_battery, cycle_count), 0}, 372 {offsetof(struct acpi_battery, measurement_accuracy), 0}, 373 {offsetof(struct acpi_battery, max_sampling_time), 0}, 374 {offsetof(struct acpi_battery, min_sampling_time), 0}, 375 {offsetof(struct acpi_battery, max_averaging_interval), 0}, 376 {offsetof(struct acpi_battery, min_averaging_interval), 0}, 377 {offsetof(struct acpi_battery, capacity_granularity_1), 0}, 378 {offsetof(struct acpi_battery, capacity_granularity_2), 0}, 379 {offsetof(struct acpi_battery, model_number), 1}, 380 {offsetof(struct acpi_battery, serial_number), 1}, 381 {offsetof(struct acpi_battery, type), 1}, 382 {offsetof(struct acpi_battery, oem_info), 1}, 383 }; 384 385 static int extract_package(struct acpi_battery *battery, 386 union acpi_object *package, 387 struct acpi_offsets *offsets, int num) 388 { 389 int i; 390 union acpi_object *element; 391 if (package->type != ACPI_TYPE_PACKAGE) 392 return -EFAULT; 393 for (i = 0; i < num; ++i) { 394 if (package->package.count <= i) 395 return -EFAULT; 396 element = &package->package.elements[i]; 397 if (offsets[i].mode) { 398 u8 *ptr = (u8 *)battery + offsets[i].offset; 399 if (element->type == ACPI_TYPE_STRING || 400 element->type == ACPI_TYPE_BUFFER) 401 strncpy(ptr, element->string.pointer, 32); 402 else if (element->type == ACPI_TYPE_INTEGER) { 403 strncpy(ptr, (u8 *)&element->integer.value, 404 sizeof(u64)); 405 ptr[sizeof(u64)] = 0; 406 } else 407 *ptr = 0; /* don't have value */ 408 } else { 409 int *x = (int *)((u8 *)battery + offsets[i].offset); 410 *x = (element->type == ACPI_TYPE_INTEGER) ? 411 element->integer.value : -1; 412 } 413 } 414 return 0; 415 } 416 417 static int acpi_battery_get_status(struct acpi_battery *battery) 418 { 419 if (acpi_bus_get_status(battery->device)) { 420 ACPI_EXCEPTION((AE_INFO, AE_ERROR, "Evaluating _STA")); 421 return -ENODEV; 422 } 423 return 0; 424 } 425 426 static int acpi_battery_get_info(struct acpi_battery *battery) 427 { 428 int result = -EFAULT; 429 acpi_status status = 0; 430 char *name = test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags) ? 431 "_BIX" : "_BIF"; 432 433 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 434 435 if (!acpi_battery_present(battery)) 436 return 0; 437 mutex_lock(&battery->lock); 438 status = acpi_evaluate_object(battery->device->handle, name, 439 NULL, &buffer); 440 mutex_unlock(&battery->lock); 441 442 if (ACPI_FAILURE(status)) { 443 ACPI_EXCEPTION((AE_INFO, status, "Evaluating %s", name)); 444 return -ENODEV; 445 } 446 if (test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags)) 447 result = extract_package(battery, buffer.pointer, 448 extended_info_offsets, 449 ARRAY_SIZE(extended_info_offsets)); 450 else 451 result = extract_package(battery, buffer.pointer, 452 info_offsets, ARRAY_SIZE(info_offsets)); 453 kfree(buffer.pointer); 454 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags)) 455 battery->full_charge_capacity = battery->design_capacity; 456 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) && 457 battery->power_unit && battery->design_voltage) { 458 battery->design_capacity = battery->design_capacity * 459 10000 / battery->design_voltage; 460 battery->full_charge_capacity = battery->full_charge_capacity * 461 10000 / battery->design_voltage; 462 battery->design_capacity_warning = 463 battery->design_capacity_warning * 464 10000 / battery->design_voltage; 465 /* Curiously, design_capacity_low, unlike the rest of them, 466 is correct. */ 467 /* capacity_granularity_* equal 1 on the systems tested, so 468 it's impossible to tell if they would need an adjustment 469 or not if their values were higher. */ 470 } 471 return result; 472 } 473 474 static int acpi_battery_get_state(struct acpi_battery *battery) 475 { 476 int result = 0; 477 acpi_status status = 0; 478 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 479 480 if (!acpi_battery_present(battery)) 481 return 0; 482 483 if (battery->update_time && 484 time_before(jiffies, battery->update_time + 485 msecs_to_jiffies(cache_time))) 486 return 0; 487 488 mutex_lock(&battery->lock); 489 status = acpi_evaluate_object(battery->device->handle, "_BST", 490 NULL, &buffer); 491 mutex_unlock(&battery->lock); 492 493 if (ACPI_FAILURE(status)) { 494 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST")); 495 return -ENODEV; 496 } 497 498 result = extract_package(battery, buffer.pointer, 499 state_offsets, ARRAY_SIZE(state_offsets)); 500 battery->update_time = jiffies; 501 kfree(buffer.pointer); 502 503 /* For buggy DSDTs that report negative 16-bit values for either 504 * charging or discharging current and/or report 0 as 65536 505 * due to bad math. 506 */ 507 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA && 508 battery->rate_now != ACPI_BATTERY_VALUE_UNKNOWN && 509 (s16)(battery->rate_now) < 0) { 510 battery->rate_now = abs((s16)battery->rate_now); 511 printk_once(KERN_WARNING FW_BUG "battery: (dis)charge rate" 512 " invalid.\n"); 513 } 514 515 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags) 516 && battery->capacity_now >= 0 && battery->capacity_now <= 100) 517 battery->capacity_now = (battery->capacity_now * 518 battery->full_charge_capacity) / 100; 519 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) && 520 battery->power_unit && battery->design_voltage) { 521 battery->capacity_now = battery->capacity_now * 522 10000 / battery->design_voltage; 523 } 524 return result; 525 } 526 527 static int acpi_battery_set_alarm(struct acpi_battery *battery) 528 { 529 acpi_status status = 0; 530 531 if (!acpi_battery_present(battery) || 532 !test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags)) 533 return -ENODEV; 534 535 mutex_lock(&battery->lock); 536 status = acpi_execute_simple_method(battery->device->handle, "_BTP", 537 battery->alarm); 538 mutex_unlock(&battery->lock); 539 540 if (ACPI_FAILURE(status)) 541 return -ENODEV; 542 543 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", battery->alarm)); 544 return 0; 545 } 546 547 static int acpi_battery_init_alarm(struct acpi_battery *battery) 548 { 549 /* See if alarms are supported, and if so, set default */ 550 if (!acpi_has_method(battery->device->handle, "_BTP")) { 551 clear_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags); 552 return 0; 553 } 554 set_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags); 555 if (!battery->alarm) 556 battery->alarm = battery->design_capacity_warning; 557 return acpi_battery_set_alarm(battery); 558 } 559 560 static ssize_t acpi_battery_alarm_show(struct device *dev, 561 struct device_attribute *attr, 562 char *buf) 563 { 564 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev)); 565 return sprintf(buf, "%d\n", battery->alarm * 1000); 566 } 567 568 static ssize_t acpi_battery_alarm_store(struct device *dev, 569 struct device_attribute *attr, 570 const char *buf, size_t count) 571 { 572 unsigned long x; 573 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev)); 574 if (sscanf(buf, "%ld\n", &x) == 1) 575 battery->alarm = x/1000; 576 if (acpi_battery_present(battery)) 577 acpi_battery_set_alarm(battery); 578 return count; 579 } 580 581 static struct device_attribute alarm_attr = { 582 .attr = {.name = "alarm", .mode = 0644}, 583 .show = acpi_battery_alarm_show, 584 .store = acpi_battery_alarm_store, 585 }; 586 587 static int sysfs_add_battery(struct acpi_battery *battery) 588 { 589 int result; 590 591 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) { 592 battery->bat.properties = charge_battery_props; 593 battery->bat.num_properties = 594 ARRAY_SIZE(charge_battery_props); 595 } else { 596 battery->bat.properties = energy_battery_props; 597 battery->bat.num_properties = 598 ARRAY_SIZE(energy_battery_props); 599 } 600 601 battery->bat.name = acpi_device_bid(battery->device); 602 battery->bat.type = POWER_SUPPLY_TYPE_BATTERY; 603 battery->bat.get_property = acpi_battery_get_property; 604 605 result = power_supply_register(&battery->device->dev, &battery->bat); 606 if (result) 607 return result; 608 return device_create_file(battery->bat.dev, &alarm_attr); 609 } 610 611 static void sysfs_remove_battery(struct acpi_battery *battery) 612 { 613 mutex_lock(&battery->sysfs_lock); 614 if (!battery->bat.dev) { 615 mutex_unlock(&battery->sysfs_lock); 616 return; 617 } 618 619 device_remove_file(battery->bat.dev, &alarm_attr); 620 power_supply_unregister(&battery->bat); 621 battery->bat.dev = NULL; 622 mutex_unlock(&battery->sysfs_lock); 623 } 624 625 static void find_battery(const struct dmi_header *dm, void *private) 626 { 627 struct acpi_battery *battery = (struct acpi_battery *)private; 628 /* Note: the hardcoded offsets below have been extracted from 629 the source code of dmidecode. */ 630 if (dm->type == DMI_ENTRY_PORTABLE_BATTERY && dm->length >= 8) { 631 const u8 *dmi_data = (const u8 *)(dm + 1); 632 int dmi_capacity = get_unaligned((const u16 *)(dmi_data + 6)); 633 if (dm->length >= 18) 634 dmi_capacity *= dmi_data[17]; 635 if (battery->design_capacity * battery->design_voltage / 1000 636 != dmi_capacity && 637 battery->design_capacity * 10 == dmi_capacity) 638 set_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, 639 &battery->flags); 640 } 641 } 642 643 /* 644 * According to the ACPI spec, some kinds of primary batteries can 645 * report percentage battery remaining capacity directly to OS. 646 * In this case, it reports the Last Full Charged Capacity == 100 647 * and BatteryPresentRate == 0xFFFFFFFF. 648 * 649 * Now we found some battery reports percentage remaining capacity 650 * even if it's rechargeable. 651 * https://bugzilla.kernel.org/show_bug.cgi?id=15979 652 * 653 * Handle this correctly so that they won't break userspace. 654 */ 655 static void acpi_battery_quirks(struct acpi_battery *battery) 656 { 657 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags)) 658 return; 659 660 if (battery->full_charge_capacity == 100 && 661 battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN && 662 battery->capacity_now >= 0 && battery->capacity_now <= 100) { 663 set_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags); 664 battery->full_charge_capacity = battery->design_capacity; 665 battery->capacity_now = (battery->capacity_now * 666 battery->full_charge_capacity) / 100; 667 } 668 669 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags)) 670 return; 671 672 if (battery->power_unit && dmi_name_in_vendors("LENOVO")) { 673 const char *s; 674 s = dmi_get_system_info(DMI_PRODUCT_VERSION); 675 if (s && !strnicmp(s, "ThinkPad", 8)) { 676 dmi_walk(find_battery, battery); 677 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, 678 &battery->flags) && 679 battery->design_voltage) { 680 battery->design_capacity = 681 battery->design_capacity * 682 10000 / battery->design_voltage; 683 battery->full_charge_capacity = 684 battery->full_charge_capacity * 685 10000 / battery->design_voltage; 686 battery->design_capacity_warning = 687 battery->design_capacity_warning * 688 10000 / battery->design_voltage; 689 battery->capacity_now = battery->capacity_now * 690 10000 / battery->design_voltage; 691 } 692 } 693 } 694 } 695 696 static int acpi_battery_update(struct acpi_battery *battery) 697 { 698 int result, old_present = acpi_battery_present(battery); 699 result = acpi_battery_get_status(battery); 700 if (result) 701 return result; 702 if (!acpi_battery_present(battery)) { 703 sysfs_remove_battery(battery); 704 battery->update_time = 0; 705 return 0; 706 } 707 if (!battery->update_time || 708 old_present != acpi_battery_present(battery)) { 709 result = acpi_battery_get_info(battery); 710 if (result) 711 return result; 712 acpi_battery_init_alarm(battery); 713 } 714 if (!battery->bat.dev) { 715 result = sysfs_add_battery(battery); 716 if (result) 717 return result; 718 } 719 result = acpi_battery_get_state(battery); 720 acpi_battery_quirks(battery); 721 return result; 722 } 723 724 static void acpi_battery_refresh(struct acpi_battery *battery) 725 { 726 int power_unit; 727 728 if (!battery->bat.dev) 729 return; 730 731 power_unit = battery->power_unit; 732 733 acpi_battery_get_info(battery); 734 735 if (power_unit == battery->power_unit) 736 return; 737 738 /* The battery has changed its reporting units. */ 739 sysfs_remove_battery(battery); 740 sysfs_add_battery(battery); 741 } 742 743 /* -------------------------------------------------------------------------- 744 FS Interface (/proc) 745 -------------------------------------------------------------------------- */ 746 747 #ifdef CONFIG_ACPI_PROCFS_POWER 748 static struct proc_dir_entry *acpi_battery_dir; 749 750 static int acpi_battery_print_info(struct seq_file *seq, int result) 751 { 752 struct acpi_battery *battery = seq->private; 753 754 if (result) 755 goto end; 756 757 seq_printf(seq, "present: %s\n", 758 acpi_battery_present(battery) ? "yes" : "no"); 759 if (!acpi_battery_present(battery)) 760 goto end; 761 if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN) 762 seq_printf(seq, "design capacity: unknown\n"); 763 else 764 seq_printf(seq, "design capacity: %d %sh\n", 765 battery->design_capacity, 766 acpi_battery_units(battery)); 767 768 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN) 769 seq_printf(seq, "last full capacity: unknown\n"); 770 else 771 seq_printf(seq, "last full capacity: %d %sh\n", 772 battery->full_charge_capacity, 773 acpi_battery_units(battery)); 774 775 seq_printf(seq, "battery technology: %srechargeable\n", 776 (!battery->technology)?"non-":""); 777 778 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN) 779 seq_printf(seq, "design voltage: unknown\n"); 780 else 781 seq_printf(seq, "design voltage: %d mV\n", 782 battery->design_voltage); 783 seq_printf(seq, "design capacity warning: %d %sh\n", 784 battery->design_capacity_warning, 785 acpi_battery_units(battery)); 786 seq_printf(seq, "design capacity low: %d %sh\n", 787 battery->design_capacity_low, 788 acpi_battery_units(battery)); 789 seq_printf(seq, "cycle count: %i\n", battery->cycle_count); 790 seq_printf(seq, "capacity granularity 1: %d %sh\n", 791 battery->capacity_granularity_1, 792 acpi_battery_units(battery)); 793 seq_printf(seq, "capacity granularity 2: %d %sh\n", 794 battery->capacity_granularity_2, 795 acpi_battery_units(battery)); 796 seq_printf(seq, "model number: %s\n", battery->model_number); 797 seq_printf(seq, "serial number: %s\n", battery->serial_number); 798 seq_printf(seq, "battery type: %s\n", battery->type); 799 seq_printf(seq, "OEM info: %s\n", battery->oem_info); 800 end: 801 if (result) 802 seq_printf(seq, "ERROR: Unable to read battery info\n"); 803 return result; 804 } 805 806 static int acpi_battery_print_state(struct seq_file *seq, int result) 807 { 808 struct acpi_battery *battery = seq->private; 809 810 if (result) 811 goto end; 812 813 seq_printf(seq, "present: %s\n", 814 acpi_battery_present(battery) ? "yes" : "no"); 815 if (!acpi_battery_present(battery)) 816 goto end; 817 818 seq_printf(seq, "capacity state: %s\n", 819 (battery->state & 0x04) ? "critical" : "ok"); 820 if ((battery->state & 0x01) && (battery->state & 0x02)) 821 seq_printf(seq, 822 "charging state: charging/discharging\n"); 823 else if (battery->state & 0x01) 824 seq_printf(seq, "charging state: discharging\n"); 825 else if (battery->state & 0x02) 826 seq_printf(seq, "charging state: charging\n"); 827 else 828 seq_printf(seq, "charging state: charged\n"); 829 830 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN) 831 seq_printf(seq, "present rate: unknown\n"); 832 else 833 seq_printf(seq, "present rate: %d %s\n", 834 battery->rate_now, acpi_battery_units(battery)); 835 836 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN) 837 seq_printf(seq, "remaining capacity: unknown\n"); 838 else 839 seq_printf(seq, "remaining capacity: %d %sh\n", 840 battery->capacity_now, acpi_battery_units(battery)); 841 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN) 842 seq_printf(seq, "present voltage: unknown\n"); 843 else 844 seq_printf(seq, "present voltage: %d mV\n", 845 battery->voltage_now); 846 end: 847 if (result) 848 seq_printf(seq, "ERROR: Unable to read battery state\n"); 849 850 return result; 851 } 852 853 static int acpi_battery_print_alarm(struct seq_file *seq, int result) 854 { 855 struct acpi_battery *battery = seq->private; 856 857 if (result) 858 goto end; 859 860 if (!acpi_battery_present(battery)) { 861 seq_printf(seq, "present: no\n"); 862 goto end; 863 } 864 seq_printf(seq, "alarm: "); 865 if (!battery->alarm) 866 seq_printf(seq, "unsupported\n"); 867 else 868 seq_printf(seq, "%u %sh\n", battery->alarm, 869 acpi_battery_units(battery)); 870 end: 871 if (result) 872 seq_printf(seq, "ERROR: Unable to read battery alarm\n"); 873 return result; 874 } 875 876 static ssize_t acpi_battery_write_alarm(struct file *file, 877 const char __user * buffer, 878 size_t count, loff_t * ppos) 879 { 880 int result = 0; 881 char alarm_string[12] = { '\0' }; 882 struct seq_file *m = file->private_data; 883 struct acpi_battery *battery = m->private; 884 885 if (!battery || (count > sizeof(alarm_string) - 1)) 886 return -EINVAL; 887 if (!acpi_battery_present(battery)) { 888 result = -ENODEV; 889 goto end; 890 } 891 if (copy_from_user(alarm_string, buffer, count)) { 892 result = -EFAULT; 893 goto end; 894 } 895 alarm_string[count] = '\0'; 896 battery->alarm = simple_strtol(alarm_string, NULL, 0); 897 result = acpi_battery_set_alarm(battery); 898 end: 899 if (!result) 900 return count; 901 return result; 902 } 903 904 typedef int(*print_func)(struct seq_file *seq, int result); 905 906 static print_func acpi_print_funcs[ACPI_BATTERY_NUMFILES] = { 907 acpi_battery_print_info, 908 acpi_battery_print_state, 909 acpi_battery_print_alarm, 910 }; 911 912 static int acpi_battery_read(int fid, struct seq_file *seq) 913 { 914 struct acpi_battery *battery = seq->private; 915 int result = acpi_battery_update(battery); 916 return acpi_print_funcs[fid](seq, result); 917 } 918 919 #define DECLARE_FILE_FUNCTIONS(_name) \ 920 static int acpi_battery_read_##_name(struct seq_file *seq, void *offset) \ 921 { \ 922 return acpi_battery_read(_name##_tag, seq); \ 923 } \ 924 static int acpi_battery_##_name##_open_fs(struct inode *inode, struct file *file) \ 925 { \ 926 return single_open(file, acpi_battery_read_##_name, PDE_DATA(inode)); \ 927 } 928 929 DECLARE_FILE_FUNCTIONS(info); 930 DECLARE_FILE_FUNCTIONS(state); 931 DECLARE_FILE_FUNCTIONS(alarm); 932 933 #undef DECLARE_FILE_FUNCTIONS 934 935 #define FILE_DESCRIPTION_RO(_name) \ 936 { \ 937 .name = __stringify(_name), \ 938 .mode = S_IRUGO, \ 939 .ops = { \ 940 .open = acpi_battery_##_name##_open_fs, \ 941 .read = seq_read, \ 942 .llseek = seq_lseek, \ 943 .release = single_release, \ 944 .owner = THIS_MODULE, \ 945 }, \ 946 } 947 948 #define FILE_DESCRIPTION_RW(_name) \ 949 { \ 950 .name = __stringify(_name), \ 951 .mode = S_IFREG | S_IRUGO | S_IWUSR, \ 952 .ops = { \ 953 .open = acpi_battery_##_name##_open_fs, \ 954 .read = seq_read, \ 955 .llseek = seq_lseek, \ 956 .write = acpi_battery_write_##_name, \ 957 .release = single_release, \ 958 .owner = THIS_MODULE, \ 959 }, \ 960 } 961 962 static const struct battery_file { 963 struct file_operations ops; 964 umode_t mode; 965 const char *name; 966 } acpi_battery_file[] = { 967 FILE_DESCRIPTION_RO(info), 968 FILE_DESCRIPTION_RO(state), 969 FILE_DESCRIPTION_RW(alarm), 970 }; 971 972 #undef FILE_DESCRIPTION_RO 973 #undef FILE_DESCRIPTION_RW 974 975 static int acpi_battery_add_fs(struct acpi_device *device) 976 { 977 struct proc_dir_entry *entry = NULL; 978 int i; 979 980 printk(KERN_WARNING PREFIX "Deprecated procfs I/F for battery is loaded," 981 " please retry with CONFIG_ACPI_PROCFS_POWER cleared\n"); 982 if (!acpi_device_dir(device)) { 983 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device), 984 acpi_battery_dir); 985 if (!acpi_device_dir(device)) 986 return -ENODEV; 987 } 988 989 for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i) { 990 entry = proc_create_data(acpi_battery_file[i].name, 991 acpi_battery_file[i].mode, 992 acpi_device_dir(device), 993 &acpi_battery_file[i].ops, 994 acpi_driver_data(device)); 995 if (!entry) 996 return -ENODEV; 997 } 998 return 0; 999 } 1000 1001 static void acpi_battery_remove_fs(struct acpi_device *device) 1002 { 1003 int i; 1004 if (!acpi_device_dir(device)) 1005 return; 1006 for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i) 1007 remove_proc_entry(acpi_battery_file[i].name, 1008 acpi_device_dir(device)); 1009 1010 remove_proc_entry(acpi_device_bid(device), acpi_battery_dir); 1011 acpi_device_dir(device) = NULL; 1012 } 1013 1014 #endif 1015 1016 /* -------------------------------------------------------------------------- 1017 Driver Interface 1018 -------------------------------------------------------------------------- */ 1019 1020 static void acpi_battery_notify(struct acpi_device *device, u32 event) 1021 { 1022 struct acpi_battery *battery = acpi_driver_data(device); 1023 struct device *old; 1024 1025 if (!battery) 1026 return; 1027 old = battery->bat.dev; 1028 if (event == ACPI_BATTERY_NOTIFY_INFO) 1029 acpi_battery_refresh(battery); 1030 acpi_battery_update(battery); 1031 acpi_bus_generate_netlink_event(device->pnp.device_class, 1032 dev_name(&device->dev), event, 1033 acpi_battery_present(battery)); 1034 /* acpi_battery_update could remove power_supply object */ 1035 if (old && battery->bat.dev) 1036 power_supply_changed(&battery->bat); 1037 } 1038 1039 static int battery_notify(struct notifier_block *nb, 1040 unsigned long mode, void *_unused) 1041 { 1042 struct acpi_battery *battery = container_of(nb, struct acpi_battery, 1043 pm_nb); 1044 switch (mode) { 1045 case PM_POST_HIBERNATION: 1046 case PM_POST_SUSPEND: 1047 if (battery->bat.dev) { 1048 sysfs_remove_battery(battery); 1049 sysfs_add_battery(battery); 1050 } 1051 break; 1052 } 1053 1054 return 0; 1055 } 1056 1057 static int acpi_battery_add(struct acpi_device *device) 1058 { 1059 int result = 0; 1060 struct acpi_battery *battery = NULL; 1061 1062 if (!device) 1063 return -EINVAL; 1064 battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL); 1065 if (!battery) 1066 return -ENOMEM; 1067 battery->device = device; 1068 strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME); 1069 strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS); 1070 device->driver_data = battery; 1071 mutex_init(&battery->lock); 1072 mutex_init(&battery->sysfs_lock); 1073 if (acpi_has_method(battery->device->handle, "_BIX")) 1074 set_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags); 1075 result = acpi_battery_update(battery); 1076 if (result) 1077 goto fail; 1078 #ifdef CONFIG_ACPI_PROCFS_POWER 1079 result = acpi_battery_add_fs(device); 1080 #endif 1081 if (result) { 1082 #ifdef CONFIG_ACPI_PROCFS_POWER 1083 acpi_battery_remove_fs(device); 1084 #endif 1085 goto fail; 1086 } 1087 1088 printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n", 1089 ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device), 1090 device->status.battery_present ? "present" : "absent"); 1091 1092 battery->pm_nb.notifier_call = battery_notify; 1093 register_pm_notifier(&battery->pm_nb); 1094 1095 return result; 1096 1097 fail: 1098 sysfs_remove_battery(battery); 1099 mutex_destroy(&battery->lock); 1100 mutex_destroy(&battery->sysfs_lock); 1101 kfree(battery); 1102 return result; 1103 } 1104 1105 static int acpi_battery_remove(struct acpi_device *device) 1106 { 1107 struct acpi_battery *battery = NULL; 1108 1109 if (!device || !acpi_driver_data(device)) 1110 return -EINVAL; 1111 battery = acpi_driver_data(device); 1112 unregister_pm_notifier(&battery->pm_nb); 1113 #ifdef CONFIG_ACPI_PROCFS_POWER 1114 acpi_battery_remove_fs(device); 1115 #endif 1116 sysfs_remove_battery(battery); 1117 mutex_destroy(&battery->lock); 1118 mutex_destroy(&battery->sysfs_lock); 1119 kfree(battery); 1120 return 0; 1121 } 1122 1123 #ifdef CONFIG_PM_SLEEP 1124 /* this is needed to learn about changes made in suspended state */ 1125 static int acpi_battery_resume(struct device *dev) 1126 { 1127 struct acpi_battery *battery; 1128 1129 if (!dev) 1130 return -EINVAL; 1131 1132 battery = acpi_driver_data(to_acpi_device(dev)); 1133 if (!battery) 1134 return -EINVAL; 1135 1136 battery->update_time = 0; 1137 acpi_battery_update(battery); 1138 return 0; 1139 } 1140 #endif 1141 1142 static SIMPLE_DEV_PM_OPS(acpi_battery_pm, NULL, acpi_battery_resume); 1143 1144 static struct acpi_driver acpi_battery_driver = { 1145 .name = "battery", 1146 .class = ACPI_BATTERY_CLASS, 1147 .ids = battery_device_ids, 1148 .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS, 1149 .ops = { 1150 .add = acpi_battery_add, 1151 .remove = acpi_battery_remove, 1152 .notify = acpi_battery_notify, 1153 }, 1154 .drv.pm = &acpi_battery_pm, 1155 }; 1156 1157 static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie) 1158 { 1159 if (acpi_disabled) 1160 return; 1161 #ifdef CONFIG_ACPI_PROCFS_POWER 1162 acpi_battery_dir = acpi_lock_battery_dir(); 1163 if (!acpi_battery_dir) 1164 return; 1165 #endif 1166 if (acpi_bus_register_driver(&acpi_battery_driver) < 0) { 1167 #ifdef CONFIG_ACPI_PROCFS_POWER 1168 acpi_unlock_battery_dir(acpi_battery_dir); 1169 #endif 1170 return; 1171 } 1172 return; 1173 } 1174 1175 static int __init acpi_battery_init(void) 1176 { 1177 async_schedule(acpi_battery_init_async, NULL); 1178 return 0; 1179 } 1180 1181 static void __exit acpi_battery_exit(void) 1182 { 1183 acpi_bus_unregister_driver(&acpi_battery_driver); 1184 #ifdef CONFIG_ACPI_PROCFS_POWER 1185 acpi_unlock_battery_dir(acpi_battery_dir); 1186 #endif 1187 } 1188 1189 module_init(acpi_battery_init); 1190 module_exit(acpi_battery_exit); 1191