battery.c 29.9 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
2
 *  battery.c - ACPI Battery Driver (Revision: 2.0)
L
Linus Torvalds 已提交
3
 *
4 5
 *  Copyright (C) 2007 Alexey Starikovskiy <astarikovskiy@suse.de>
 *  Copyright (C) 2004-2007 Vladimir Lebedev <vladimir.p.lebedev@intel.com>
L
Linus Torvalds 已提交
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
 *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
 *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or (at
 *  your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful, but
 *  WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#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
L
Linus Torvalds 已提交
38 39 40
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <asm/uaccess.h>
41
#endif
L
Linus Torvalds 已提交
42 43 44

#include <acpi/acpi_bus.h>
#include <acpi/acpi_drivers.h>
45 46
#include <linux/power_supply.h>

47 48
#define PREFIX "ACPI: "

L
Linus Torvalds 已提交
49 50 51 52 53 54
#define ACPI_BATTERY_VALUE_UNKNOWN 0xFFFFFFFF

#define ACPI_BATTERY_CLASS		"battery"
#define ACPI_BATTERY_DEVICE_NAME	"Battery"
#define ACPI_BATTERY_NOTIFY_STATUS	0x80
#define ACPI_BATTERY_NOTIFY_INFO	0x81
55
#define ACPI_BATTERY_NOTIFY_THRESHOLD   0x82
L
Linus Torvalds 已提交
56 57

#define _COMPONENT		ACPI_BATTERY_COMPONENT
58

59
ACPI_MODULE_NAME("battery");
L
Linus Torvalds 已提交
60

61
MODULE_AUTHOR("Paul Diefenbaugh");
62
MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>");
63
MODULE_DESCRIPTION("ACPI Battery Driver");
L
Linus Torvalds 已提交
64 65
MODULE_LICENSE("GPL");

66 67 68
static unsigned int cache_time = 1000;
module_param(cache_time, uint, 0644);
MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
69

70
#ifdef CONFIG_ACPI_PROCFS_POWER
71 72 73
extern struct proc_dir_entry *acpi_lock_battery_dir(void);
extern void *acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir);

74 75 76 77 78 79 80 81 82
enum acpi_battery_files {
	info_tag = 0,
	state_tag,
	alarm_tag,
	ACPI_BATTERY_NUMFILES,
};

#endif

83 84 85 86 87
static const struct acpi_device_id battery_device_ids[] = {
	{"PNP0C0A", 0},
	{"", 0},
};

88
MODULE_DEVICE_TABLE(acpi, battery_device_ids);
L
Linus Torvalds 已提交
89

90 91
enum {
	ACPI_BATTERY_ALARM_PRESENT,
92 93 94 95 96
	ACPI_BATTERY_XINFO_PRESENT,
	/* For buggy DSDTs that report negative 16-bit values for either
	 * charging or discharging current and/or report 0 as 65536
	 * due to bad math.
	 */
97
	ACPI_BATTERY_QUIRK_SIGNED16_CURRENT,
98
	ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY,
99
};
100

L
Linus Torvalds 已提交
101
struct acpi_battery {
102
	struct mutex lock;
103
	struct power_supply bat;
104 105
	struct acpi_device *device;
	unsigned long update_time;
106
	int rate_now;
107 108
	int capacity_now;
	int voltage_now;
109
	int design_capacity;
110
	int full_charge_capacity;
111 112 113 114
	int technology;
	int design_voltage;
	int design_capacity_warning;
	int design_capacity_low;
115 116 117 118 119 120
	int cycle_count;
	int measurement_accuracy;
	int max_sampling_time;
	int min_sampling_time;
	int max_averaging_interval;
	int min_averaging_interval;
121 122
	int capacity_granularity_1;
	int capacity_granularity_2;
123
	int alarm;
124 125 126 127
	char model_number[32];
	char serial_number[32];
	char type[32];
	char oem_info[32];
128 129
	int state;
	int power_unit;
130
	unsigned long flags;
L
Linus Torvalds 已提交
131 132
};

133 134
#define to_acpi_battery(x) container_of(x, struct acpi_battery, bat);

135
inline int acpi_battery_present(struct acpi_battery *battery)
136
{
137 138
	return battery->device->status.battery_present;
}
139

140 141 142 143 144 145 146 147
static int acpi_battery_technology(struct acpi_battery *battery)
{
	if (!strcasecmp("NiCd", battery->type))
		return POWER_SUPPLY_TECHNOLOGY_NiCd;
	if (!strcasecmp("NiMH", battery->type))
		return POWER_SUPPLY_TECHNOLOGY_NiMH;
	if (!strcasecmp("LION", battery->type))
		return POWER_SUPPLY_TECHNOLOGY_LION;
148
	if (!strncasecmp("LI-ION", battery->type, 6))
149
		return POWER_SUPPLY_TECHNOLOGY_LION;
150 151 152 153 154
	if (!strcasecmp("LiP", battery->type))
		return POWER_SUPPLY_TECHNOLOGY_LIPO;
	return POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
}

155
static int acpi_battery_get_state(struct acpi_battery *battery);
156

