battery.c 25.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

35
#ifdef CONFIG_ACPI_PROCFS_POWER
L
Linus Torvalds 已提交
36 37 38
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <asm/uaccess.h>
39
#endif
L
Linus Torvalds 已提交
40 41 42 43

#include <acpi/acpi_bus.h>
#include <acpi/acpi_drivers.h>

44
#ifdef CONFIG_ACPI_SYSFS_POWER
45
#include <linux/power_supply.h>
46
#endif
47

L
Linus Torvalds 已提交
48 49 50 51 52 53 54 55
#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

#define _COMPONENT		ACPI_BATTERY_COMPONENT
56

57
ACPI_MODULE_NAME("battery");
L
Linus Torvalds 已提交
58

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

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

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

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

#endif

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

86
MODULE_DEVICE_TABLE(acpi, battery_device_ids);
L
Linus Torvalds 已提交
87

88

L
Linus Torvalds 已提交
89
struct acpi_battery {
90
	struct mutex lock;
91
#ifdef CONFIG_ACPI_SYSFS_POWER
92
	struct power_supply bat;
93
#endif
94 95
	struct acpi_device *device;
	unsigned long update_time;
96
	int rate_now;
97 98
	int capacity_now;
	int voltage_now;
99
	int design_capacity;
100
	int full_charge_capacity;
101 102 103 104 105 106
	int technology;
	int design_voltage;
	int design_capacity_warning;
	int design_capacity_low;
	int capacity_granularity_1;
	int capacity_granularity_2;
107
	int alarm;
108 109 110 111
	char model_number[32];
	char serial_number[32];
	char type[32];
	char oem_info[32];
112 113
	int state;
	int power_unit;
114
	u8 alarm_present;
L
Linus Torvalds 已提交
115 116
};

117 118
#define to_acpi_battery(x) container_of(x, struct acpi_battery, bat);

119
inline int acpi_battery_present(struct acpi_battery *battery)
120
{
121 122
	return battery->device->status.battery_present;
}
123

124
#ifdef CONFIG_ACPI_SYSFS_POWER
125 126 127 128 129 130 131 132
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;
133
	if (!strncasecmp("LI-ION", battery->type, 6))
134
		return POWER_SUPPLY_TECHNOLOGY_LION;
135 136 137 138 139
	if (!strcasecmp("LiP", battery->type))
		return POWER_SUPPLY_TECHNOLOGY_LIPO;
	return POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
}

140
static int acpi_battery_get_state(struct acpi_battery *battery);
141

142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164
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;
}

165 166 167 168 169 170
static int acpi_battery_get_property(struct power_supply *psy,
				     enum power_supply_property psp,
				     union power_supply_propval *val)
{
	struct acpi_battery *battery = to_acpi_battery(psy);

171 172 173 174
	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)
175 176 177 178 179 180 181
		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;
182
		else if (acpi_battery_is_charged(battery))
183
			val->intval = POWER_SUPPLY_STATUS_FULL;
184 185
		else
			val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
186 187 188 189 190 191 192 193 194 195 196 197 198 199
		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;
	case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
		val->intval = battery->design_voltage * 1000;
		break;
	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
		val->intval = battery->voltage_now * 1000;
		break;
	case POWER_SUPPLY_PROP_CURRENT_NOW:
200 201
	case POWER_SUPPLY_PROP_POWER_NOW:
		val->intval = battery->rate_now * 1000;
202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220
		break;
	case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
	case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
		val->intval = battery->design_capacity * 1000;
		break;
	case POWER_SUPPLY_PROP_CHARGE_FULL:
	case POWER_SUPPLY_PROP_ENERGY_FULL:
		val->intval = battery->full_charge_capacity * 1000;
		break;
	case POWER_SUPPLY_PROP_CHARGE_NOW:
	case POWER_SUPPLY_PROP_ENERGY_NOW:
		val->intval = battery->capacity_now * 1000;
		break;
	case POWER_SUPPLY_PROP_MODEL_NAME:
		val->strval = battery->model_number;
		break;
	case POWER_SUPPLY_PROP_MANUFACTURER:
		val->strval = battery->oem_info;
		break;
