sbs.c 19.9 KB
Newer Older
1
/*
2
 *  sbs.c - ACPI Smart Battery System Driver ($Revision: 2.0 $)
3
 *
4 5
 *  Copyright (c) 2007 Alexey Starikovskiy <astarikovskiy@suse.de>
 *  Copyright (c) 2005-2007 Vladimir Lebedev <vladimir.p.lebedev@intel.com>
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
 *  Copyright (c) 2005 Rich Townsend <rhdt@bartol.udel.edu>
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *
 *  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.
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 */

#include <linux/init.h>
24
#include <linux/slab.h>
25 26 27
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/kernel.h>
28

29
#include <linux/acpi.h>
30
#include <linux/timer.h>
31
#include <linux/jiffies.h>
32
#include <linux/delay.h>
33
#include <linux/power_supply.h>
34
#include <linux/platform_data/x86/apple.h>
35
#include <acpi/battery.h>
36

37 38
#include "sbshc.h"

39 40
#define PREFIX "ACPI: "

41 42 43 44 45 46 47 48 49
#define ACPI_SBS_CLASS			"sbs"
#define ACPI_AC_CLASS			"ac_adapter"
#define ACPI_SBS_DEVICE_NAME		"Smart Battery System"
#define ACPI_SBS_FILE_INFO		"info"
#define ACPI_SBS_FILE_STATE		"state"
#define ACPI_SBS_FILE_ALARM		"alarm"
#define ACPI_BATTERY_DIR_NAME		"BAT%i"
#define ACPI_AC_DIR_NAME		"AC0"

50 51
#define ACPI_SBS_NOTIFY_STATUS		0x80
#define ACPI_SBS_NOTIFY_INFO		0x81
52

53
MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>");
54 55 56
MODULE_DESCRIPTION("Smart Battery System ACPI interface driver");
MODULE_LICENSE("GPL");

57 58 59
static unsigned int cache_time = 1000;
module_param(cache_time, uint, 0644);
MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
60

61
#define MAX_SBS_BAT			4
62 63
#define ACPI_SBS_BLOCK_MAX		32

64
static const struct acpi_device_id sbs_device_ids[] = {
65
	{"ACPI0002", 0},
66 67 68 69
	{"", 0},
};
MODULE_DEVICE_TABLE(acpi, sbs_device_ids);

70
struct acpi_battery {
71 72
	struct power_supply *bat;
	struct power_supply_desc bat_desc;
73
	struct acpi_sbs *sbs;
74 75
	unsigned long update_time;
	char name[8];
76 77 78
	char manufacturer_name[ACPI_SBS_BLOCK_MAX];
	char device_name[ACPI_SBS_BLOCK_MAX];
	char device_chemistry[ACPI_SBS_BLOCK_MAX];
79
	u16 alarm_capacity;
80 81 82 83
	u16 full_charge_capacity;
	u16 design_capacity;
	u16 design_voltage;
	u16 serial_number;
84 85
	u16 cycle_count;
	u16 temp_now;
86
	u16 voltage_now;
87 88
	s16 rate_now;
	s16 rate_avg;
89
	u16 capacity_now;
90
	u16 state_of_charge;
91 92
	u16 state;
	u16 mode;
93
	u16 spec;
94 95
	u8 id;
	u8 present:1;
J
Jeff Garzik 已提交
96
	u8 have_sysfs_alarm:1;
97 98
};

99
#define to_acpi_battery(x) power_supply_get_drvdata(x)
100

101
struct acpi_sbs {
102
	struct power_supply *charger;
103
	struct acpi_device *device;
104
	struct acpi_smb_hc *hc;
105
	struct mutex lock;
106
	struct acpi_battery battery[MAX_SBS_BAT];
107
	u8 batteries_supported:4;
108 109
	u8 manager_present:1;
	u8 charger_present:1;
110
	u8 charger_exists:1;
111 112
};

113
#define to_acpi_sbs(x) power_supply_get_drvdata(x)
114

115
static int acpi_sbs_remove(struct acpi_device *device);
116 117
static int acpi_battery_get_state(struct acpi_battery *battery);