157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179
static int acpi_battery_is_charged(struct acpi_battery *battery)
{
	/* either charging or discharging */
	if (battery->state != 0)
		return 0;

	/* battery not reporting charge */
	if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN ||
	    battery->capacity_now == 0)
		return 0;

	/* good batteries update full_charge as the batteries degrade */
	if (battery->full_charge_capacity == battery->capacity_now)
		return 1;

	/* fallback to using design values for broken batteries */
	if (battery->design_capacity == battery->capacity_now)
		return 1;

	/* we don't do any sort of metric based on percentages */
	return 0;
}

180 181 182 183
static int acpi_battery_get_property(struct power_supply *psy,
				     enum power_supply_property psp,
				     union power_supply_propval *val)
{
184
	int ret = 0;
185 186
	struct acpi_battery *battery = to_acpi_battery(psy);

187 188 189 190
	if (acpi_battery_present(battery)) {
		/* run battery update only if it is present */
		acpi_battery_get_state(battery);
	} else if (psp != POWER_SUPPLY_PROP_PRESENT)
191 192 193 194 195 196 197
		return -ENODEV;
	switch (psp) {
	case POWER_SUPPLY_PROP_STATUS:
		if (battery->state & 0x01)
			val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
		else if (battery->state & 0x02)
			val->intval = POWER_SUPPLY_STATUS_CHARGING;
198
		else if (acpi_battery_is_charged(battery))
199
			val->intval = POWER_SUPPLY_STATUS_FULL;
200 201
		else
			val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
202 203 204 205 206 207 208
		break;
	case POWER_SUPPLY_PROP_PRESENT:
		val->intval = acpi_battery_present(battery);
		break;
	case POWER_SUPPLY_PROP_TECHNOLOGY:
		val->intval = acpi_battery_technology(battery);
		break;
209 210 211
	case POWER_SUPPLY_PROP_CYCLE_COUNT:
		val->intval = battery->cycle_count;
		break;
212
	case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
213 214 215 216
		if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
			ret = -ENODEV;
		else
			val->intval = battery->design_voltage * 1000;
217 218
		break;
	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
219 220 221 222
		if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
			ret = -ENODEV;
		else
			val->intval = battery->voltage_now * 1000;
223 224
		break;
	case POWER_SUPPLY_PROP_CURRENT_NOW:
225
	case POWER_SUPPLY_PROP_POWER_NOW:
226 227 228 229
		if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
			ret = -ENODEV;
		else
			val->intval = battery->rate_now * 1000;
230 231 232
		break;
	case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
	case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
233 234 235 236
		if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
			ret = -ENODEV;
		else
			val->intval = battery->design_capacity * 1000;
237 238 239
		break;
	case POWER_SUPPLY_PROP_CHARGE_FULL:
	case POWER_SUPPLY_PROP_ENERGY_FULL:
240 241 242 243
		if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
			ret = -ENODEV;
		else
			val->intval = battery->full_charge_capacity * 1000;
244 245 246
		break;
	case POWER_SUPPLY_PROP_CHARGE_NOW:
	case POWER_SUPPLY_PROP_ENERGY_NOW:
247 248 249 250
		if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
			ret = -ENODEV;
		else
			val->intval = battery->capacity_now * 1000;
251 252 253 254 255 256 257
		break;
	case POWER_SUPPLY_PROP_MODEL_NAME:
		val->strval = battery->model_number;
		break;
	case POWER_SUPPLY_PROP_MANUFACTURER:
		val->strval = battery->oem_info;
		break;
258 259 260
	case POWER_SUPPLY_PROP_SERIAL_NUMBER:
		val->strval = battery->serial_number;
		break;
261
	default:
262
		ret = -EINVAL;
263
	}
264
	return ret;
265 266 267 268 269 270
}

static enum power_supply_property charge_battery_props[] = {
	POWER_SUPPLY_PROP_STATUS,
	POWER_SUPPLY_PROP_PRESENT,
	POWER_SUPPLY_PROP_TECHNOLOGY,
271
	POWER_SUPPLY_PROP_CYCLE_COUNT,
272 273 274 275 276 277 278 279
	POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
	POWER_SUPPLY_PROP_VOLTAGE_NOW,
	POWER_SUPPLY_PROP_CURRENT_NOW,
	POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
	POWER_SUPPLY_PROP_CHARGE_FULL,
	POWER_SUPPLY_PROP_CHARGE_NOW,
	POWER_SUPPLY_PROP_MODEL_NAME,
	POWER_SUPPLY_PROP_MANUFACTURER,
280
	POWER_SUPPLY_PROP_SERIAL_NUMBER,
281 282 283 284 285 286
};

static enum power_supply_property energy_battery_props[] = {
	POWER_SUPPLY_PROP_STATUS,
	POWER_SUPPLY_PROP_PRESENT,
	POWER_SUPPLY_PROP_TECHNOLOGY,
287
	POWER_SUPPLY_PROP_CYCLE_COUNT,
288 289
	POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
	POWER_SUPPLY_PROP_VOLTAGE_NOW,
290
	POWER_SUPPLY_PROP_POWER_NOW,
291 292 293 294 295
	POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
	POWER_SUPPLY_PROP_ENERGY_FULL,
	POWER_SUPPLY_PROP_ENERGY_NOW,
	POWER_SUPPLY_PROP_MODEL_NAME,
	POWER_SUPPLY_PROP_MANUFACTURER,
296
	POWER_SUPPLY_PROP_SERIAL_NUMBER,
297 298
};