221 222 223
	case POWER_SUPPLY_PROP_SERIAL_NUMBER:
		val->strval = battery->serial_number;
		break;
224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241
	default:
		return -EINVAL;
	}
	return 0;
}

static enum power_supply_property charge_battery_props[] = {
	POWER_SUPPLY_PROP_STATUS,
	POWER_SUPPLY_PROP_PRESENT,
	POWER_SUPPLY_PROP_TECHNOLOGY,
	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,
242
	POWER_SUPPLY_PROP_SERIAL_NUMBER,
243 244 245 246 247 248 249 250 251
};

static enum power_supply_property energy_battery_props[] = {
	POWER_SUPPLY_PROP_STATUS,
	POWER_SUPPLY_PROP_PRESENT,
	POWER_SUPPLY_PROP_TECHNOLOGY,
	POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
	POWER_SUPPLY_PROP_VOLTAGE_NOW,
	POWER_SUPPLY_PROP_CURRENT_NOW,
252
	POWER_SUPPLY_PROP_POWER_NOW,
253 254 255 256 257
	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,
258
	POWER_SUPPLY_PROP_SERIAL_NUMBER,
259
};
260
#endif
261

262
#ifdef CONFIG_ACPI_PROCFS_POWER
263
inline char *acpi_battery_units(struct acpi_battery *battery)
264
{
265
	return (battery->power_unit)?"mA":"mW";
266
}
267
#endif
268

269 270 271
/* --------------------------------------------------------------------------
                               Battery Management
   -------------------------------------------------------------------------- */
272 273 274 275
struct acpi_offsets {
	size_t offset;		/* offset inside struct acpi_sbs_battery */
	u8 mode;		/* int or string? */
};
276

277 278
static struct acpi_offsets state_offsets[] = {
	{offsetof(struct acpi_battery, state), 0},
279
	{offsetof(struct acpi_battery, rate_now), 0},
280 281
	{offsetof(struct acpi_battery, capacity_now), 0},
	{offsetof(struct acpi_battery, voltage_now), 0},
282
};
283

284 285 286
static struct acpi_offsets info_offsets[] = {
	{offsetof(struct acpi_battery, power_unit), 0},
	{offsetof(struct acpi_battery, design_capacity), 0},
287
	{offsetof(struct acpi_battery, full_charge_capacity), 0},
288 289 290 291 292 293 294 295 296 297 298
	{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},
};
299

300 301 302 303
static int extract_package(struct acpi_battery *battery,
			   union acpi_object *package,
			   struct acpi_offsets *offsets, int num)
{
304
	int i;
305 306 307 308 309 310 311 312
	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) {
313 314 315 316 317 318 319 320
			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,
					sizeof(acpi_integer));
				ptr[sizeof(acpi_integer)] = 0;
321 322
			} else
				*ptr = 0; /* don't have value */
323
		} else {
324 325 326
			int *x = (int *)((u8 *)battery + offsets[i].offset);
			*x = (element->type == ACPI_TYPE_INTEGER) ?
				element->integer.value : -1;
327
		}
328 329 330 331 332 333
	}
	return 0;
}

static int acpi_battery_get_status(struct acpi_battery *battery)
{
334
	if (acpi_bus_get_status(battery->device)) {
335 336 337
		ACPI_EXCEPTION((AE_INFO, AE_ERROR, "Evaluating _STA"));
		return -ENODEV;
	}
338
	return 0;
339 340 341
}

static int acpi_battery_get_info(struct acpi_battery *battery)
L
Linus Torvalds 已提交
342
{
343
	int result = -EFAULT;
L
Len Brown 已提交
344 345
	acpi_status status = 0;
	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
L
Linus Torvalds 已提交
346

347 348
	if (!acpi_battery_present(battery))
		return 0;
349
	mutex_lock(&battery->lock);
350
	status = acpi_evaluate_object(battery->device->handle, "_BIF",
351 352
				      NULL, &buffer);
	mutex_unlock(&battery->lock);
353

L
Linus Torvalds 已提交
354
	if (ACPI_FAILURE(status)) {
355
		ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BIF"));
356
		return -ENODEV;
L
Linus Torvalds 已提交
357
	}
358

359 360
	result = extract_package(battery, buffer.pointer,
				 info_offsets, ARRAY_SIZE(info_offsets));
361
	kfree(buffer.pointer);
362
	return result;
L
Linus Torvalds 已提交
363 364
}