118
static inline int battery_scale(int log)
119
{
120 121 122 123
	int scale = 1;
	while (log--)
		scale *= 10;
	return scale;
124 125
}

126
static inline int acpi_battery_vscale(struct acpi_battery *battery)
127
{
128
	return battery_scale((battery->spec & 0x0f00) >> 8);
129 130
}

131
static inline int acpi_battery_ipscale(struct acpi_battery *battery)
132
{
133
	return battery_scale((battery->spec & 0xf000) >> 12);
134 135
}

136
static inline int acpi_battery_mode(struct acpi_battery *battery)
137
{
138
	return (battery->mode & 0x8000);
139
}
140

141
static inline int acpi_battery_scale(struct acpi_battery *battery)
142
{
143 144
	return (acpi_battery_mode(battery) ? 10 : 1) *
	    acpi_battery_ipscale(battery);
145 146
}

147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182
static int sbs_get_ac_property(struct power_supply *psy,
			       enum power_supply_property psp,
			       union power_supply_propval *val)
{
	struct acpi_sbs *sbs = to_acpi_sbs(psy);
	switch (psp) {
	case POWER_SUPPLY_PROP_ONLINE:
		val->intval = sbs->charger_present;
		break;
	default:
		return -EINVAL;
	}
	return 0;
}

static int acpi_battery_technology(struct acpi_battery *battery)
{
	if (!strcasecmp("NiCd", battery->device_chemistry))
		return POWER_SUPPLY_TECHNOLOGY_NiCd;
	if (!strcasecmp("NiMH", battery->device_chemistry))
		return POWER_SUPPLY_TECHNOLOGY_NiMH;
	if (!strcasecmp("LION", battery->device_chemistry))
		return POWER_SUPPLY_TECHNOLOGY_LION;
	if (!strcasecmp("LiP", battery->device_chemistry))
		return POWER_SUPPLY_TECHNOLOGY_LIPO;
	return POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
}

static int acpi_sbs_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);

	if ((!battery->present) && psp != POWER_SUPPLY_PROP_PRESENT)
		return -ENODEV;
183 184

	acpi_battery_get_state(battery);
185 186
	switch (psp) {
	case POWER_SUPPLY_PROP_STATUS:
187
		if (battery->rate_now < 0)
188
			val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
189
		else if (battery->rate_now > 0)
190 191 192 193 194 195 196 197 198 199
			val->intval = POWER_SUPPLY_STATUS_CHARGING;
		else
			val->intval = POWER_SUPPLY_STATUS_FULL;
		break;
	case POWER_SUPPLY_PROP_PRESENT:
		val->intval = battery->present;
		break;
	case POWER_SUPPLY_PROP_TECHNOLOGY:
		val->intval = acpi_battery_technology(battery);
		break;
200 201 202
	case POWER_SUPPLY_PROP_CYCLE_COUNT:
		val->intval = battery->cycle_count;
		break;
203 204 205 206 207 208 209 210 211
	case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
		val->intval = battery->design_voltage *
			acpi_battery_vscale(battery) * 1000;
		break;
	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
		val->intval = battery->voltage_now *
				acpi_battery_vscale(battery) * 1000;
		break;
	case POWER_SUPPLY_PROP_CURRENT_NOW:
212 213
	case POWER_SUPPLY_PROP_POWER_NOW:
		val->intval = abs(battery->rate_now) *
214
				acpi_battery_ipscale(battery) * 1000;
215 216 217
		val->intval *= (acpi_battery_mode(battery)) ?
				(battery->voltage_now *
				acpi_battery_vscale(battery) / 1000) : 1;
218 219
		break;
	case POWER_SUPPLY_PROP_CURRENT_AVG:
220 221
	case POWER_SUPPLY_PROP_POWER_AVG:
		val->intval = abs(battery->rate_avg) *
222
				acpi_battery_ipscale(battery) * 1000;
223 224 225
		val->intval *= (acpi_battery_mode(battery)) ?
				(battery->voltage_now *
				acpi_battery_vscale(battery) / 1000) : 1;
226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267
		break;
	case POWER_SUPPLY_PROP_CAPACITY:
		val->intval = battery->state_of_charge;
		break;
	case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
	case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
		val->intval = battery->design_capacity *
			acpi_battery_scale(battery) * 1000;
		break;
	case POWER_SUPPLY_PROP_CHARGE_FULL:
	case POWER_SUPPLY_PROP_ENERGY_FULL:
		val->intval = battery->full_charge_capacity *
			acpi_battery_scale(battery) * 1000;
		break;
	case POWER_SUPPLY_PROP_CHARGE_NOW:
	case POWER_SUPPLY_PROP_ENERGY_NOW:
		val->intval = battery->capacity_now *
				acpi_battery_scale(battery) * 1000;
		break;
	case POWER_SUPPLY_PROP_TEMP:
		val->intval = battery->temp_now - 2730;	// dK -> dC
		break;
	case POWER_SUPPLY_PROP_MODEL_NAME:
		val->strval = battery->device_name;
		break;
	case POWER_SUPPLY_PROP_MANUFACTURER:
		val->strval = battery->manufacturer_name;
		break;
	default:
		return -EINVAL;
	}
	return 0;
}