299
#ifdef CONFIG_ACPI_PROCFS_POWER
300
inline char *acpi_battery_units(struct acpi_battery *battery)
301
{
302
	return (battery->power_unit)?"mA":"mW";
303
}
304
#endif
305

306 307 308
/* --------------------------------------------------------------------------
                               Battery Management
   -------------------------------------------------------------------------- */
309 310 311 312
struct acpi_offsets {
	size_t offset;		/* offset inside struct acpi_sbs_battery */
	u8 mode;		/* int or string? */
};
313

314 315
static struct acpi_offsets state_offsets[] = {
	{offsetof(struct acpi_battery, state), 0},
316
	{offsetof(struct acpi_battery, rate_now), 0},
317 318
	{offsetof(struct acpi_battery, capacity_now), 0},
	{offsetof(struct acpi_battery, voltage_now), 0},
319
};
320

321 322 323
static struct acpi_offsets info_offsets[] = {
	{offsetof(struct acpi_battery, power_unit), 0},
	{offsetof(struct acpi_battery, design_capacity), 0},
324
	{offsetof(struct acpi_battery, full_charge_capacity), 0},
325 326 327 328 329 330 331 332 333 334 335
	{offsetof(struct acpi_battery, technology), 0},
	{offsetof(struct acpi_battery, design_voltage), 0},
	{offsetof(struct acpi_battery, design_capacity_warning), 0},
	{offsetof(struct acpi_battery, design_capacity_low), 0},
	{offsetof(struct acpi_battery, capacity_granularity_1), 0},
	{offsetof(struct acpi_battery, capacity_granularity_2), 0},
	{offsetof(struct acpi_battery, model_number), 1},
	{offsetof(struct acpi_battery, serial_number), 1},
	{offsetof(struct acpi_battery, type), 1},
	{offsetof(struct acpi_battery, oem_info), 1},
};
336

337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358
static struct acpi_offsets extended_info_offsets[] = {
	{offsetof(struct acpi_battery, power_unit), 0},
	{offsetof(struct acpi_battery, design_capacity), 0},
	{offsetof(struct acpi_battery, full_charge_capacity), 0},
	{offsetof(struct acpi_battery, technology), 0},
	{offsetof(struct acpi_battery, design_voltage), 0},
	{offsetof(struct acpi_battery, design_capacity_warning), 0},
	{offsetof(struct acpi_battery, design_capacity_low), 0},
	{offsetof(struct acpi_battery, cycle_count), 0},
	{offsetof(struct acpi_battery, measurement_accuracy), 0},
	{offsetof(struct acpi_battery, max_sampling_time), 0},
	{offsetof(struct acpi_battery, min_sampling_time), 0},
	{offsetof(struct acpi_battery, max_averaging_interval), 0},
	{offsetof(struct acpi_battery, min_averaging_interval), 0},
	{offsetof(struct acpi_battery, capacity_granularity_1), 0},
	{offsetof(struct acpi_battery, capacity_granularity_2), 0},
	{offsetof(struct acpi_battery, model_number), 1},
	{offsetof(struct acpi_battery, serial_number), 1},
	{offsetof(struct acpi_battery, type), 1},
	{offsetof(struct acpi_battery, oem_info), 1},
};

359 360 361 362
static int extract_package(struct acpi_battery *battery,
			   union acpi_object *package,
			   struct acpi_offsets *offsets, int num)
{
363
	int i;
364 365 366 367 368 369 370 371
	union acpi_object *element;
	if (package->type != ACPI_TYPE_PACKAGE)
		return -EFAULT;
	for (i = 0; i < num; ++i) {
		if (package->package.count <= i)
			return -EFAULT;
		element = &package->package.elements[i];
		if (offsets[i].mode) {
372 373 374 375 376 377
			u8 *ptr = (u8 *)battery + offsets[i].offset;
			if (element->type == ACPI_TYPE_STRING ||
			    element->type == ACPI_TYPE_BUFFER)
				strncpy(ptr, element->string.pointer, 32);
			else if (element->type == ACPI_TYPE_INTEGER) {
				strncpy(ptr, (u8 *)&element->integer.value,
L
Lin Ming 已提交
378 379
					sizeof(u64));
				ptr[sizeof(u64)] = 0;
380 381
			} else
				*ptr = 0; /* don't have value */
382
		} else {
383 384 385
			int *x = (int *)((u8 *)battery + offsets[i].offset);
			*x = (element->type == ACPI_TYPE_INTEGER) ?
				element->integer.value : -1;
386
		}
387 388 389 390 391 392
	}
	return 0;
}

static int acpi_battery_get_status(struct acpi_battery *battery)
{
393
	if (acpi_bus_get_status(battery->device)) {
394 395 396
		ACPI_EXCEPTION((AE_INFO, AE_ERROR, "Evaluating _STA"));
		return -ENODEV;
	}
397
	return 0;
398 399 400
}

static int acpi_battery_get_info(struct acpi_battery *battery)
L
Linus Torvalds 已提交
401
{
402
	int result = -EFAULT;
L
Len Brown 已提交
403
	acpi_status status = 0;
404 405 406
	char *name = test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags)?
			"_BIX" : "_BIF";

