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 37 #ifdef CONFIG_ACPI_PROCFS_POWER 38 #include <linux/proc_fs.h> 39 #include <linux/seq_file.h> 40 #include <asm/uaccess.h> 41 #endif 42 43 #include <acpi/acpi_bus.h> 44 #include <acpi/acpi_drivers.h> 45 46 #ifdef CONFIG_ACPI_SYSFS_POWER 47 #include <linux/power_supply.h> 48 #endif 49 50 #define PREFIX "ACPI: " 51 52 #define ACPI_BATTERY_VALUE_UNKNOWN 0xFFFFFFFF 53 54 #define ACPI_BATTERY_CLASS "battery" 55 #define ACPI_BATTERY_DEVICE_NAME "Battery" 56 #define ACPI_BATTERY_NOTIFY_STATUS 0x80 57 #define ACPI_BATTERY_NOTIFY_INFO 0x81 58 #define ACPI_BATTERY_NOTIFY_THRESHOLD 0x82 59 60 #define _COMPONENT ACPI_BATTERY_COMPONENT 61 62 ACPI_MODULE_NAME("battery"); 63 64 MODULE_AUTHOR("Paul Diefenbaugh"); 65 MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>"); 66 MODULE_DESCRIPTION("ACPI Battery Driver"); 67 MODULE_LICENSE("GPL"); 68 69 static unsigned int cache_time = 1000; 70 module_param(cache_time, uint, 0644); 71 MODULE_PARM_DESC(cache_time, "cache time in milliseconds"); 72 73 #ifdef CONFIG_ACPI_PROCFS_POWER 74 extern struct proc_dir_entry *acpi_lock_battery_dir(void); 75 extern void *acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir); 76 77 enum acpi_battery_files { 78 info_tag = 0, 79 state_tag, 80 alarm_tag, 81 ACPI_BATTERY_NUMFILES, 82 }; 83 84 #endif 85 86 static const struct acpi_device_id battery_device_ids[] = { 87 {"PNP0C0A", 0}, 88 {"", 0}, 89 }; 90 91 MODULE_DEVICE_TABLE(acpi, battery_device_ids); 92 93 enum { 94 ACPI_BATTERY_ALARM_PRESENT, 95 ACPI_BATTERY_XINFO_PRESENT, 96 /* For buggy DSDTs that report negative 16-bit values for either 97 * charging or discharging current and/or report 0 as 65536 98 * due to bad math. 99 */ 100 ACPI_BATTERY_QUIRK_SIGNED16_CURRENT, 101 }; 102 103 struct acpi_battery { 104 struct mutex lock; 105 #ifdef CONFIG_ACPI_SYSFS_POWER 106 struct power_supply bat; 107 #endif 108 struct acpi_device *device; 109 unsigned long update_time; 110 int rate_now; 111 int capacity_now; 112 int voltage_now; 113 int design_capacity; 114 int full_charge_capacity; 115 int technology; 116 int design_voltage; 117 int design_capacity_warning; 118 int design_capacity_low; 119 int cycle_count; 120 int measurement_accuracy; 121 int max_sampling_time; 122 int min_sampling_time; 123 int max_averaging_interval; 124 int min_averaging_interval; 125 int capacity_granularity_1; 126 int capacity_granularity_2; 127 int alarm; 128 char model_number[32]; 129 char serial_number[32]; 130 char type[32]; 131 char oem_info[32]; 132 int state; 133 int power_unit; 134 unsigned long flags; 135 }; 136 137 #define to_acpi_battery(x) container_of(x, struct acpi_battery, bat); 138 139 inline int acpi_battery_present(struct acpi_battery *battery) 140 { 141 return battery->device->status.battery_present; 142 } 143 144 #ifdef CONFIG_ACPI_SYSFS_POWER 145 static int acpi_battery_technology(struct acpi_battery *battery) 146 { 147 if (!strcasecmp("NiCd", battery->type)) 148 return POWER_SUPPLY_TECHNOLOGY_NiCd; 149 if (!strcasecmp("NiMH", battery->type)) 150 return POWER_SUPPLY_TECHNOLOGY_NiMH; 151 if (!strcasecmp("LION", battery->type)) 152 return POWER_SUPPLY_TECHNOLOGY_LION; 153 if (!strncasecmp("LI-ION", battery->type, 6)) 154 return POWER_SUPPLY_TECHNOLOGY_LION; 155 if (!strcasecmp("LiP", battery->type)) 156 return POWER_SUPPLY_TECHNOLOGY_LIPO; 157 return POWER_SUPPLY_TECHNOLOGY_UNKNOWN; 158 } 159 160 static int acpi_battery_get_state(struct acpi_battery *battery); 161 162 static int acpi_battery_is_charged(struct acpi_battery *battery) 163 { 164 /* either charging or discharging */ 165 if (battery->state != 0) 166 return 0; 167 168 /* battery not reporting charge */ 169 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN || 170 battery->capacity_now == 0) 171 return 0; 172 173 /* good batteries update full_charge as the batteries degrade */ 174 if (battery->full_charge_capacity == battery->capacity_now) 175 return 1; 176 177 /* fallback to using design values for broken batteries */ 178 if (battery->design_capacity == battery->capacity_now) 179 return 1; 180 181 /* we don't do any sort of metric based on percentages */ 182 return 0; 183 } 184 185 static int acpi_battery_get_property(struct power_supply *psy, 186 enum power_supply_property psp, 187 union power_supply_propval *val) 188 { 189 struct acpi_battery *battery = to_acpi_battery(psy); 190 191 if (acpi_battery_present(battery)) { 192 /* run battery update only if it is present */ 193 acpi_battery_get_state(battery); 194 } else if (psp != POWER_SUPPLY_PROP_PRESENT) 195 return -ENODEV; 196 switch (psp) { 197 case POWER_SUPPLY_PROP_STATUS: 198 if (battery->state & 0x01) 199 val->intval = POWER_SUPPLY_STATUS_DISCHARGING; 200 else if (battery->state & 0x02) 201 val->intval = POWER_SUPPLY_STATUS_CHARGING; 202 else if (acpi_battery_is_charged(battery)) 203 val->intval = POWER_SUPPLY_STATUS_FULL; 204 else 205 val->intval = POWER_SUPPLY_STATUS_UNKNOWN; 206 break; 207 case POWER_SUPPLY_PROP_PRESENT: 208 val->intval = acpi_battery_present(battery); 209 break; 210 case POWER_SUPPLY_PROP_TECHNOLOGY: 211 val->intval = acpi_battery_technology(battery); 212 break; 213 case POWER_SUPPLY_PROP_CYCLE_COUNT: 214 val->intval = battery->cycle_count; 215 break; 216 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN: 217 val->intval = battery->design_voltage * 1000; 218 break; 219 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 220 val->intval = battery->voltage_now * 1000; 221 break; 222 case POWER_SUPPLY_PROP_CURRENT_NOW: 223 case POWER_SUPPLY_PROP_POWER_NOW: 224 val->intval = battery->rate_now * 1000; 225 break; 226 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN: 227 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN: 228 val->intval = battery->design_capacity * 1000; 229 break; 230 case POWER_SUPPLY_PROP_CHARGE_FULL: 231 case POWER_SUPPLY_PROP_ENERGY_FULL: 232 val->intval = battery->full_charge_capacity * 1000; 233 break; 234 case POWER_SUPPLY_PROP_CHARGE_NOW: 235 case POWER_SUPPLY_PROP_ENERGY_NOW: 236 val->intval = battery->capacity_now * 1000; 237 break; 238 case POWER_SUPPLY_PROP_MODEL_NAME: 239 val->strval = battery->model_number; 240 break; 241 case POWER_SUPPLY_PROP_MANUFACTURER: 242 val->strval = battery->oem_info; 243 break; 244 case POWER_SUPPLY_PROP_SERIAL_NUMBER: 245 val->strval = battery->serial_number; 246 break; 247 default: 248 return -EINVAL; 249 } 250 return 0; 251 } 252 253 static enum power_supply_property charge_battery_props[] = { 254 POWER_SUPPLY_PROP_STATUS, 255 POWER_SUPPLY_PROP_PRESENT, 256 POWER_SUPPLY_PROP_TECHNOLOGY, 257 POWER_SUPPLY_PROP_CYCLE_COUNT, 258 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN, 259 POWER_SUPPLY_PROP_VOLTAGE_NOW, 260 POWER_SUPPLY_PROP_CURRENT_NOW, 261 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, 262 POWER_SUPPLY_PROP_CHARGE_FULL, 263 POWER_SUPPLY_PROP_CHARGE_NOW, 264 POWER_SUPPLY_PROP_MODEL_NAME, 265 POWER_SUPPLY_PROP_MANUFACTURER, 266 POWER_SUPPLY_PROP_SERIAL_NUMBER, 267 }; 268 269 static enum power_supply_property energy_battery_props[] = { 270 POWER_SUPPLY_PROP_STATUS, 271 POWER_SUPPLY_PROP_PRESENT, 272 POWER_SUPPLY_PROP_TECHNOLOGY, 273 POWER_SUPPLY_PROP_CYCLE_COUNT, 274 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN, 275 POWER_SUPPLY_PROP_VOLTAGE_NOW, 276 POWER_SUPPLY_PROP_POWER_NOW, 277 POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN, 278 POWER_SUPPLY_PROP_ENERGY_FULL, 279 POWER_SUPPLY_PROP_ENERGY_NOW, 280 POWER_SUPPLY_PROP_MODEL_NAME, 281 POWER_SUPPLY_PROP_MANUFACTURER, 282 POWER_SUPPLY_PROP_SERIAL_NUMBER, 283 }; 284 #endif 285 286 #ifdef CONFIG_ACPI_PROCFS_POWER 287 inline char *acpi_battery_units(struct acpi_battery *battery) 288 { 289 return (battery->power_unit)?"mA":"mW"; 290 } 291 #endif 292 293 /* -------------------------------------------------------------------------- 294 Battery Management 295 -------------------------------------------------------------------------- */ 296 struct acpi_offsets { 297 size_t offset; /* offset inside struct acpi_sbs_battery */ 298 u8 mode; /* int or string? */ 299 }; 300 301 static struct acpi_offsets state_offsets[] = { 302 {offsetof(struct acpi_battery, state), 0}, 303 {offsetof(struct acpi_battery, rate_now), 0}, 304 {offsetof(struct acpi_battery, capacity_now), 0}, 305 {offsetof(struct acpi_battery, voltage_now), 0}, 306 }; 307 308 static struct acpi_offsets info_offsets[] = { 309 {offsetof(struct acpi_battery, power_unit), 0}, 310 {offsetof(struct acpi_battery, design_capacity), 0}, 311 {offsetof(struct acpi_battery, full_charge_capacity), 0}, 312 {offsetof(struct acpi_battery, technology), 0}, 313 {offsetof(struct acpi_battery, design_voltage), 0}, 314 {offsetof(struct acpi_battery, design_capacity_warning), 0}, 315 {offsetof(struct acpi_battery, design_capacity_low), 0}, 316 {offsetof(struct acpi_battery, capacity_granularity_1), 0}, 317 {offsetof(struct acpi_battery, capacity_granularity_2), 0}, 318 {offsetof(struct acpi_battery, model_number), 1}, 319 {offsetof(struct acpi_battery, serial_number), 1}, 320 {offsetof(struct acpi_battery, type), 1}, 321 {offsetof(struct acpi_battery, oem_info), 1}, 322 }; 323 324 static struct acpi_offsets extended_info_offsets[] = { 325 {offsetof(struct acpi_battery, power_unit), 0}, 326 {offsetof(struct acpi_battery, design_capacity), 0}, 327 {offsetof(struct acpi_battery, full_charge_capacity), 0}, 328 {offsetof(struct acpi_battery, technology), 0}, 329 {offsetof(struct acpi_battery, design_voltage), 0}, 330 {offsetof(struct acpi_battery, design_capacity_warning), 0}, 331 {offsetof(struct acpi_battery, design_capacity_low), 0}, 332 {offsetof(struct acpi_battery, cycle_count), 0}, 333 {offsetof(struct acpi_battery, measurement_accuracy), 0}, 334 {offsetof(struct acpi_battery, max_sampling_time), 0}, 335 {offsetof(struct acpi_battery, min_sampling_time), 0}, 336 {offsetof(struct acpi_battery, max_averaging_interval), 0}, 337 {offsetof(struct acpi_battery, min_averaging_interval), 0}, 338 {offsetof(struct acpi_battery, capacity_granularity_1), 0}, 339 {offsetof(struct acpi_battery, capacity_granularity_2), 0}, 340 {offsetof(struct acpi_battery, model_number), 1}, 341 {offsetof(struct acpi_battery, serial_number), 1}, 342 {offsetof(struct acpi_battery, type), 1}, 343 {offsetof(struct acpi_battery, oem_info), 1}, 344 }; 345 346 static int extract_package(struct acpi_battery *battery, 347 union acpi_object *package, 348 struct acpi_offsets *offsets, int num) 349 { 350 int i; 351 union acpi_object *element; 352 if (package->type != ACPI_TYPE_PACKAGE) 353 return -EFAULT; 354 for (i = 0; i < num; ++i) { 355 if (package->package.count <= i) 356 return -EFAULT; 357 element = &package->package.elements[i]; 358 if (offsets[i].mode) { 359 u8 *ptr = (u8 *)battery + offsets[i].offset; 360 if (element->type == ACPI_TYPE_STRING || 361 element->type == ACPI_TYPE_BUFFER) 362 strncpy(ptr, element->string.pointer, 32); 363 else if (element->type == ACPI_TYPE_INTEGER) { 364 strncpy(ptr, (u8 *)&element->integer.value, 365 sizeof(u64)); 366 ptr[sizeof(u64)] = 0; 367 } else 368 *ptr = 0; /* don't have value */ 369 } else { 370 int *x = (int *)((u8 *)battery + offsets[i].offset); 371 *x = (element->type == ACPI_TYPE_INTEGER) ? 372 element->integer.value : -1; 373 } 374 } 375 return 0; 376 } 377 378 static int acpi_battery_get_status(struct acpi_battery *battery) 379 { 380 if (acpi_bus_get_status(battery->device)) { 381 ACPI_EXCEPTION((AE_INFO, AE_ERROR, "Evaluating _STA")); 382 return -ENODEV; 383 } 384 return 0; 385 } 386 387 static int acpi_battery_get_info(struct acpi_battery *battery) 388 { 389 int result = -EFAULT; 390 acpi_status status = 0; 391 char *name = test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags)? 392 "_BIX" : "_BIF"; 393 394 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 395 396 if (!acpi_battery_present(battery)) 397 return 0; 398 mutex_lock(&battery->lock); 399 status = acpi_evaluate_object(battery->device->handle, name, 400 NULL, &buffer); 401 mutex_unlock(&battery->lock); 402 403 if (ACPI_FAILURE(status)) { 404 ACPI_EXCEPTION((AE_INFO, status, "Evaluating %s", name)); 405 return -ENODEV; 406 } 407 if (test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags)) 408 result = extract_package(battery, buffer.pointer, 409 extended_info_offsets, 410 ARRAY_SIZE(extended_info_offsets)); 411 else 412 result = extract_package(battery, buffer.pointer, 413 info_offsets, ARRAY_SIZE(info_offsets)); 414 kfree(buffer.pointer); 415 return result; 416 } 417 418 static int acpi_battery_get_state(struct acpi_battery *battery) 419 { 420 int result = 0; 421 acpi_status status = 0; 422 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 423 424 if (!acpi_battery_present(battery)) 425 return 0; 426 427 if (battery->update_time && 428 time_before(jiffies, battery->update_time + 429 msecs_to_jiffies(cache_time))) 430 return 0; 431 432 mutex_lock(&battery->lock); 433 status = acpi_evaluate_object(battery->device->handle, "_BST", 434 NULL, &buffer); 435 mutex_unlock(&battery->lock); 436 437 if (ACPI_FAILURE(status)) { 438 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST")); 439 return -ENODEV; 440 } 441 442 result = extract_package(battery, buffer.pointer, 443 state_offsets, ARRAY_SIZE(state_offsets)); 444 battery->update_time = jiffies; 445 kfree(buffer.pointer); 446 447 if (test_bit(ACPI_BATTERY_QUIRK_SIGNED16_CURRENT, &battery->flags) && 448 battery->rate_now != -1) 449 battery->rate_now = abs((s16)battery->rate_now); 450 451 return result; 452 } 453 454 static int acpi_battery_set_alarm(struct acpi_battery *battery) 455 { 456 acpi_status status = 0; 457 union acpi_object arg0 = { .type = ACPI_TYPE_INTEGER }; 458 struct acpi_object_list arg_list = { 1, &arg0 }; 459 460 if (!acpi_battery_present(battery) || 461 !test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags)) 462 return -ENODEV; 463 464 arg0.integer.value = battery->alarm; 465 466 mutex_lock(&battery->lock); 467 status = acpi_evaluate_object(battery->device->handle, "_BTP", 468 &arg_list, NULL); 469 mutex_unlock(&battery->lock); 470 471 if (ACPI_FAILURE(status)) 472 return -ENODEV; 473 474 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", battery->alarm)); 475 return 0; 476 } 477 478 static int acpi_battery_init_alarm(struct acpi_battery *battery) 479 { 480 acpi_status status = AE_OK; 481 acpi_handle handle = NULL; 482 483 /* See if alarms are supported, and if so, set default */ 484 status = acpi_get_handle(battery->device->handle, "_BTP", &handle); 485 if (ACPI_FAILURE(status)) { 486 clear_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags); 487 return 0; 488 } 489 set_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags); 490 if (!battery->alarm) 491 battery->alarm = battery->design_capacity_warning; 492 return acpi_battery_set_alarm(battery); 493 } 494 495 #ifdef CONFIG_ACPI_SYSFS_POWER 496 static ssize_t acpi_battery_alarm_show(struct device *dev, 497 struct device_attribute *attr, 498 char *buf) 499 { 500 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev)); 501 return sprintf(buf, "%d\n", battery->alarm * 1000); 502 } 503 504 static ssize_t acpi_battery_alarm_store(struct device *dev, 505 struct device_attribute *attr, 506 const char *buf, size_t count) 507 { 508 unsigned long x; 509 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev)); 510 if (sscanf(buf, "%ld\n", &x) == 1) 511 battery->alarm = x/1000; 512 if (acpi_battery_present(battery)) 513 acpi_battery_set_alarm(battery); 514 return count; 515 } 516 517 static struct device_attribute alarm_attr = { 518 .attr = {.name = "alarm", .mode = 0644}, 519 .show = acpi_battery_alarm_show, 520 .store = acpi_battery_alarm_store, 521 }; 522 523 static int sysfs_add_battery(struct acpi_battery *battery) 524 { 525 int result; 526 527 if (battery->power_unit) { 528 battery->bat.properties = charge_battery_props; 529 battery->bat.num_properties = 530 ARRAY_SIZE(charge_battery_props); 531 } else { 532 battery->bat.properties = energy_battery_props; 533 battery->bat.num_properties = 534 ARRAY_SIZE(energy_battery_props); 535 } 536 537 battery->bat.name = acpi_device_bid(battery->device); 538 battery->bat.type = POWER_SUPPLY_TYPE_BATTERY; 539 battery->bat.get_property = acpi_battery_get_property; 540 541 result = power_supply_register(&battery->device->dev, &battery->bat); 542 if (result) 543 return result; 544 return device_create_file(battery->bat.dev, &alarm_attr); 545 } 546 547 static void sysfs_remove_battery(struct acpi_battery *battery) 548 { 549 if (!battery->bat.dev) 550 return; 551 device_remove_file(battery->bat.dev, &alarm_attr); 552 power_supply_unregister(&battery->bat); 553 battery->bat.dev = NULL; 554 } 555 #endif 556 557 static void acpi_battery_quirks(struct acpi_battery *battery) 558 { 559 if (dmi_name_in_vendors("Acer") && battery->power_unit) { 560 set_bit(ACPI_BATTERY_QUIRK_SIGNED16_CURRENT, &battery->flags); 561 } 562 } 563 564 static int acpi_battery_update(struct acpi_battery *battery) 565 { 566 int result, old_present = acpi_battery_present(battery); 567 result = acpi_battery_get_status(battery); 568 if (result) 569 return result; 570 if (!acpi_battery_present(battery)) { 571 #ifdef CONFIG_ACPI_SYSFS_POWER 572 sysfs_remove_battery(battery); 573 #endif 574 battery->update_time = 0; 575 return 0; 576 } 577 if (!battery->update_time || 578 old_present != acpi_battery_present(battery)) { 579 result = acpi_battery_get_info(battery); 580 if (result) 581 return result; 582 acpi_battery_quirks(battery); 583 acpi_battery_init_alarm(battery); 584 } 585 #ifdef CONFIG_ACPI_SYSFS_POWER 586 if (!battery->bat.dev) 587 sysfs_add_battery(battery); 588 #endif 589 return acpi_battery_get_state(battery); 590 } 591 592 /* -------------------------------------------------------------------------- 593 FS Interface (/proc) 594 -------------------------------------------------------------------------- */ 595 596 #ifdef CONFIG_ACPI_PROCFS_POWER 597 static struct proc_dir_entry *acpi_battery_dir; 598 599 static int acpi_battery_print_info(struct seq_file *seq, int result) 600 { 601 struct acpi_battery *battery = seq->private; 602 603 if (result) 604 goto end; 605 606 seq_printf(seq, "present: %s\n", 607 acpi_battery_present(battery)?"yes":"no"); 608 if (!acpi_battery_present(battery)) 609 goto end; 610 if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN) 611 seq_printf(seq, "design capacity: unknown\n"); 612 else 613 seq_printf(seq, "design capacity: %d %sh\n", 614 battery->design_capacity, 615 acpi_battery_units(battery)); 616 617 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN) 618 seq_printf(seq, "last full capacity: unknown\n"); 619 else 620 seq_printf(seq, "last full capacity: %d %sh\n", 621 battery->full_charge_capacity, 622 acpi_battery_units(battery)); 623 624 seq_printf(seq, "battery technology: %srechargeable\n", 625 (!battery->technology)?"non-":""); 626 627 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN) 628 seq_printf(seq, "design voltage: unknown\n"); 629 else 630 seq_printf(seq, "design voltage: %d mV\n", 631 battery->design_voltage); 632 seq_printf(seq, "design capacity warning: %d %sh\n", 633 battery->design_capacity_warning, 634 acpi_battery_units(battery)); 635 seq_printf(seq, "design capacity low: %d %sh\n", 636 battery->design_capacity_low, 637 acpi_battery_units(battery)); 638 seq_printf(seq, "cycle count: %i\n", battery->cycle_count); 639 seq_printf(seq, "capacity granularity 1: %d %sh\n", 640 battery->capacity_granularity_1, 641 acpi_battery_units(battery)); 642 seq_printf(seq, "capacity granularity 2: %d %sh\n", 643 battery->capacity_granularity_2, 644 acpi_battery_units(battery)); 645 seq_printf(seq, "model number: %s\n", battery->model_number); 646 seq_printf(seq, "serial number: %s\n", battery->serial_number); 647 seq_printf(seq, "battery type: %s\n", battery->type); 648 seq_printf(seq, "OEM info: %s\n", battery->oem_info); 649 end: 650 if (result) 651 seq_printf(seq, "ERROR: Unable to read battery info\n"); 652 return result; 653 } 654 655 static int acpi_battery_print_state(struct seq_file *seq, int result) 656 { 657 struct acpi_battery *battery = seq->private; 658 659 if (result) 660 goto end; 661 662 seq_printf(seq, "present: %s\n", 663 acpi_battery_present(battery)?"yes":"no"); 664 if (!acpi_battery_present(battery)) 665 goto end; 666 667 seq_printf(seq, "capacity state: %s\n", 668 (battery->state & 0x04)?"critical":"ok"); 669 if ((battery->state & 0x01) && (battery->state & 0x02)) 670 seq_printf(seq, 671 "charging state: charging/discharging\n"); 672 else if (battery->state & 0x01) 673 seq_printf(seq, "charging state: discharging\n"); 674 else if (battery->state & 0x02) 675 seq_printf(seq, "charging state: charging\n"); 676 else 677 seq_printf(seq, "charging state: charged\n"); 678 679 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN) 680 seq_printf(seq, "present rate: unknown\n"); 681 else 682 seq_printf(seq, "present rate: %d %s\n", 683 battery->rate_now, acpi_battery_units(battery)); 684 685 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN) 686 seq_printf(seq, "remaining capacity: unknown\n"); 687 else 688 seq_printf(seq, "remaining capacity: %d %sh\n", 689 battery->capacity_now, acpi_battery_units(battery)); 690 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN) 691 seq_printf(seq, "present voltage: unknown\n"); 692 else 693 seq_printf(seq, "present voltage: %d mV\n", 694 battery->voltage_now); 695 end: 696 if (result) 697 seq_printf(seq, "ERROR: Unable to read battery state\n"); 698 699 return result; 700 } 701 702 static int acpi_battery_print_alarm(struct seq_file *seq, int result) 703 { 704 struct acpi_battery *battery = seq->private; 705 706 if (result) 707 goto end; 708 709 if (!acpi_battery_present(battery)) { 710 seq_printf(seq, "present: no\n"); 711 goto end; 712 } 713 seq_printf(seq, "alarm: "); 714 if (!battery->alarm) 715 seq_printf(seq, "unsupported\n"); 716 else 717 seq_printf(seq, "%u %sh\n", battery->alarm, 718 acpi_battery_units(battery)); 719 end: 720 if (result) 721 seq_printf(seq, "ERROR: Unable to read battery alarm\n"); 722 return result; 723 } 724 725 static ssize_t acpi_battery_write_alarm(struct file *file, 726 const char __user * buffer, 727 size_t count, loff_t * ppos) 728 { 729 int result = 0; 730 char alarm_string[12] = { '\0' }; 731 struct seq_file *m = file->private_data; 732 struct acpi_battery *battery = m->private; 733 734 if (!battery || (count > sizeof(alarm_string) - 1)) 735 return -EINVAL; 736 if (!acpi_battery_present(battery)) { 737 result = -ENODEV; 738 goto end; 739 } 740 if (copy_from_user(alarm_string, buffer, count)) { 741 result = -EFAULT; 742 goto end; 743 } 744 alarm_string[count] = '\0'; 745 battery->alarm = simple_strtol(alarm_string, NULL, 0); 746 result = acpi_battery_set_alarm(battery); 747 end: 748 if (!result) 749 return count; 750 return result; 751 } 752 753 typedef int(*print_func)(struct seq_file *seq, int result); 754 755 static print_func acpi_print_funcs[ACPI_BATTERY_NUMFILES] = { 756 acpi_battery_print_info, 757 acpi_battery_print_state, 758 acpi_battery_print_alarm, 759 }; 760 761 static int acpi_battery_read(int fid, struct seq_file *seq) 762 { 763 struct acpi_battery *battery = seq->private; 764 int result = acpi_battery_update(battery); 765 return acpi_print_funcs[fid](seq, result); 766 } 767 768 #define DECLARE_FILE_FUNCTIONS(_name) \ 769 static int acpi_battery_read_##_name(struct seq_file *seq, void *offset) \ 770 { \ 771 return acpi_battery_read(_name##_tag, seq); \ 772 } \ 773 static int acpi_battery_##_name##_open_fs(struct inode *inode, struct file *file) \ 774 { \ 775 return single_open(file, acpi_battery_read_##_name, PDE(inode)->data); \ 776 } 777 778 DECLARE_FILE_FUNCTIONS(info); 779 DECLARE_FILE_FUNCTIONS(state); 780 DECLARE_FILE_FUNCTIONS(alarm); 781 782 #undef DECLARE_FILE_FUNCTIONS 783 784 #define FILE_DESCRIPTION_RO(_name) \ 785 { \ 786 .name = __stringify(_name), \ 787 .mode = S_IRUGO, \ 788 .ops = { \ 789 .open = acpi_battery_##_name##_open_fs, \ 790 .read = seq_read, \ 791 .llseek = seq_lseek, \ 792 .release = single_release, \ 793 .owner = THIS_MODULE, \ 794 }, \ 795 } 796 797 #define FILE_DESCRIPTION_RW(_name) \ 798 { \ 799 .name = __stringify(_name), \ 800 .mode = S_IFREG | S_IRUGO | S_IWUSR, \ 801 .ops = { \ 802 .open = acpi_battery_##_name##_open_fs, \ 803 .read = seq_read, \ 804 .llseek = seq_lseek, \ 805 .write = acpi_battery_write_##_name, \ 806 .release = single_release, \ 807 .owner = THIS_MODULE, \ 808 }, \ 809 } 810 811 static struct battery_file { 812 struct file_operations ops; 813 mode_t mode; 814 const char *name; 815 } acpi_battery_file[] = { 816 FILE_DESCRIPTION_RO(info), 817 FILE_DESCRIPTION_RO(state), 818 FILE_DESCRIPTION_RW(alarm), 819 }; 820 821 #undef FILE_DESCRIPTION_RO 822 #undef FILE_DESCRIPTION_RW 823 824 static int acpi_battery_add_fs(struct acpi_device *device) 825 { 826 struct proc_dir_entry *entry = NULL; 827 int i; 828 829 if (!acpi_device_dir(device)) { 830 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device), 831 acpi_battery_dir); 832 if (!acpi_device_dir(device)) 833 return -ENODEV; 834 } 835 836 for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i) { 837 entry = proc_create_data(acpi_battery_file[i].name, 838 acpi_battery_file[i].mode, 839 acpi_device_dir(device), 840 &acpi_battery_file[i].ops, 841 acpi_driver_data(device)); 842 if (!entry) 843 return -ENODEV; 844 } 845 return 0; 846 } 847 848 static void acpi_battery_remove_fs(struct acpi_device *device) 849 { 850 int i; 851 if (!acpi_device_dir(device)) 852 return; 853 for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i) 854 remove_proc_entry(acpi_battery_file[i].name, 855 acpi_device_dir(device)); 856 857 remove_proc_entry(acpi_device_bid(device), acpi_battery_dir); 858 acpi_device_dir(device) = NULL; 859 } 860 861 #endif 862 863 /* -------------------------------------------------------------------------- 864 Driver Interface 865 -------------------------------------------------------------------------- */ 866 867 static void acpi_battery_notify(struct acpi_device *device, u32 event) 868 { 869 struct acpi_battery *battery = acpi_driver_data(device); 870 #ifdef CONFIG_ACPI_SYSFS_POWER 871 struct device *old; 872 #endif 873 874 if (!battery) 875 return; 876 #ifdef CONFIG_ACPI_SYSFS_POWER 877 old = battery->bat.dev; 878 #endif 879 acpi_battery_update(battery); 880 acpi_bus_generate_proc_event(device, event, 881 acpi_battery_present(battery)); 882 acpi_bus_generate_netlink_event(device->pnp.device_class, 883 dev_name(&device->dev), event, 884 acpi_battery_present(battery)); 885 #ifdef CONFIG_ACPI_SYSFS_POWER 886 /* acpi_battery_update could remove power_supply object */ 887 if (old && battery->bat.dev) 888 power_supply_changed(&battery->bat); 889 #endif 890 } 891 892 static int acpi_battery_add(struct acpi_device *device) 893 { 894 int result = 0; 895 struct acpi_battery *battery = NULL; 896 acpi_handle handle; 897 if (!device) 898 return -EINVAL; 899 battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL); 900 if (!battery) 901 return -ENOMEM; 902 battery->device = device; 903 strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME); 904 strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS); 905 device->driver_data = battery; 906 mutex_init(&battery->lock); 907 if (ACPI_SUCCESS(acpi_get_handle(battery->device->handle, 908 "_BIX", &handle))) 909 set_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags); 910 acpi_battery_update(battery); 911 #ifdef CONFIG_ACPI_PROCFS_POWER 912 result = acpi_battery_add_fs(device); 913 #endif 914 if (!result) { 915 printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n", 916 ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device), 917 device->status.battery_present ? "present" : "absent"); 918 } else { 919 #ifdef CONFIG_ACPI_PROCFS_POWER 920 acpi_battery_remove_fs(device); 921 #endif 922 kfree(battery); 923 } 924 return result; 925 } 926 927 static int acpi_battery_remove(struct acpi_device *device, int type) 928 { 929 struct acpi_battery *battery = NULL; 930 931 if (!device || !acpi_driver_data(device)) 932 return -EINVAL; 933 battery = acpi_driver_data(device); 934 #ifdef CONFIG_ACPI_PROCFS_POWER 935 acpi_battery_remove_fs(device); 936 #endif 937 #ifdef CONFIG_ACPI_SYSFS_POWER 938 sysfs_remove_battery(battery); 939 #endif 940 mutex_destroy(&battery->lock); 941 kfree(battery); 942 return 0; 943 } 944 945 /* this is needed to learn about changes made in suspended state */ 946 static int acpi_battery_resume(struct acpi_device *device) 947 { 948 struct acpi_battery *battery; 949 if (!device) 950 return -EINVAL; 951 battery = acpi_driver_data(device); 952 battery->update_time = 0; 953 acpi_battery_update(battery); 954 return 0; 955 } 956 957 static struct acpi_driver acpi_battery_driver = { 958 .name = "battery", 959 .class = ACPI_BATTERY_CLASS, 960 .ids = battery_device_ids, 961 .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS, 962 .ops = { 963 .add = acpi_battery_add, 964 .resume = acpi_battery_resume, 965 .remove = acpi_battery_remove, 966 .notify = acpi_battery_notify, 967 }, 968 }; 969 970 static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie) 971 { 972 if (acpi_disabled) 973 return; 974 #ifdef CONFIG_ACPI_PROCFS_POWER 975 acpi_battery_dir = acpi_lock_battery_dir(); 976 if (!acpi_battery_dir) 977 return; 978 #endif 979 if (acpi_bus_register_driver(&acpi_battery_driver) < 0) { 980 #ifdef CONFIG_ACPI_PROCFS_POWER 981 acpi_unlock_battery_dir(acpi_battery_dir); 982 #endif 983 return; 984 } 985 return; 986 } 987 988 static int __init acpi_battery_init(void) 989 { 990 async_schedule(acpi_battery_init_async, NULL); 991 return 0; 992 } 993 994 static void __exit acpi_battery_exit(void) 995 { 996 acpi_bus_unregister_driver(&acpi_battery_driver); 997 #ifdef CONFIG_ACPI_PROCFS_POWER 998 acpi_unlock_battery_dir(acpi_battery_dir); 999 #endif 1000 } 1001 1002 module_init(acpi_battery_init); 1003 module_exit(acpi_battery_exit); 1004