PageRenderTime 82ms CodeModel.GetById 10ms app.highlight 60ms RepoModel.GetById 1ms app.codeStats 0ms

/drivers/acpi/battery.c

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