L
Len Brown 已提交
407
	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
L
Linus Torvalds 已提交
408

409 410
	if (!acpi_battery_present(battery))
		return 0;
411
	mutex_lock(&battery->lock);
412 413
	status = acpi_evaluate_object(battery->device->handle, name,
						NULL, &buffer);
414
	mutex_unlock(&battery->lock);
415

L
Linus Torvalds 已提交
416
	if (ACPI_FAILURE(status)) {
417
		ACPI_EXCEPTION((AE_INFO, status, "Evaluating %s", name));
418
		return -ENODEV;
L
Linus Torvalds 已提交
419
	}
420 421 422 423 424 425 426
	if (test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags))
		result = extract_package(battery, buffer.pointer,
				extended_info_offsets,
				ARRAY_SIZE(extended_info_offsets));
	else
		result = extract_package(battery, buffer.pointer,
				info_offsets, ARRAY_SIZE(info_offsets));
427
	kfree(buffer.pointer);
428 429
	if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
		battery->full_charge_capacity = battery->design_capacity;
430
	return result;
L
Linus Torvalds 已提交
431 432
}

433
static int acpi_battery_get_state(struct acpi_battery *battery)
L
Linus Torvalds 已提交
434
{
L
Len Brown 已提交
435 436 437
	int result = 0;
	acpi_status status = 0;
	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
L
Linus Torvalds 已提交
438

439 440
	if (!acpi_battery_present(battery))
		return 0;
L
Linus Torvalds 已提交
441

442 443 444 445 446
	if (battery->update_time &&
	    time_before(jiffies, battery->update_time +
			msecs_to_jiffies(cache_time)))
		return 0;

447
	mutex_lock(&battery->lock);
448
	status = acpi_evaluate_object(battery->device->handle, "_BST",
449 450
				      NULL, &buffer);
	mutex_unlock(&battery->lock);
451

L
Linus Torvalds 已提交
452
	if (ACPI_FAILURE(status)) {
453
		ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST"));
454
		return -ENODEV;
L
Linus Torvalds 已提交
455
	}
456

457 458
	result = extract_package(battery, buffer.pointer,
				 state_offsets, ARRAY_SIZE(state_offsets));
459
	battery->update_time = jiffies;
460
	kfree(buffer.pointer);
461

462
	if (test_bit(ACPI_BATTERY_QUIRK_SIGNED16_CURRENT, &battery->flags) &&
463 464 465
	    battery->rate_now != -1)
		battery->rate_now = abs((s16)battery->rate_now);

466 467 468 469
	if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags)
	    && battery->capacity_now >= 0 && battery->capacity_now <= 100)
		battery->capacity_now = (battery->capacity_now *
				battery->full_charge_capacity) / 100;
470 471
	return result;
}
L
Linus Torvalds 已提交
472

473
static int acpi_battery_set_alarm(struct acpi_battery *battery)
L
Linus Torvalds 已提交
474
{
L
Len Brown 已提交
475
	acpi_status status = 0;
476
	union acpi_object arg0 = { .type = ACPI_TYPE_INTEGER };
L
Len Brown 已提交
477
	struct acpi_object_list arg_list = { 1, &arg0 };
L
Linus Torvalds 已提交
478

479
	if (!acpi_battery_present(battery) ||
480
	    !test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags))
481
		return -ENODEV;
L
Linus Torvalds 已提交
482

483
	arg0.integer.value = battery->alarm;
L
Linus Torvalds 已提交
484

485
	mutex_lock(&battery->lock);
486 487
	status = acpi_evaluate_object(battery->device->handle, "_BTP",
				 &arg_list, NULL);
488
	mutex_unlock(&battery->lock);
489

L
Linus Torvalds 已提交
490
	if (ACPI_FAILURE(status))
491
		return -ENODEV;
L
Linus Torvalds 已提交
492

493
	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", battery->alarm));
494
	return 0;
L
Linus Torvalds 已提交
495 496
}

497
static int acpi_battery_init_alarm(struct acpi_battery *battery)
L
Linus Torvalds 已提交
498
{
L
Len Brown 已提交
499 500 501
	acpi_status status = AE_OK;
	acpi_handle handle = NULL;

502
	/* See if alarms are supported, and if so, set default */
503 504
	status = acpi_get_handle(battery->device->handle, "_BTP", &handle);
	if (ACPI_FAILURE(status)) {
505
		clear_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
506
		return 0;
507
	}
508
	set_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
509 510
	if (!battery->alarm)
		battery->alarm = battery->design_capacity_warning;
511
	return acpi_battery_set_alarm(battery);
512
}
L
Linus Torvalds 已提交
513

514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535
static ssize_t acpi_battery_alarm_show(struct device *dev,
					struct device_attribute *attr,
					char *buf)
{
	struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
	return sprintf(buf, "%d\n", battery->alarm * 1000);
}

static ssize_t acpi_battery_alarm_store(struct device *dev,
					struct device_attribute *attr,
					const char *buf, size_t count)
{
	unsigned long x;
	struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
	if (sscanf(buf, "%ld\n", &x) == 1)
		battery->alarm = x/1000;
	if (acpi_battery_present(battery))
		acpi_battery_set_alarm(battery);
	return count;
}

