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