365
static int acpi_battery_get_state(struct acpi_battery *battery)
L
Linus Torvalds 已提交
366
{
L
Len Brown 已提交
367 368 369
	int result = 0;
	acpi_status status = 0;
	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
L
Linus Torvalds 已提交
370

371 372
	if (!acpi_battery_present(battery))
		return 0;
L
Linus Torvalds 已提交
373

374 375 376 377 378
	if (battery->update_time &&
	    time_before(jiffies, battery->update_time +
			msecs_to_jiffies(cache_time)))
		return 0;

379
	mutex_lock(&battery->lock);
380
	status = acpi_evaluate_object(battery->device->handle, "_BST",
381 382
				      NULL, &buffer);
	mutex_unlock(&battery->lock);
383

L
Linus Torvalds 已提交
384
	if (ACPI_FAILURE(status)) {
385
		ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST"));
386
		return -ENODEV;
L
Linus Torvalds 已提交
387
	}
388

389 390
	result = extract_package(battery, buffer.pointer,
				 state_offsets, ARRAY_SIZE(state_offsets));
391
	battery->update_time = jiffies;
392
	kfree(buffer.pointer);
393 394
	return result;
}
L
Linus Torvalds 已提交
395

396
static int acpi_battery_set_alarm(struct acpi_battery *battery)
L
Linus Torvalds 已提交
397
{
L
Len Brown 已提交
398
	acpi_status status = 0;
399
	union acpi_object arg0 = { .type = ACPI_TYPE_INTEGER };
L
Len Brown 已提交
400
	struct acpi_object_list arg_list = { 1, &arg0 };
L
Linus Torvalds 已提交
401

402
	if (!acpi_battery_present(battery)|| !battery->alarm_present)
403
		return -ENODEV;
L
Linus Torvalds 已提交
404

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

407
	mutex_lock(&battery->lock);
408 409
	status = acpi_evaluate_object(battery->device->handle, "_BTP",
				 &arg_list, NULL);
410
	mutex_unlock(&battery->lock);
411

L
Linus Torvalds 已提交
412
	if (ACPI_FAILURE(status))
413
		return -ENODEV;
L
Linus Torvalds 已提交
414

415
	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", battery->alarm));
416
	return 0;
L
Linus Torvalds 已提交
417 418
}

419
static int acpi_battery_init_alarm(struct acpi_battery *battery)
L
Linus Torvalds 已提交
420
{
L
Len Brown 已提交
421 422 423
	acpi_status status = AE_OK;
	acpi_handle handle = NULL;

424
	/* See if alarms are supported, and if so, set default */
425 426
	status = acpi_get_handle(battery->device->handle, "_BTP", &handle);
	if (ACPI_FAILURE(status)) {
427
		battery->alarm_present = 0;
428
		return 0;
429
	}
430 431 432
	battery->alarm_present = 1;
	if (!battery->alarm)
		battery->alarm = battery->design_capacity_warning;
433
	return acpi_battery_set_alarm(battery);
434
}
L
Linus Torvalds 已提交
435

436
#ifdef CONFIG_ACPI_SYSFS_POWER
437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458
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 = {
459
	.attr = {.name = "alarm", .mode = 0644},
460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493
	.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);
494
	battery->bat.dev = NULL;
495
}
496
#endif
497