static struct device_attribute alarm_attr = {
536
	.attr = {.name = "alarm", .mode = 0644},
537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570
	.show = acpi_battery_alarm_show,
	.store = acpi_battery_alarm_store,
};

static int sysfs_add_battery(struct acpi_battery *battery)
{
	int result;

	if (battery->power_unit) {
		battery->bat.properties = charge_battery_props;
		battery->bat.num_properties =
			ARRAY_SIZE(charge_battery_props);
	} else {
		battery->bat.properties = energy_battery_props;
		battery->bat.num_properties =
			ARRAY_SIZE(energy_battery_props);
	}

	battery->bat.name = acpi_device_bid(battery->device);
	battery->bat.type = POWER_SUPPLY_TYPE_BATTERY;
	battery->bat.get_property = acpi_battery_get_property;

	result = power_supply_register(&battery->device->dev, &battery->bat);
	if (result)
		return result;
	return device_create_file(battery->bat.dev, &alarm_attr);
}

static void sysfs_remove_battery(struct acpi_battery *battery)
{
	if (!battery->bat.dev)
		return;
	device_remove_file(battery->bat.dev, &alarm_attr);
	power_supply_unregister(&battery->bat);
571
	battery->bat.dev = NULL;
572 573
}

574 575 576
static void acpi_battery_quirks(struct acpi_battery *battery)
{
	if (dmi_name_in_vendors("Acer") && battery->power_unit) {
577
		set_bit(ACPI_BATTERY_QUIRK_SIGNED16_CURRENT, &battery->flags);
578 579 580
	}
}

581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607
/*
 * According to the ACPI spec, some kinds of primary batteries can
 * report percentage battery remaining capacity directly to OS.
 * In this case, it reports the Last Full Charged Capacity == 100
 * and BatteryPresentRate == 0xFFFFFFFF.
 *
 * Now we found some battery reports percentage remaining capacity
 * even if it's rechargeable.
 * https://bugzilla.kernel.org/show_bug.cgi?id=15979
 *
 * Handle this correctly so that they won't break userspace.
 */
static void acpi_battery_quirks2(struct acpi_battery *battery)
{
	if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
		return ;

        if (battery->full_charge_capacity == 100 &&
            battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN &&
            battery->capacity_now >=0 && battery->capacity_now <= 100) {
		set_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags);
		battery->full_charge_capacity = battery->design_capacity;
		battery->capacity_now = (battery->capacity_now *
				battery->full_charge_capacity) / 100;
	}
}

608
static int acpi_battery_update(struct acpi_battery *battery)
609
{
610
	int result, old_present = acpi_battery_present(battery);
611
	result = acpi_battery_get_status(battery);
612
	if (result)
613
		return result;
614 615
	if (!acpi_battery_present(battery)) {
		sysfs_remove_battery(battery);
616
		battery->update_time = 0;
617
		return 0;
618
	}
619 620
	if (!battery->update_time ||
	    old_present != acpi_battery_present(battery)) {
621 622 623
		result = acpi_battery_get_info(battery);
		if (result)
			return result;
624
		acpi_battery_quirks(battery);
625 626
		acpi_battery_init_alarm(battery);
	}
627 628
	if (!battery->bat.dev)
		sysfs_add_battery(battery);
629 630 631
	result = acpi_battery_get_state(battery);
	acpi_battery_quirks2(battery);
	return result;
632 633
}

L
Linus Torvalds 已提交
634 635 636 637
/* --------------------------------------------------------------------------
                              FS Interface (/proc)
   -------------------------------------------------------------------------- */

638
#ifdef CONFIG_ACPI_PROCFS_POWER
L
Len Brown 已提交
639
static struct proc_dir_entry *acpi_battery_dir;
640