static enum power_supply_property sbs_ac_props[] = {
	POWER_SUPPLY_PROP_ONLINE,
};

static enum power_supply_property sbs_charge_battery_props[] = {
	POWER_SUPPLY_PROP_STATUS,
	POWER_SUPPLY_PROP_PRESENT,
	POWER_SUPPLY_PROP_TECHNOLOGY,
268
	POWER_SUPPLY_PROP_CYCLE_COUNT,
269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289
	POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
	POWER_SUPPLY_PROP_VOLTAGE_NOW,
	POWER_SUPPLY_PROP_CURRENT_NOW,
	POWER_SUPPLY_PROP_CURRENT_AVG,
	POWER_SUPPLY_PROP_CAPACITY,
	POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
	POWER_SUPPLY_PROP_CHARGE_FULL,
	POWER_SUPPLY_PROP_CHARGE_NOW,
	POWER_SUPPLY_PROP_TEMP,
	POWER_SUPPLY_PROP_MODEL_NAME,
	POWER_SUPPLY_PROP_MANUFACTURER,
};

static enum power_supply_property sbs_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,
	POWER_SUPPLY_PROP_CURRENT_AVG,
290 291
	POWER_SUPPLY_PROP_POWER_NOW,
	POWER_SUPPLY_PROP_POWER_AVG,
292 293 294 295 296 297 298 299
	POWER_SUPPLY_PROP_CAPACITY,
	POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
	POWER_SUPPLY_PROP_ENERGY_FULL,
	POWER_SUPPLY_PROP_ENERGY_NOW,
	POWER_SUPPLY_PROP_TEMP,
	POWER_SUPPLY_PROP_MODEL_NAME,
	POWER_SUPPLY_PROP_MANUFACTURER,
};
300

301 302 303 304 305 306 307
static const struct power_supply_desc acpi_sbs_charger_desc = {
	.name		= "sbs-charger",
	.type		= POWER_SUPPLY_TYPE_MAINS,
	.properties	= sbs_ac_props,
	.num_properties	= ARRAY_SIZE(sbs_ac_props),
	.get_property	= sbs_get_ac_property,
};
308

309 310 311
/* --------------------------------------------------------------------------
                            Smart Battery System Management
   -------------------------------------------------------------------------- */
312

313 314 315 316 317
struct acpi_battery_reader {
	u8 command;		/* command for battery */
	u8 mode;		/* word or block? */
	size_t offset;		/* offset inside struct acpi_sbs_battery */
};
318