498
static int acpi_battery_update(struct acpi_battery *battery)
499
{
500
	int result, old_present = acpi_battery_present(battery);
501
	result = acpi_battery_get_status(battery);
502
	if (result)
503
		return result;
504
#ifdef CONFIG_ACPI_SYSFS_POWER
505 506
	if (!acpi_battery_present(battery)) {
		sysfs_remove_battery(battery);
507
		battery->update_time = 0;
508
		return 0;
509
	}
510
#endif
511 512
	if (!battery->update_time ||
	    old_present != acpi_battery_present(battery)) {
513 514 515 516 517 518
		result = acpi_battery_get_info(battery);
		if (result)
			return result;
		acpi_battery_init_alarm(battery);
	}
#ifdef CONFIG_ACPI_SYSFS_POWER
519 520
	if (!battery->bat.dev)
		sysfs_add_battery(battery);
521
#endif
522
	return acpi_battery_get_state(battery);
523 524
}

L
Linus Torvalds 已提交
525 526 527 528
/* --------------------------------------------------------------------------
                              FS Interface (/proc)
   -------------------------------------------------------------------------- */

529
#ifdef CONFIG_ACPI_PROCFS_POWER
L
Len Brown 已提交
530
static struct proc_dir_entry *acpi_battery_dir;
531

532
static int acpi_battery_print_info(struct seq_file *seq, int result)
L
Linus Torvalds 已提交
533
{
534
	struct acpi_battery *battery = seq->private;
L
Linus Torvalds 已提交
535

536
	if (result)
L
Linus Torvalds 已提交
537 538
		goto end;

539 540 541
	seq_printf(seq, "present:                 %s\n",
		   acpi_battery_present(battery)?"yes":"no");
	if (!acpi_battery_present(battery))
L
Linus Torvalds 已提交
542
		goto end;
543
	if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
L
Linus Torvalds 已提交
544 545 546
		seq_printf(seq, "design capacity:         unknown\n");
	else
		seq_printf(seq, "design capacity:         %d %sh\n",
547 548
			   battery->design_capacity,
			   acpi_battery_units(battery));
L
Linus Torvalds 已提交
549

550
	if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
L
Linus Torvalds 已提交
551 552 553
		seq_printf(seq, "last full capacity:      unknown\n");
	else
		seq_printf(seq, "last full capacity:      %d %sh\n",
554
			   battery->full_charge_capacity,
555 556 557 558
			   acpi_battery_units(battery));

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

560
	if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
L
Linus Torvalds 已提交
561 562 563
		seq_printf(seq, "design voltage:          unknown\n");
	else
		seq_printf(seq, "design voltage:          %d mV\n",
564
			   battery->design_voltage);
L
Linus Torvalds 已提交
565
	seq_printf(seq, "design capacity warning: %d %sh\n",
566 567
		   battery->design_capacity_warning,
		   acpi_battery_units(battery));
L
Linus Torvalds 已提交
568
	seq_printf(seq, "design capacity low:     %d %sh\n",
569 570
		   battery->design_capacity_low,
		   acpi_battery_units(battery));
L
Linus Torvalds 已提交
571
	seq_printf(seq, "capacity granularity 1:  %d %sh\n",
572 573
		   battery->capacity_granularity_1,
		   acpi_battery_units(battery));
L
Linus Torvalds 已提交
574
	seq_printf(seq, "capacity granularity 2:  %d %sh\n",
575 576
		   battery->capacity_granularity_2,
		   acpi_battery_units(battery));
577 578 579 580
	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 已提交
581
      end:
582 583 584 585 586
	if (result)
		seq_printf(seq, "ERROR: Unable to read battery info\n");
	return result;
}