641
static int acpi_battery_print_info(struct seq_file *seq, int result)
L
Linus Torvalds 已提交
642
{
643
	struct acpi_battery *battery = seq->private;
L
Linus Torvalds 已提交
644

645
	if (result)
L
Linus Torvalds 已提交
646 647
		goto end;

648 649 650
	seq_printf(seq, "present:                 %s\n",
		   acpi_battery_present(battery)?"yes":"no");
	if (!acpi_battery_present(battery))
L
Linus Torvalds 已提交
651
		goto end;
652
	if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
L
Linus Torvalds 已提交
653 654 655
		seq_printf(seq, "design capacity:         unknown\n");
	else
		seq_printf(seq, "design capacity:         %d %sh\n",
656 657
			   battery->design_capacity,
			   acpi_battery_units(battery));
L
Linus Torvalds 已提交
658

659
	if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
L
Linus Torvalds 已提交
660 661 662
		seq_printf(seq, "last full capacity:      unknown\n");
	else
		seq_printf(seq, "last full capacity:      %d %sh\n",
663
			   battery->full_charge_capacity,
664 665 666 667
			   acpi_battery_units(battery));

	seq_printf(seq, "battery technology:      %srechargeable\n",
		   (!battery->technology)?"non-":"");
L
Linus Torvalds 已提交
668

669
	if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
L
Linus Torvalds 已提交
670 671 672
		seq_printf(seq, "design voltage:          unknown\n");
	else
		seq_printf(seq, "design voltage:          %d mV\n",
673
			   battery->design_voltage);
L
Linus Torvalds 已提交
674
	seq_printf(seq, "design capacity warning: %d %sh\n",
675 676
		   battery->design_capacity_warning,
		   acpi_battery_units(battery));
L
Linus Torvalds 已提交
677
	seq_printf(seq, "design capacity low:     %d %sh\n",
678 679
		   battery->design_capacity_low,
		   acpi_battery_units(battery));
680
	seq_printf(seq, "cycle count:		  %i\n", battery->cycle_count);
L
Linus Torvalds 已提交
681
	seq_printf(seq, "capacity granularity 1:  %d %sh\n",
682 683
		   battery->capacity_granularity_1,
		   acpi_battery_units(battery));
L
Linus Torvalds 已提交
684
	seq_printf(seq, "capacity granularity 2:  %d %sh\n",
685 686
		   battery->capacity_granularity_2,
		   acpi_battery_units(battery));
687 688 689 690
	seq_printf(seq, "model number:            %s\n", battery->model_number);
	seq_printf(seq, "serial number:           %s\n", battery->serial_number);
	seq_printf(seq, "battery type:            %s\n", battery->type);
	seq_printf(seq, "OEM info:                %s\n", battery->oem_info);
L
Len Brown 已提交
691
      end:
692 693 694 695 696
	if (result)
		seq_printf(seq, "ERROR: Unable to read battery info\n");
	return result;
}

697
static int acpi_battery_print_state(struct seq_file *seq, int result)
L
Linus Torvalds 已提交
698
{
699
	struct acpi_battery *battery = seq->private;
L
Linus Torvalds 已提交
700

701
	if (result)
L
Linus Torvalds 已提交
702 703
		goto end;

704 705 706
	seq_printf(seq, "present:                 %s\n",
		   acpi_battery_present(battery)?"yes":"no");
	if (!acpi_battery_present(battery))
L
Linus Torvalds 已提交
707
		goto end;
708

709 710 711
	seq_printf(seq, "capacity state:          %s\n",
			(battery->state & 0x04)?"critical":"ok");
	if ((battery->state & 0x01) && (battery->state & 0x02))
L
Len Brown 已提交
712 713
		seq_printf(seq,
			   "charging state:          charging/discharging\n");
714
	else if (battery->state & 0x01)
L
Linus Torvalds 已提交
715
		seq_printf(seq, "charging state:          discharging\n");
716
	else if (battery->state & 0x02)
L
Linus Torvalds 已提交
717
		seq_printf(seq, "charging state:          charging\n");
718
	else
L
Linus Torvalds 已提交
719 720
		seq_printf(seq, "charging state:          charged\n");

721
	if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
L
Linus Torvalds 已提交
722 723 724
		seq_printf(seq, "present rate:            unknown\n");
	else
		seq_printf(seq, "present rate:            %d %s\n",
725
			   battery->rate_now, acpi_battery_units(battery));
L
Linus Torvalds 已提交
726

727
	if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
L
Linus Torvalds 已提交
728 729 730
		seq_printf(seq, "remaining capacity:      unknown\n");
	else
		seq_printf(seq, "remaining capacity:      %d %sh\n",
731 732
			   battery->capacity_now, acpi_battery_units(battery));
	if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
L
Linus Torvalds 已提交
733 734 735
		seq_printf(seq, "present voltage:         unknown\n");
	else
		seq_printf(seq, "present voltage:         %d mV\n",
736
			   battery->voltage_now);
L
Len Brown 已提交
737
      end:
738
	if (result)
739 740 741 742 743
		seq_printf(seq, "ERROR: Unable to read battery state\n");

	return result;
}

744
static int acpi_battery_print_alarm(struct seq_file *seq, int result)
L
Linus Torvalds 已提交
745
{
746
	struct acpi_battery *battery = seq->private;
L
Linus Torvalds 已提交
747

748
	if (result)
L
Linus Torvalds 已提交
749 750
		goto end;

751
	if (!acpi_battery_present(battery)) {
L
Linus Torvalds 已提交
752 753 754 755 756 757 758
		seq_printf(seq, "present:                 no\n");
		goto end;
	}
	seq_printf(seq, "alarm:                   ");
	if (!battery->alarm)
		seq_printf(seq, "unsupported\n");
	else
759 760
		seq_printf(seq, "%u %sh\n", battery->alarm,
				acpi_battery_units(battery));
L
Len Brown 已提交
761
      end:
762 763 764 765 766
	if (result)
		seq_printf(seq, "ERROR: Unable to read battery alarm\n");
	return result;
}

767 768 769
static ssize_t acpi_battery_write_alarm(struct file *file,
					const char __user * buffer,
					size_t count, loff_t * ppos)