319 320 321 322 323 324 325 326 327 328 329 330 331
static struct acpi_battery_reader info_readers[] = {
	{0x01, SMBUS_READ_WORD, offsetof(struct acpi_battery, alarm_capacity)},
	{0x03, SMBUS_READ_WORD, offsetof(struct acpi_battery, mode)},
	{0x10, SMBUS_READ_WORD, offsetof(struct acpi_battery, full_charge_capacity)},
	{0x17, SMBUS_READ_WORD, offsetof(struct acpi_battery, cycle_count)},
	{0x18, SMBUS_READ_WORD, offsetof(struct acpi_battery, design_capacity)},
	{0x19, SMBUS_READ_WORD, offsetof(struct acpi_battery, design_voltage)},
	{0x1a, SMBUS_READ_WORD, offsetof(struct acpi_battery, spec)},
	{0x1c, SMBUS_READ_WORD, offsetof(struct acpi_battery, serial_number)},
	{0x20, SMBUS_READ_BLOCK, offsetof(struct acpi_battery, manufacturer_name)},
	{0x21, SMBUS_READ_BLOCK, offsetof(struct acpi_battery, device_name)},
	{0x22, SMBUS_READ_BLOCK, offsetof(struct acpi_battery, device_chemistry)},
};
332

333 334 335
static struct acpi_battery_reader state_readers[] = {
	{0x08, SMBUS_READ_WORD, offsetof(struct acpi_battery, temp_now)},
	{0x09, SMBUS_READ_WORD, offsetof(struct acpi_battery, voltage_now)},
336 337
	{0x0a, SMBUS_READ_WORD, offsetof(struct acpi_battery, rate_now)},
	{0x0b, SMBUS_READ_WORD, offsetof(struct acpi_battery, rate_avg)},
338 339 340 341
	{0x0f, SMBUS_READ_WORD, offsetof(struct acpi_battery, capacity_now)},
	{0x0e, SMBUS_READ_WORD, offsetof(struct acpi_battery, state_of_charge)},
	{0x16, SMBUS_READ_WORD, offsetof(struct acpi_battery, state)},
};
342

343
static int acpi_manager_get_info(struct acpi_sbs *sbs)
344 345
{
	int result = 0;
346
	u16 battery_system_info;
347

348
	result = acpi_smbus_read(sbs->hc, SMBUS_READ_WORD, ACPI_SBS_MANAGER,
349
				 0x04, (u8 *)&battery_system_info);
350 351
	if (!result)
		sbs->batteries_supported = battery_system_info & 0x000f;
352
	return result;
353 354 355 356
}

static int acpi_battery_get_info(struct acpi_battery *battery)
{
357
	int i, result = 0;
358

359
	for (i = 0; i < ARRAY_SIZE(info_readers); ++i) {
360 361 362 363 364 365
		result = acpi_smbus_read(battery->sbs->hc,
					 info_readers[i].mode,
					 ACPI_SBS_BATTERY,
					 info_readers[i].command,
					 (u8 *) battery +
						info_readers[i].offset);
366 367
		if (result)
			break;
368
	}
369
	return result;
370 371 372 373
}

static int acpi_battery_get_state(struct acpi_battery *battery)
{
374
	int i, result = 0;
375

376 377
	if (battery->update_time &&
	    time_before(jiffies, battery->update_time +
378 379 380 381 382 383 384 385 386 387
				msecs_to_jiffies(cache_time)))
		return 0;
	for (i = 0; i < ARRAY_SIZE(state_readers); ++i) {
		result = acpi_smbus_read(battery->sbs->hc,
					 state_readers[i].mode,
					 ACPI_SBS_BATTERY,
					 state_readers[i].command,
				         (u8 *)battery +
						state_readers[i].offset);
		if (result)
388 389 390
			goto end;
	}
      end:
391
	battery->update_time = jiffies;
392
	return result;
393 394
}

395
static int acpi_battery_get_alarm(struct acpi_battery *battery)
396
{
397 398
	return acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD,
				 ACPI_SBS_BATTERY, 0x01,
399
				 (u8 *)&battery->alarm_capacity);
400 401
}