587
static int acpi_battery_print_state(struct seq_file *seq, int result)
L
Linus Torvalds 已提交
588
{
589
	struct acpi_battery *battery = seq->private;
L
Linus Torvalds 已提交
590

591
	if (result)
L
Linus Torvalds 已提交
592 593
		goto end;

594 595 596
	seq_printf(seq, "present:                 %s\n",
		   acpi_battery_present(battery)?"yes":"no");
	if (!acpi_battery_present(battery))
L
Linus Torvalds 已提交
597
		goto end;
598

599 600 601
	seq_printf(seq, "capacity state:          %s\n",
			(battery->state & 0x04)?"critical":"ok");
	if ((battery->state & 0x01) && (battery->state & 0x02))
L
Len Brown 已提交
602 603
		seq_printf(seq,
			   "charging state:          charging/discharging\n");
604
	else if (battery->state & 0x01)
L
Linus Torvalds 已提交
605
		seq_printf(seq, "charging state:          discharging\n");
606
	else if (battery->state & 0x02)
L
Linus Torvalds 已提交
607
		seq_printf(seq, "charging state:          charging\n");
608
	else
L
Linus Torvalds 已提交
609 610
		seq_printf(seq, "charging state:          charged\n");

611
	if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
L
Linus Torvalds 已提交
612 613 614
		seq_printf(seq, "present rate:            unknown\n");
	else
		seq_printf(seq, "present rate:            %d %s\n",
615
			   battery->rate_now, acpi_battery_units(battery));
L
Linus Torvalds 已提交
616

617
	if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
L
Linus Torvalds 已提交
618 619 620
		seq_printf(seq, "remaining capacity:      unknown\n");
	else
		seq_printf(seq, "remaining capacity:      %d %sh\n",
621 622
			   battery->capacity_now, acpi_battery_units(battery));
	if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
L
Linus Torvalds 已提交
623 624 625
		seq_printf(seq, "present voltage:         unknown\n");
	else
		seq_printf(seq, "present voltage:         %d mV\n",
626
			   battery->voltage_now);
L
Len Brown 已提交
627
      end:
628
	if (result)
629 630 631 632 633
		seq_printf(seq, "ERROR: Unable to read battery state\n");

	return result;
}

634
static int acpi_battery_print_alarm(struct seq_file *seq, int result)
L
Linus Torvalds 已提交
635
{
636
	struct acpi_battery *battery = seq->private;
L
Linus Torvalds 已提交
637

638
	if (result)
L
Linus Torvalds 已提交
639 640
		goto end;

641
	if (!acpi_battery_present(battery)) {
L
Linus Torvalds 已提交
642 643 644 645 646 647 648
		seq_printf(seq, "present:                 no\n");
		goto end;
	}
	seq_printf(seq, "alarm:                   ");
	if (!battery->alarm)
		seq_printf(seq, "unsupported\n");
	else
649 650
		seq_printf(seq, "%u %sh\n", battery->alarm,
				acpi_battery_units(battery));
L
Len Brown 已提交
651
      end:
652 653 654 655 656
	if (result)
		seq_printf(seq, "ERROR: Unable to read battery alarm\n");
	return result;
}

657 658 659
static ssize_t acpi_battery_write_alarm(struct file *file,
					const char __user * buffer,
					size_t count, loff_t * ppos)
L
Linus Torvalds 已提交
660
{
L
Len Brown 已提交
661 662
	int result = 0;
	char alarm_string[12] = { '\0' };
663 664
	struct seq_file *m = file->private_data;
	struct acpi_battery *battery = m->private;
L
Linus Torvalds 已提交
665 666

	if (!battery || (count > sizeof(alarm_string) - 1))
667
		return -EINVAL;
668 669 670 671 672 673 674 675
	if (!acpi_battery_present(battery)) {
		result = -ENODEV;
		goto end;
	}
	if (copy_from_user(alarm_string, buffer, count)) {
		result = -EFAULT;
		goto end;
	}
L
Linus Torvalds 已提交
676
	alarm_string[count] = '\0';
677
	battery->alarm = simple_strtol(alarm_string, NULL, 0);
678
	result = acpi_battery_set_alarm(battery);
679 680
      end:
	if (!result)
681
		return count;
682 683 684 685
	return result;
}

typedef int(*print_func)(struct seq_file *seq, int result);
686 687 688 689 690

static print_func acpi_print_funcs[ACPI_BATTERY_NUMFILES] = {
	acpi_battery_print_info,
	acpi_battery_print_state,
	acpi_battery_print_alarm,
691
};
692

693 694 695
static int acpi_battery_read(int fid, struct seq_file *seq)
{
	struct acpi_battery *battery = seq->private;
696
	int result = acpi_battery_update(battery);
697
	return acpi_print_funcs[fid](seq, result);
698 699
}

700 701 702 703 704 705 706 707
#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); \
708 709
}

710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727
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, \
		}, \
	}
728

729 730 731 732 733 734 735 736 737 738 739 740 741
#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 已提交
742