L
Linus Torvalds 已提交
770
{
L
Len Brown 已提交
771 772
	int result = 0;
	char alarm_string[12] = { '\0' };
773 774
	struct seq_file *m = file->private_data;
	struct acpi_battery *battery = m->private;
L
Linus Torvalds 已提交
775 776

	if (!battery || (count > sizeof(alarm_string) - 1))
777
		return -EINVAL;
778 779 780 781 782 783 784 785
	if (!acpi_battery_present(battery)) {
		result = -ENODEV;
		goto end;
	}
	if (copy_from_user(alarm_string, buffer, count)) {
		result = -EFAULT;
		goto end;
	}
L
Linus Torvalds 已提交
786
	alarm_string[count] = '\0';
787
	battery->alarm = simple_strtol(alarm_string, NULL, 0);
788
	result = acpi_battery_set_alarm(battery);
789 790
      end:
	if (!result)
791
		return count;
792 793 794 795
	return result;
}

typedef int(*print_func)(struct seq_file *seq, int result);
796 797 798 799 800

static print_func acpi_print_funcs[ACPI_BATTERY_NUMFILES] = {
	acpi_battery_print_info,
	acpi_battery_print_state,
	acpi_battery_print_alarm,
801
};
802

803 804 805
static int acpi_battery_read(int fid, struct seq_file *seq)
{
	struct acpi_battery *battery = seq->private;
806
	int result = acpi_battery_update(battery);
807
	return acpi_print_funcs[fid](seq, result);
808 809
}

810 811 812 813 814 815 816 817
#define DECLARE_FILE_FUNCTIONS(_name) \
static int acpi_battery_read_##_name(struct seq_file *seq, void *offset) \
{ \
	return acpi_battery_read(_name##_tag, seq); \
} \
static int acpi_battery_##_name##_open_fs(struct inode *inode, struct file *file) \
{ \
	return single_open(file, acpi_battery_read_##_name, PDE(inode)->data); \
818 819
}

820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837
DECLARE_FILE_FUNCTIONS(info);
DECLARE_FILE_FUNCTIONS(state);
DECLARE_FILE_FUNCTIONS(alarm);

#undef DECLARE_FILE_FUNCTIONS

#define FILE_DESCRIPTION_RO(_name) \
	{ \
	.name = __stringify(_name), \
	.mode = S_IRUGO, \
	.ops = { \
		.open = acpi_battery_##_name##_open_fs, \
		.read = seq_read, \
		.llseek = seq_lseek, \
		.release = single_release, \
		.owner = THIS_MODULE, \
		}, \
	}
838

839 840 841 842 843 844 845 846 847 848 849 850 851
#define FILE_DESCRIPTION_RW(_name) \
	{ \
	.name = __stringify(_name), \
	.mode = S_IFREG | S_IRUGO | S_IWUSR, \
	.ops = { \
		.open = acpi_battery_##_name##_open_fs, \
		.read = seq_read, \
		.llseek = seq_lseek, \
		.write = acpi_battery_write_##_name, \
		.release = single_release, \
		.owner = THIS_MODULE, \
		}, \
	}
L
Linus Torvalds 已提交
852

853 854 855
static struct battery_file {
	struct file_operations ops;
	mode_t mode;
J
Jan Engelhardt 已提交
856
	const char *name;
857
} acpi_battery_file[] = {
858 859 860
	FILE_DESCRIPTION_RO(info),
	FILE_DESCRIPTION_RO(state),
	FILE_DESCRIPTION_RW(alarm),
L
Linus Torvalds 已提交
861 862
};

863 864 865
#undef FILE_DESCRIPTION_RO
#undef FILE_DESCRIPTION_RW

L
Len Brown 已提交
866
static int acpi_battery_add_fs(struct acpi_device *device)
L
Linus Torvalds 已提交
867
{
L
Len Brown 已提交
868
	struct proc_dir_entry *entry = NULL;
869
	int i;
L
Linus Torvalds 已提交
870 871 872

	if (!acpi_device_dir(device)) {
		acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
L
Len Brown 已提交
873
						     acpi_battery_dir);
L
Linus Torvalds 已提交
874
		if (!acpi_device_dir(device))
875
			return -ENODEV;
L
Linus Torvalds 已提交
876 877
	}

878
	for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i) {
879 880 881 882 883
		entry = proc_create_data(acpi_battery_file[i].name,
					 acpi_battery_file[i].mode,
					 acpi_device_dir(device),
					 &acpi_battery_file[i].ops,
					 acpi_driver_data(device));
884 885
		if (!entry)
			return -ENODEV;
L
Linus Torvalds 已提交
886
	}
887
	return 0;
L
Linus Torvalds 已提交
888 889
}

890
static void acpi_battery_remove_fs(struct acpi_device *device)
L
Linus Torvalds 已提交
891
{
892
	int i;
893 894 895 896
	if (!acpi_device_dir(device))
		return;
	for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i)
		remove_proc_entry(acpi_battery_file[i].name,
L
Linus Torvalds 已提交
897 898
				  acpi_device_dir(device));

899 900
	remove_proc_entry(acpi_device_bid(device), acpi_battery_dir);
	acpi_device_dir(device) = NULL;
L
Linus Torvalds 已提交
901 902
}

903
#endif
904

L
Linus Torvalds 已提交
905 906 907 908
/* --------------------------------------------------------------------------
                                 Driver Interface
   -------------------------------------------------------------------------- */