402
static int acpi_battery_set_alarm(struct acpi_battery *battery)
403
{
404
	struct acpi_sbs *sbs = battery->sbs;
405 406 407 408
	u16 value, sel = 1 << (battery->id + 12);

	int ret;

409

410
	if (sbs->manager_present) {
411
		ret = acpi_smbus_read(sbs->hc, SMBUS_READ_WORD, ACPI_SBS_MANAGER,
412
				0x01, (u8 *)&value);
413 414 415 416 417
		if (ret)
			goto end;
		if ((value & 0xf000) != sel) {
			value &= 0x0fff;
			value |= sel;
418
			ret = acpi_smbus_write(sbs->hc, SMBUS_WRITE_WORD,
419 420
					 ACPI_SBS_MANAGER,
					 0x01, (u8 *)&value, 2);
421 422
			if (ret)
				goto end;
423
		}
424
	}
425 426 427 428
	ret = acpi_smbus_write(sbs->hc, SMBUS_WRITE_WORD, ACPI_SBS_BATTERY,
				0x01, (u8 *)&battery->alarm_capacity, 2);
      end:
	return ret;
429 430 431 432
}

static int acpi_ac_get_present(struct acpi_sbs *sbs)
{
433 434
	int result;
	u16 status;
435

436 437
	result = acpi_smbus_read(sbs->hc, SMBUS_READ_WORD, ACPI_SBS_CHARGER,
				 0x13, (u8 *) & status);
438 439 440 441 442 443 444 445

	if (result)
		return result;

	/*
	 * The spec requires that bit 4 always be 1. If it's not set, assume
	 * that the implementation doesn't support an SBS charger
	 */
446
	if (!((status >> 4) & 0x1))
447 448 449 450
		return -ENODEV;

	sbs->charger_present = (status >> 15) & 0x1;
	return 0;
451 452
}

A
Alexey Starikovskiy 已提交
453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468
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));
	acpi_battery_get_alarm(battery);
	return sprintf(buf, "%d\n", battery->alarm_capacity *
				acpi_battery_scale(battery) * 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));
469
	if (sscanf(buf, "%lu\n", &x) == 1)
A
Alexey Starikovskiy 已提交
470 471 472 473 474 475 476
		battery->alarm_capacity = x /
			(1000 * acpi_battery_scale(battery));
	if (battery->present)
		acpi_battery_set_alarm(battery);
	return count;
}

477
static const struct device_attribute alarm_attr = {
478
	.attr = {.name = "alarm", .mode = 0644},
A
Alexey Starikovskiy 已提交
479 480 481 482
	.show = acpi_battery_alarm_show,
	.store = acpi_battery_alarm_store,
};

483 484 485
/* --------------------------------------------------------------------------
                                 Driver Interface
   -------------------------------------------------------------------------- */
486
static int acpi_battery_read(struct acpi_battery *battery)
487
{
488 489
	int result = 0, saved_present = battery->present;
	u16 state;
490

491 492 493 494 495 496 497 498 499 500 501
	if (battery->sbs->manager_present) {
		result = acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD,
				ACPI_SBS_MANAGER, 0x01, (u8 *)&state);
		if (!result)
			battery->present = state & (1 << battery->id);
		state &= 0x0fff;
		state |= 1 << (battery->id + 12);
		acpi_smbus_write(battery->sbs->hc, SMBUS_WRITE_WORD,
				  ACPI_SBS_MANAGER, 0x01, (u8 *)&state, 2);
	} else if (battery->id == 0)
		battery->present = 1;
502

503 504
	if (result || !battery->present)
		return result;
505

506 507 508
	if (saved_present != battery->present) {
		battery->update_time = 0;
		result = acpi_battery_get_info(battery);
509 510
		if (result) {
			battery->present = 0;
511
			return result;
512
		}
513 514
	}
	result = acpi_battery_get_state(battery);
515 516
	if (result)
		battery->present = 0;
517 518
	return result;
}
519

