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