909
static void acpi_battery_notify(struct acpi_device *device, u32 event)
L
Linus Torvalds 已提交
910
{
911
	struct acpi_battery *battery = acpi_driver_data(device);
912
	struct device *old;
913

L
Linus Torvalds 已提交
914
	if (!battery)
915
		return;
916
	old = battery->bat.dev;
917 918 919 920
	acpi_battery_update(battery);
	acpi_bus_generate_proc_event(device, event,
				     acpi_battery_present(battery));
	acpi_bus_generate_netlink_event(device->pnp.device_class,
921
					dev_name(&device->dev), event,
V
Vladimir Lebedev 已提交
922
					acpi_battery_present(battery));
J
Justin P. Mattock 已提交
923
	/* acpi_battery_update could remove power_supply object */
924
	if (old && battery->bat.dev)
925
		power_supply_changed(&battery->bat);
L
Linus Torvalds 已提交
926 927
}

L
Len Brown 已提交
928
static int acpi_battery_add(struct acpi_device *device)
L
Linus Torvalds 已提交
929
{
L
Len Brown 已提交
930 931
	int result = 0;
	struct acpi_battery *battery = NULL;
932
	acpi_handle handle;
L
Linus Torvalds 已提交
933
	if (!device)
934
		return -EINVAL;
935
	battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
L
Linus Torvalds 已提交
936
	if (!battery)
937
		return -ENOMEM;
938
	battery->device = device;
L
Linus Torvalds 已提交
939 940
	strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
	strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
941
	device->driver_data = battery;
942
	mutex_init(&battery->lock);
943 944 945
	if (ACPI_SUCCESS(acpi_get_handle(battery->device->handle,
			"_BIX", &handle)))
		set_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
946
	acpi_battery_update(battery);
947
#ifdef CONFIG_ACPI_PROCFS_POWER
L
Linus Torvalds 已提交
948
	result = acpi_battery_add_fs(device);
949
#endif
950 951 952 953 954
	if (!result) {
		printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n",
			ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device),
			device->status.battery_present ? "present" : "absent");
	} else {
955
#ifdef CONFIG_ACPI_PROCFS_POWER
L
Linus Torvalds 已提交
956
		acpi_battery_remove_fs(device);
957
#endif
L
Linus Torvalds 已提交
958 959
		kfree(battery);
	}
960
	return result;
L
Linus Torvalds 已提交
961 962
}

L
Len Brown 已提交
963
static int acpi_battery_remove(struct acpi_device *device, int type)
L
Linus Torvalds 已提交
964
{
L
Len Brown 已提交
965
	struct acpi_battery *battery = NULL;
L
Linus Torvalds 已提交
966 967

	if (!device || !acpi_driver_data(device))
968
		return -EINVAL;
969
	battery = acpi_driver_data(device);
970
#ifdef CONFIG_ACPI_PROCFS_POWER
L
Linus Torvalds 已提交
971
	acpi_battery_remove_fs(device);
972
#endif
973
	sysfs_remove_battery(battery);
974
	mutex_destroy(&battery->lock);
L
Linus Torvalds 已提交
975
	kfree(battery);
976
	return 0;
L
Linus Torvalds 已提交
977 978
}

979
/* this is needed to learn about changes made in suspended state */
980
static int acpi_battery_resume(struct acpi_device *device)
981 982 983 984
{
	struct acpi_battery *battery;
	if (!device)
		return -EINVAL;
985 986
	battery = acpi_driver_data(device);
	battery->update_time = 0;
987
	acpi_battery_update(battery);
988
	return 0;
989 990
}

991 992 993 994
static struct acpi_driver acpi_battery_driver = {
	.name = "battery",
	.class = ACPI_BATTERY_CLASS,
	.ids = battery_device_ids,
995
	.flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
996 997 998 999
	.ops = {
		.add = acpi_battery_add,
		.resume = acpi_battery_resume,
		.remove = acpi_battery_remove,
1000
		.notify = acpi_battery_notify,
1001 1002 1003
		},
};

1004
static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie)
L
Linus Torvalds 已提交
1005
{
P
Pavel Machek 已提交
1006
	if (acpi_disabled)
1007
		return;
1008
#ifdef CONFIG_ACPI_PROCFS_POWER
1009
	acpi_battery_dir = acpi_lock_battery_dir();
L
Linus Torvalds 已提交
1010
	if (!acpi_battery_dir)
1011
		return;
1012
#endif
1013
	if (acpi_bus_register_driver(&acpi_battery_driver) < 0) {
1014
#ifdef CONFIG_ACPI_PROCFS_POWER
1015
		acpi_unlock_battery_dir(acpi_battery_dir);
1016
#endif
1017
		return;
L
Linus Torvalds 已提交
1018
	}
1019 1020 1021 1022 1023 1024
	return;
}

static int __init acpi_battery_init(void)
{
	async_schedule(acpi_battery_init_async, NULL);
1025
	return 0;
L
Linus Torvalds 已提交
1026 1027
}

L
Len Brown 已提交
1028
static void __exit acpi_battery_exit(void)
L
Linus Torvalds 已提交
1029 1030
{
	acpi_bus_unregister_driver(&acpi_battery_driver);
1031
#ifdef CONFIG_ACPI_PROCFS_POWER
1032
	acpi_unlock_battery_dir(acpi_battery_dir);
1033
#endif
L
Linus Torvalds 已提交
1034 1035 1036 1037
}

module_init(acpi_battery_init);
module_exit(acpi_battery_exit);