520
/* Smart Battery */
521 522 523
static int acpi_battery_add(struct acpi_sbs *sbs, int id)
{
	struct acpi_battery *battery = &sbs->battery[id];
524
	struct power_supply_config psy_cfg = { .drv_data = battery, };
525 526
	int result;

527 528
	battery->id = id;
	battery->sbs = sbs;
529 530 531
	result = acpi_battery_read(battery);
	if (result)
		return result;
532

533
	sprintf(battery->name, ACPI_BATTERY_DIR_NAME, id);
534 535
	battery->bat_desc.name = battery->name;
	battery->bat_desc.type = POWER_SUPPLY_TYPE_BATTERY;
536
	if (!acpi_battery_mode(battery)) {
537 538
		battery->bat_desc.properties = sbs_charge_battery_props;
		battery->bat_desc.num_properties =
539 540
		    ARRAY_SIZE(sbs_charge_battery_props);
	} else {
541 542
		battery->bat_desc.properties = sbs_energy_battery_props;
		battery->bat_desc.num_properties =
543 544
		    ARRAY_SIZE(sbs_energy_battery_props);
	}
545 546 547 548 549 550
	battery->bat_desc.get_property = acpi_sbs_battery_get_property;
	battery->bat = power_supply_register(&sbs->device->dev,
					&battery->bat_desc, &psy_cfg);
	if (IS_ERR(battery->bat)) {
		result = PTR_ERR(battery->bat);
		battery->bat = NULL;
J
Jeff Garzik 已提交
551
		goto end;
552
	}
553

554
	result = device_create_file(&battery->bat->dev, &alarm_attr);
J
Jeff Garzik 已提交
555 556 557 558
	if (result)
		goto end;
	battery->have_sysfs_alarm = 1;
      end:
559
	printk(KERN_INFO PREFIX "%s [%s]: Battery Slot [%s] (battery %s)\n",
560
	       ACPI_SBS_DEVICE_NAME, acpi_device_bid(sbs->device),
561
	       battery->name, battery->present ? "present" : "absent");
562
	return result;
563 564 565 566
}

static void acpi_battery_remove(struct acpi_sbs *sbs, int id)
{
J
Jeff Garzik 已提交
567
	struct acpi_battery *battery = &sbs->battery[id];
568

569
	if (battery->bat) {
J
Jeff Garzik 已提交
570
		if (battery->have_sysfs_alarm)
571 572
			device_remove_file(&battery->bat->dev, &alarm_attr);
		power_supply_unregister(battery->bat);
573 574 575
	}
}

576
static int acpi_charger_add(struct acpi_sbs *sbs)
577 578
{
	int result;
579
	struct power_supply_config psy_cfg = { .drv_data = sbs, };
580 581

	result = acpi_ac_get_present(sbs);
582
	if (result)
583
		goto end;
584

585
	sbs->charger_exists = 1;
586 587 588 589 590 591
	sbs->charger = power_supply_register(&sbs->device->dev,
					&acpi_sbs_charger_desc, &psy_cfg);
	if (IS_ERR(sbs->charger)) {
		result = PTR_ERR(sbs->charger);
		sbs->charger = NULL;
	}
592 593
	printk(KERN_INFO PREFIX "%s [%s]: AC Adapter [%s] (%s)\n",
	       ACPI_SBS_DEVICE_NAME, acpi_device_bid(sbs->device),
594
	       ACPI_AC_DIR_NAME, sbs->charger_present ? "on-line" : "off-line");
595
      end:
596
	return result;
597 598
}

599
static void acpi_charger_remove(struct acpi_sbs *sbs)
600
{
601 602
	if (sbs->charger)
		power_supply_unregister(sbs->charger);
603 604
}

A
Adrian Bunk 已提交
605
static void acpi_sbs_callback(void *context)
606
{
607 608 609 610 611
	int id;
	struct acpi_sbs *sbs = context;
	struct acpi_battery *bat;
	u8 saved_charger_state = sbs->charger_present;
	u8 saved_battery_state;
612 613 614 615

	if (sbs->charger_exists) {
		acpi_ac_get_present(sbs);
		if (sbs->charger_present != saved_charger_state)
616
			kobject_uevent(&sbs->charger->dev.kobj, KOBJ_CHANGE);
617
	}
618

619 620 621 622 623 624 625 626 627
	if (sbs->manager_present) {
		for (id = 0; id < MAX_SBS_BAT; ++id) {
			if (!(sbs->batteries_supported & (1 << id)))
				continue;
			bat = &sbs->battery[id];
			saved_battery_state = bat->present;
			acpi_battery_read(bat);
			if (saved_battery_state == bat->present)
				continue;
628
			kobject_uevent(&bat->bat->dev.kobj, KOBJ_CHANGE);
629 630 631 632 633 634
		}
	}
}