743 744 745
static struct battery_file {
	struct file_operations ops;
	mode_t mode;
J
Jan Engelhardt 已提交
746
	const char *name;
747
} acpi_battery_file[] = {
748 749 750
	FILE_DESCRIPTION_RO(info),
	FILE_DESCRIPTION_RO(state),
	FILE_DESCRIPTION_RW(alarm),
L
Linus Torvalds 已提交
751 752
};

753 754 755
#undef FILE_DESCRIPTION_RO
#undef FILE_DESCRIPTION_RW

L
Len Brown 已提交
756
static int acpi_battery_add_fs(struct acpi_device *device)
L
Linus Torvalds 已提交
757
{
L
Len Brown 已提交
758
	struct proc_dir_entry *entry = NULL;
759
	int i;
L
Linus Torvalds 已提交
760 761 762

	if (!acpi_device_dir(device)) {
		acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
L
Len Brown 已提交
763
						     acpi_battery_dir);
L
Linus Torvalds 已提交
764
		if (!acpi_device_dir(device))
765
			return -ENODEV;
L
Linus Torvalds 已提交
766 767
	}

768
	for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i) {
769 770 771 772 773
		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));
774 775
		if (!entry)
			return -ENODEV;
L
Linus Torvalds 已提交
776
	}
777
	return 0;
L
Linus Torvalds 已提交
778 779
}

780
static void acpi_battery_remove_fs(struct acpi_device *device)
L
Linus Torvalds 已提交
781
{
782
	int i;
783 784 785 786
	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 已提交
787 788
				  acpi_device_dir(device));

789 790
	remove_proc_entry(acpi_device_bid(device), acpi_battery_dir);
	acpi_device_dir(device) = NULL;
L
Linus Torvalds 已提交
791 792
}

793
#endif
794

L
Linus Torvalds 已提交
795 796 797 798
/* --------------------------------------------------------------------------
                                 Driver Interface
   -------------------------------------------------------------------------- */

L
Len Brown 已提交
799
static void acpi_battery_notify(acpi_handle handle, u32 event, void *data)
L
Linus Torvalds 已提交
800
{
801
	struct acpi_battery *battery = data;
802
	struct acpi_device *device;
L
Linus Torvalds 已提交
803
	if (!battery)
804
		return;
805
	device = battery->device;
806 807 808 809
	acpi_battery_update(battery);
	acpi_bus_generate_proc_event(device, event,
				     acpi_battery_present(battery));
	acpi_bus_generate_netlink_event(device->pnp.device_class,
810
					dev_name(&device->dev), event,
V
Vladimir Lebedev 已提交
811
					acpi_battery_present(battery));
812
#ifdef CONFIG_ACPI_SYSFS_POWER
813 814 815
	/* acpi_batter_update could remove power_supply object */
	if (battery->bat.dev)
		kobject_uevent(&battery->bat.dev->kobj, KOBJ_CHANGE);
816
#endif
L
Linus Torvalds 已提交
817 818
}

L
Len Brown 已提交
819
static int acpi_battery_add(struct acpi_device *device)
L
Linus Torvalds 已提交
820
{
L
Len Brown 已提交
821 822 823
	int result = 0;
	acpi_status status = 0;
	struct acpi_battery *battery = NULL;
L
Linus Torvalds 已提交
824
	if (!device)
825
		return -EINVAL;
826
	battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
L
Linus Torvalds 已提交
827
	if (!battery)
828
		return -ENOMEM;
829
	battery->device = device;
L
Linus Torvalds 已提交
830 831
	strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
	strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
832
	device->driver_data = battery;
833
	mutex_init(&battery->lock);
834
	acpi_battery_update(battery);
835
#ifdef CONFIG_ACPI_PROCFS_POWER
L
Linus Torvalds 已提交
836 837 838
	result = acpi_battery_add_fs(device);
	if (result)
		goto end;
839
#endif
840
	status = acpi_install_notify_handler(device->handle,
841
					     ACPI_ALL_NOTIFY,
L
Len Brown 已提交
842
					     acpi_battery_notify, battery);
L
Linus Torvalds 已提交
843
	if (ACPI_FAILURE(status)) {
844
		ACPI_EXCEPTION((AE_INFO, status, "Installing notify handler"));
L
Linus Torvalds 已提交
845 846 847 848
		result = -ENODEV;
		goto end;
	}
	printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n",
L
Len Brown 已提交
849 850 851
	       ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device),
	       device->status.battery_present ? "present" : "absent");
      end:
L
Linus Torvalds 已提交
852
	if (result) {
853
#ifdef CONFIG_ACPI_PROCFS_POWER
L
Linus Torvalds 已提交
854
		acpi_battery_remove_fs(device);
855
#endif
L
Linus Torvalds 已提交
856 857
		kfree(battery);
	}
858
	return result;
L
Linus Torvalds 已提交
859 860
}

L
Len Brown 已提交
861
static int acpi_battery_remove(struct acpi_device *device, int type)
L
Linus Torvalds 已提交
862
{
L
Len Brown 已提交
863 864
	acpi_status status = 0;
	struct acpi_battery *battery = NULL;
L
Linus Torvalds 已提交
865 866

	if (!device || !acpi_driver_data(device))
867
		return -EINVAL;
868
	battery = acpi_driver_data(device);
869
	status = acpi_remove_notify_handler(device->handle,
870
					    ACPI_ALL_NOTIFY,
L
Len Brown 已提交
871
					    acpi_battery_notify);
872
#ifdef CONFIG_ACPI_PROCFS_POWER
L
Linus Torvalds 已提交
873
	acpi_battery_remove_fs(device);
874
#endif
875
#ifdef CONFIG_ACPI_SYSFS_POWER
876
	sysfs_remove_battery(battery);
877
#endif
878
	mutex_destroy(&battery->lock);
L
Linus Torvalds 已提交
879
	kfree(battery);
880
	return 0;
L
Linus Torvalds 已提交
881 882
}

883
/* this is needed to learn about changes made in suspended state */
884
static int acpi_battery_resume(struct acpi_device *device)
885 886 887 888
{
	struct acpi_battery *battery;
	if (!device)
		return -EINVAL;
889 890
	battery = acpi_driver_data(device);
	battery->update_time = 0;
891
	acpi_battery_update(battery);
892
	return 0;
893 894
}

895 896 897 898 899 900 901 902 903 904 905
static struct acpi_driver acpi_battery_driver = {
	.name = "battery",
	.class = ACPI_BATTERY_CLASS,
	.ids = battery_device_ids,
	.ops = {
		.add = acpi_battery_add,
		.resume = acpi_battery_resume,
		.remove = acpi_battery_remove,
		},
};

906
static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie)
L
Linus Torvalds 已提交
907
{
P
Pavel Machek 已提交
908
	if (acpi_disabled)
909
		return;
910
#ifdef CONFIG_ACPI_PROCFS_POWER
911
	acpi_battery_dir = acpi_lock_battery_dir();
L
Linus Torvalds 已提交
912
	if (!acpi_battery_dir)
913
		return;
914
#endif
915
	if (acpi_bus_register_driver(&acpi_battery_driver) < 0) {
916
#ifdef CONFIG_ACPI_PROCFS_POWER
917
		acpi_unlock_battery_dir(acpi_battery_dir);
918
#endif
919
		return;
L
Linus Torvalds 已提交
920
	}
921 922 923 924 925 926
	return;
}

static int __init acpi_battery_init(void)
{
	async_schedule(acpi_battery_init_async, NULL);
927
	return 0;
L
Linus Torvalds 已提交
928 929
}

L
Len Brown 已提交
930
static void __exit acpi_battery_exit(void)
L
Linus Torvalds 已提交
931 932
{
	acpi_bus_unregister_driver(&acpi_battery_driver);
933
#ifdef CONFIG_ACPI_PROCFS_POWER
934
	acpi_unlock_battery_dir(acpi_battery_dir);
935
#endif
L
Linus Torvalds 已提交
936 937 938 939
}

module_init(acpi_battery_init);
module_exit(acpi_battery_exit);