static int acpi_sbs_add(struct acpi_device *device)
{
635 636
	struct acpi_sbs *sbs;
	int result = 0;
637
	int id;
638

639
	sbs = kzalloc(sizeof(struct acpi_sbs), GFP_KERNEL);
640
	if (!sbs) {
641 642
		result = -ENOMEM;
		goto end;
643 644
	}

645
	mutex_init(&sbs->lock);
646

647
	sbs->hc = acpi_driver_data(device->parent);
648
	sbs->device = device;
649 650
	strcpy(acpi_device_name(device), ACPI_SBS_DEVICE_NAME);
	strcpy(acpi_device_class(device), ACPI_SBS_CLASS);
651
	device->driver_data = sbs;
652

653
	result = acpi_charger_add(sbs);
654
	if (result && result != -ENODEV)
655
		goto end;
656

657 658
	result = 0;

659
	if (!x86_apple_machine) {
660 661
		result = acpi_manager_get_info(sbs);
		if (!result) {
662
			sbs->manager_present = 1;
663 664 665 666 667 668 669
			for (id = 0; id < MAX_SBS_BAT; ++id)
				if ((sbs->batteries_supported & (1 << id)))
					acpi_battery_add(sbs, id);
		}
	}

	if (!sbs->manager_present)
670
		acpi_battery_add(sbs, 0);
671

672
	acpi_smbus_register_callback(sbs->hc, acpi_sbs_callback, sbs);
673
      end:
674
	if (result)
675
		acpi_sbs_remove(device);
676
	return result;
677 678
}

679
static int acpi_sbs_remove(struct acpi_device *device)
680
{
L
Len Brown 已提交
681
	struct acpi_sbs *sbs;
682 683
	int id;

684
	if (!device)
685
		return -EINVAL;
686
	sbs = acpi_driver_data(device);
687
	if (!sbs)
688
		return -EINVAL;
689 690 691
	mutex_lock(&sbs->lock);
	acpi_smbus_unregister_callback(sbs->hc);
	for (id = 0; id < MAX_SBS_BAT; ++id)
692
		acpi_battery_remove(sbs, id);
693 694 695
	acpi_charger_remove(sbs);
	mutex_unlock(&sbs->lock);
	mutex_destroy(&sbs->lock);
696
	kfree(sbs);
697
	return 0;
698 699
}

700
#ifdef CONFIG_PM_SLEEP
701
static int acpi_sbs_resume(struct device *dev)
702 703
{
	struct acpi_sbs *sbs;
704
	if (!dev)
705
		return -EINVAL;
706
	sbs = to_acpi_device(dev)->driver_data;
707
	acpi_sbs_callback(sbs);
708 709
	return 0;
}
710 711
#else
#define acpi_sbs_resume NULL
712
#endif
713

714 715
static SIMPLE_DEV_PM_OPS(acpi_sbs_pm, NULL, acpi_sbs_resume);

716 717 718 719 720 721 722 723
static struct acpi_driver acpi_sbs_driver = {
	.name = "sbs",
	.class = ACPI_SBS_CLASS,
	.ids = sbs_device_ids,
	.ops = {
		.add = acpi_sbs_add,
		.remove = acpi_sbs_remove,
		},
724
	.drv.pm = &acpi_sbs_pm,
725 726
};

727 728 729 730
static int __init acpi_sbs_init(void)
{
	int result = 0;

731 732
	if (acpi_disabled)
		return -ENODEV;
733

734
	result = acpi_bus_register_driver(&acpi_sbs_driver);
735
	if (result < 0)
736
		return -ENODEV;
737

738
	return 0;
739 740 741 742 743
}

static void __exit acpi_sbs_exit(void)
{
	acpi_bus_unregister_driver(&acpi_sbs_driver);
744
	return;
745 746 747 748
}

module_init(acpi_sbs_init);
module_exit(acpi_sbs_exit);