sbs.c 26.5 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 24 25 26 27 28 29 30
 *  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.
 *
 *  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/init.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/kernel.h>
31

32 33 34
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <asm/uaccess.h>
35

36
#include <linux/acpi.h>
37
#include <linux/timer.h>
38
#include <linux/jiffies.h>
39 40
#include <linux/delay.h>

41 42
#include <linux/power_supply.h>

43 44
#include "sbshc.h"

45 46 47 48 49 50 51 52 53 54
#define ACPI_SBS_CLASS			"sbs"
#define ACPI_AC_CLASS			"ac_adapter"
#define ACPI_BATTERY_CLASS		"battery"
#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"

55 56 57 58 59 60 61 62
enum acpi_sbs_device_addr {
	ACPI_SBS_CHARGER = 0x9,
	ACPI_SBS_MANAGER = 0xa,
	ACPI_SBS_BATTERY = 0xb,
};

#define ACPI_SBS_NOTIFY_STATUS		0x80
#define ACPI_SBS_NOTIFY_INFO		0x81
63

64
MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>");
65 66 67
MODULE_DESCRIPTION("Smart Battery System ACPI interface driver");
MODULE_LICENSE("GPL");

68 69 70
static unsigned int cache_time = 1000;
module_param(cache_time, uint, 0644);
MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
71 72 73 74 75 76

extern struct proc_dir_entry *acpi_lock_ac_dir(void);
extern struct proc_dir_entry *acpi_lock_battery_dir(void);
extern void acpi_unlock_ac_dir(struct proc_dir_entry *acpi_ac_dir);
extern void acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir);

77
#define MAX_SBS_BAT			4
78 79
#define ACPI_SBS_BLOCK_MAX		32

80
static const struct acpi_device_id sbs_device_ids[] = {
81
	{"ACPI0002", 0},
82 83 84 85
	{"", 0},
};
MODULE_DEVICE_TABLE(acpi, sbs_device_ids);

86
struct acpi_battery {
87
	struct power_supply bat;
88
	struct acpi_sbs *sbs;
89
	struct proc_dir_entry *proc_entry;
90 91
	unsigned long update_time;
	char name[8];
92 93 94
	char manufacturer_name[ACPI_SBS_BLOCK_MAX];
	char device_name[ACPI_SBS_BLOCK_MAX];
	char device_chemistry[ACPI_SBS_BLOCK_MAX];
95
	u16 alarm_capacity;
96 97 98 99
	u16 full_charge_capacity;
	u16 design_capacity;
	u16 design_voltage;
	u16 serial_number;
100 101
	u16 cycle_count;
	u16 temp_now;
102 103
	u16 voltage_now;
	s16 current_now;
104
	s16 current_avg;
105
	u16 capacity_now;
106
	u16 state_of_charge;
107 108
	u16 state;
	u16 mode;
109
	u16 spec;
110 111
	u8 id;
	u8 present:1;
112 113
};

114 115
#define to_acpi_battery(x) container_of(x, struct acpi_battery, bat);

116
struct acpi_sbs {
117
	struct power_supply charger;
118
	struct acpi_device *device;
119
	struct acpi_smb_hc *hc;
120 121
	struct mutex lock;
	struct proc_dir_entry *charger_entry;
122
	struct acpi_battery battery[MAX_SBS_BAT];
123
	u8 batteries_supported:4;
124 125
	u8 manager_present:1;
	u8 charger_present:1;
126 127
};

128 129
#define to_acpi_sbs(x) container_of(x, struct acpi_sbs, charger)

130
static inline int battery_scale(int log)
131
{
132 133 134 135
	int scale = 1;
	while (log--)
		scale *= 10;
	return scale;
136 137
}

138
static inline int acpi_battery_vscale(struct acpi_battery *battery)
139
{
140
	return battery_scale((battery->spec & 0x0f00) >> 8);
141 142
}

143
static inline int acpi_battery_ipscale(struct acpi_battery *battery)
144
{
145
	return battery_scale((battery->spec & 0xf000) >> 12);
146 147
}

148
static inline int acpi_battery_mode(struct acpi_battery *battery)
149
{
150
	return (battery->mode & 0x8000);
151
}
152

153
static inline int acpi_battery_scale(struct acpi_battery *battery)
154
{
155 156
	return (acpi_battery_mode(battery) ? 10 : 1) *
	    acpi_battery_ipscale(battery);
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 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 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 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296
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;
	switch (psp) {
	case POWER_SUPPLY_PROP_STATUS:
		if (battery->current_now < 0)
			val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
		else if (battery->current_now > 0)
			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;
	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:
		val->intval = abs(battery->current_now) *
				acpi_battery_ipscale(battery) * 1000;
		break;
	case POWER_SUPPLY_PROP_CURRENT_AVG:
		val->intval = abs(battery->current_avg) *
				acpi_battery_ipscale(battery) * 1000;
		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,
	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,
	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,
};

297 298 299
/* --------------------------------------------------------------------------
                            Smart Battery System Management
   -------------------------------------------------------------------------- */
300

301 302 303 304 305
struct acpi_battery_reader {
	u8 command;		/* command for battery */
	u8 mode;		/* word or block? */
	size_t offset;		/* offset inside struct acpi_sbs_battery */
};
306

307 308 309 310 311 312 313 314 315 316 317 318 319
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)},
};
320

321 322 323 324 325 326 327 328 329
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)},
	{0x0a, SMBUS_READ_WORD, offsetof(struct acpi_battery, current_now)},
	{0x0b, SMBUS_READ_WORD, offsetof(struct acpi_battery, current_avg)},
	{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)},
};
330

331
static int acpi_manager_get_info(struct acpi_sbs *sbs)
332 333
{
	int result = 0;
334
	u16 battery_system_info;
335

336
	result = acpi_smbus_read(sbs->hc, SMBUS_READ_WORD, ACPI_SBS_MANAGER,
337
				 0x04, (u8 *)&battery_system_info);
338 339
	if (!result)
		sbs->batteries_supported = battery_system_info & 0x000f;
340
	return result;
341 342 343 344
}

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

347
	for (i = 0; i < ARRAY_SIZE(info_readers); ++i) {
348 349 350 351 352 353
		result = acpi_smbus_read(battery->sbs->hc,
					 info_readers[i].mode,
					 ACPI_SBS_BATTERY,
					 info_readers[i].command,
					 (u8 *) battery +
						info_readers[i].offset);
354 355
		if (result)
			break;
356
	}
357
	return result;
358 359 360 361
}

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

364 365
	if (battery->update_time &&
	    time_before(jiffies, battery->update_time +
366 367 368 369 370 371 372 373 374 375
				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)
376 377 378
			goto end;
	}
      end:
379
	battery->update_time = jiffies;
380
	return result;
381 382
}

383
static int acpi_battery_get_alarm(struct acpi_battery *battery)
384
{
385 386
	return acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD,
				 ACPI_SBS_BATTERY, 0x01,
387
				 (u8 *)&battery->alarm_capacity);
388 389
}

390
static int acpi_battery_set_alarm(struct acpi_battery *battery)
391
{
392
	struct acpi_sbs *sbs = battery->sbs;
393 394 395 396
	u16 value, sel = 1 << (battery->id + 12);

	int ret;

397

398
	if (sbs->manager_present) {
399
		ret = acpi_smbus_read(sbs->hc, SMBUS_READ_WORD, ACPI_SBS_MANAGER,
400
				0x01, (u8 *)&value);
401 402 403 404 405 406 407 408 409 410 411
		if (ret)
			goto end;
		if ((value & 0xf000) != sel) {
			value &= 0x0fff;
			value |= sel;
		ret = acpi_smbus_write(sbs->hc, SMBUS_WRITE_WORD,
					 ACPI_SBS_MANAGER,
					 0x01, (u8 *)&value, 2);
		if (ret)
			goto end;
		}
412
	}
413 414 415 416
	ret = acpi_smbus_write(sbs->hc, SMBUS_WRITE_WORD, ACPI_SBS_BATTERY,
				0x01, (u8 *)&battery->alarm_capacity, 2);
      end:
	return ret;
417 418 419 420
}

static int acpi_ac_get_present(struct acpi_sbs *sbs)
{
421 422
	int result;
	u16 status;
423

424 425 426 427
	result = acpi_smbus_read(sbs->hc, SMBUS_READ_WORD, ACPI_SBS_CHARGER,
				 0x13, (u8 *) & status);
	if (!result)
		sbs->charger_present = (status >> 15) & 0x1;
428
	return result;
429 430 431 432 433 434 435 436
}

/* --------------------------------------------------------------------------
                              FS Interface (/proc/acpi)
   -------------------------------------------------------------------------- */

/* Generic Routines */
static int
437
acpi_sbs_add_fs(struct proc_dir_entry **dir,
438 439 440 441 442
		struct proc_dir_entry *parent_dir,
		char *dir_name,
		struct file_operations *info_fops,
		struct file_operations *state_fops,
		struct file_operations *alarm_fops, void *data)
443 444 445 446 447 448
{
	struct proc_dir_entry *entry = NULL;

	if (!*dir) {
		*dir = proc_mkdir(dir_name, parent_dir);
		if (!*dir) {
449
			return -ENODEV;
450 451 452 453 454 455 456
		}
		(*dir)->owner = THIS_MODULE;
	}

	/* 'info' [R] */
	if (info_fops) {
		entry = create_proc_entry(ACPI_SBS_FILE_INFO, S_IRUGO, *dir);
457
		if (entry) {
458 459 460 461 462 463 464 465 466
			entry->proc_fops = info_fops;
			entry->data = data;
			entry->owner = THIS_MODULE;
		}
	}

	/* 'state' [R] */
	if (state_fops) {
		entry = create_proc_entry(ACPI_SBS_FILE_STATE, S_IRUGO, *dir);
467
		if (entry) {
468 469 470 471 472 473 474 475 476
			entry->proc_fops = state_fops;
			entry->data = data;
			entry->owner = THIS_MODULE;
		}
	}

	/* 'alarm' [R/W] */
	if (alarm_fops) {
		entry = create_proc_entry(ACPI_SBS_FILE_ALARM, S_IRUGO, *dir);
477
		if (entry) {
478 479 480 481 482
			entry->proc_fops = alarm_fops;
			entry->data = data;
			entry->owner = THIS_MODULE;
		}
	}
483
	return 0;
484 485 486
}

static void
487
acpi_sbs_remove_fs(struct proc_dir_entry **dir,
488 489 490 491 492 493 494 495 496 497 498 499 500 501
			   struct proc_dir_entry *parent_dir)
{
	if (*dir) {
		remove_proc_entry(ACPI_SBS_FILE_INFO, *dir);
		remove_proc_entry(ACPI_SBS_FILE_STATE, *dir);
		remove_proc_entry(ACPI_SBS_FILE_ALARM, *dir);
		remove_proc_entry((*dir)->name, parent_dir);
		*dir = NULL;
	}
}

/* Smart Battery Interface */
static struct proc_dir_entry *acpi_battery_dir = NULL;

502 503 504 505 506 507
static inline char *acpi_battery_units(struct acpi_battery *battery)
{
	return acpi_battery_mode(battery) ? " mWh" : " mAh";
}


508 509
static int acpi_battery_read_info(struct seq_file *seq, void *offset)
{
510
	struct acpi_battery *battery = seq->private;
511
	struct acpi_sbs *sbs = battery->sbs;
512 513
	int result = 0;

514
	mutex_lock(&sbs->lock);
515

516 517 518
	seq_printf(seq, "present:                 %s\n",
		   (battery->present) ? "yes" : "no");
	if (!battery->present)
519
		goto end;
520

521
	seq_printf(seq, "design capacity:         %i%s\n",
522 523
		   battery->design_capacity * acpi_battery_scale(battery),
		   acpi_battery_units(battery));
524
	seq_printf(seq, "last full capacity:      %i%s\n",
525 526
		   battery->full_charge_capacity * acpi_battery_scale(battery),
		   acpi_battery_units(battery));
527 528
	seq_printf(seq, "battery technology:      rechargeable\n");
	seq_printf(seq, "design voltage:          %i mV\n",
529
		   battery->design_voltage * acpi_battery_vscale(battery));
530 531 532 533
	seq_printf(seq, "design capacity warning: unknown\n");
	seq_printf(seq, "design capacity low:     unknown\n");
	seq_printf(seq, "capacity granularity 1:  unknown\n");
	seq_printf(seq, "capacity granularity 2:  unknown\n");
534
	seq_printf(seq, "model number:            %s\n", battery->device_name);
535
	seq_printf(seq, "serial number:           %i\n",
536
		   battery->serial_number);
537
	seq_printf(seq, "battery type:            %s\n",
538
		   battery->device_chemistry);
539
	seq_printf(seq, "OEM info:                %s\n",
540
		   battery->manufacturer_name);
541
      end:
542
	mutex_unlock(&sbs->lock);
543
	return result;
544 545 546 547 548 549 550 551 552
}

static int acpi_battery_info_open_fs(struct inode *inode, struct file *file)
{
	return single_open(file, acpi_battery_read_info, PDE(inode)->data);
}

static int acpi_battery_read_state(struct seq_file *seq, void *offset)
{
553 554
	struct acpi_battery *battery = seq->private;
	struct acpi_sbs *sbs = battery->sbs;
555 556
	int result = 0;

557 558 559 560
	mutex_lock(&sbs->lock);
	seq_printf(seq, "present:                 %s\n",
		   (battery->present) ? "yes" : "no");
	if (!battery->present)
561 562
		goto end;

563 564 565 566 567 568 569 570
	acpi_battery_get_state(battery);
	seq_printf(seq, "capacity state:          %s\n",
		   (battery->state & 0x0010) ? "critical" : "ok");
	seq_printf(seq, "charging state:          %s\n",
		   (battery->current_now < 0) ? "discharging" :
		   ((battery->current_now > 0) ? "charging" : "charged"));
	seq_printf(seq, "present rate:            %d mA\n",
		   abs(battery->current_now) * acpi_battery_ipscale(battery));
571
	seq_printf(seq, "remaining capacity:      %i%s\n",
572 573
		   battery->capacity_now * acpi_battery_scale(battery),
		   acpi_battery_units(battery));
574
	seq_printf(seq, "present voltage:         %i mV\n",
575
		   battery->voltage_now * acpi_battery_vscale(battery));
576 577

      end:
578
	mutex_unlock(&sbs->lock);
579
	return result;
580 581 582 583 584 585 586 587 588
}

static int acpi_battery_state_open_fs(struct inode *inode, struct file *file)
{
	return single_open(file, acpi_battery_read_state, PDE(inode)->data);
}

static int acpi_battery_read_alarm(struct seq_file *seq, void *offset)
{
589
	struct acpi_battery *battery = seq->private;
590
	struct acpi_sbs *sbs = battery->sbs;
591 592
	int result = 0;

593
	mutex_lock(&sbs->lock);
594

595
	if (!battery->present) {
596 597 598 599
		seq_printf(seq, "present:                 no\n");
		goto end;
	}

600
	acpi_battery_get_alarm(battery);
601
	seq_printf(seq, "alarm:                   ");
602
	if (battery->alarm_capacity)
603
		seq_printf(seq, "%i%s\n",
604 605 606 607
			   battery->alarm_capacity *
			   acpi_battery_scale(battery),
			   acpi_battery_units(battery));
	else
608 609
		seq_printf(seq, "disabled\n");
      end:
610
	mutex_unlock(&sbs->lock);
611
	return result;
612 613 614 615 616 617
}

static ssize_t
acpi_battery_write_alarm(struct file *file, const char __user * buffer,
			 size_t count, loff_t * ppos)
{
618 619
	struct seq_file *seq = file->private_data;
	struct acpi_battery *battery = seq->private;
620
	struct acpi_sbs *sbs = battery->sbs;
621
	char alarm_string[12] = { '\0' };
622 623
	int result = 0;
	mutex_lock(&sbs->lock);
624
	if (!battery->present) {
625 626 627 628 629 630 631 632 633 634 635 636
		result = -ENODEV;
		goto end;
	}
	if (count > sizeof(alarm_string) - 1) {
		result = -EINVAL;
		goto end;
	}
	if (copy_from_user(alarm_string, buffer, count)) {
		result = -EFAULT;
		goto end;
	}
	alarm_string[count] = 0;
637 638
	battery->alarm_capacity = simple_strtoul(alarm_string, NULL, 0) /
					acpi_battery_scale(battery);
639
	acpi_battery_set_alarm(battery);
640
      end:
641 642
	mutex_unlock(&sbs->lock);
	if (result)
643
		return result;
644
	return count;
645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683
}

static int acpi_battery_alarm_open_fs(struct inode *inode, struct file *file)
{
	return single_open(file, acpi_battery_read_alarm, PDE(inode)->data);
}

static struct file_operations acpi_battery_info_fops = {
	.open = acpi_battery_info_open_fs,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
	.owner = THIS_MODULE,
};

static struct file_operations acpi_battery_state_fops = {
	.open = acpi_battery_state_open_fs,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
	.owner = THIS_MODULE,
};

static struct file_operations acpi_battery_alarm_fops = {
	.open = acpi_battery_alarm_open_fs,
	.read = seq_read,
	.write = acpi_battery_write_alarm,
	.llseek = seq_lseek,
	.release = single_release,
	.owner = THIS_MODULE,
};

/* Legacy AC Adapter Interface */

static struct proc_dir_entry *acpi_ac_dir = NULL;

static int acpi_ac_read_state(struct seq_file *seq, void *offset)
{

684
	struct acpi_sbs *sbs = seq->private;
685

686
	mutex_lock(&sbs->lock);
687 688

	seq_printf(seq, "state:                   %s\n",
689
		   sbs->charger_present ? "on-line" : "off-line");
690

691
	mutex_unlock(&sbs->lock);
692
	return 0;
693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710
}

static int acpi_ac_state_open_fs(struct inode *inode, struct file *file)
{
	return single_open(file, acpi_ac_read_state, PDE(inode)->data);
}

static struct file_operations acpi_ac_state_fops = {
	.open = acpi_ac_state_open_fs,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
	.owner = THIS_MODULE,
};

/* --------------------------------------------------------------------------
                                 Driver Interface
   -------------------------------------------------------------------------- */
711
static int acpi_battery_read(struct acpi_battery *battery)
712
{
713 714
	int result = 0, saved_present = battery->present;
	u16 state;
715

716 717 718 719 720 721 722 723 724 725 726 727 728
	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;
	if (result || !battery->present)
		return result;
729

730 731 732 733 734 735 736 737 738
	if (saved_present != battery->present) {
		battery->update_time = 0;
		result = acpi_battery_get_info(battery);
		if (result)
			return result;
	}
	result = acpi_battery_get_state(battery);
	return result;
}
739

740
/* Smart Battery */
741 742 743
static int acpi_battery_add(struct acpi_sbs *sbs, int id)
{
	struct acpi_battery *battery = &sbs->battery[id];
744 745
	int result;

746 747
	battery->id = id;
	battery->sbs = sbs;
748 749 750
	result = acpi_battery_read(battery);
	if (result)
		return result;
751

752 753 754 755 756
	sprintf(battery->name, ACPI_BATTERY_DIR_NAME, id);
	acpi_sbs_add_fs(&battery->proc_entry, acpi_battery_dir,
			battery->name, &acpi_battery_info_fops,
			&acpi_battery_state_fops, &acpi_battery_alarm_fops,
			battery);
757 758 759 760 761 762 763 764 765 766 767 768 769
	battery->bat.name = battery->name;
	battery->bat.type = POWER_SUPPLY_TYPE_BATTERY;
	if (!acpi_battery_mode(battery)) {
		battery->bat.properties = sbs_charge_battery_props;
		battery->bat.num_properties =
		    ARRAY_SIZE(sbs_charge_battery_props);
	} else {
		battery->bat.properties = sbs_energy_battery_props;
		battery->bat.num_properties =
		    ARRAY_SIZE(sbs_energy_battery_props);
	}
	battery->bat.get_property = acpi_sbs_battery_get_property;
	result = power_supply_register(&sbs->device->dev, &battery->bat);
770
	printk(KERN_INFO PREFIX "%s [%s]: Battery Slot [%s] (battery %s)\n",
771 772
	       ACPI_SBS_DEVICE_NAME, acpi_device_bid(sbs->device),
	       battery->name, sbs->battery->present ? "present" : "absent");
773
	return result;
774 775 776 777
}

static void acpi_battery_remove(struct acpi_sbs *sbs, int id)
{
778 779
	if (sbs->battery[id].bat.dev)
		power_supply_unregister(&sbs->battery[id].bat);
780
	if (sbs->battery[id].proc_entry) {
781 782
		acpi_sbs_remove_fs(&(sbs->battery[id].proc_entry),
				   acpi_battery_dir);
783 784 785
	}
}

786
static int acpi_charger_add(struct acpi_sbs *sbs)
787 788 789 790
{
	int result;

	result = acpi_ac_get_present(sbs);
791
	if (result)
792
		goto end;
793 794 795 796
	result = acpi_sbs_add_fs(&sbs->charger_entry, acpi_ac_dir,
				 ACPI_AC_DIR_NAME, NULL,
				 &acpi_ac_state_fops, NULL, sbs);
	if (result)
797
		goto end;
798 799 800 801 802 803
	sbs->charger.name = "sbs-charger";
	sbs->charger.type = POWER_SUPPLY_TYPE_MAINS;
	sbs->charger.properties = sbs_ac_props;
	sbs->charger.num_properties = ARRAY_SIZE(sbs_ac_props);
	sbs->charger.get_property = sbs_get_ac_property;
	power_supply_register(&sbs->device->dev, &sbs->charger);
804 805
	printk(KERN_INFO PREFIX "%s [%s]: AC Adapter [%s] (%s)\n",
	       ACPI_SBS_DEVICE_NAME, acpi_device_bid(sbs->device),
806
	       ACPI_AC_DIR_NAME, sbs->charger_present ? "on-line" : "off-line");
807
      end:
808
	return result;
809 810
}

811
static void acpi_charger_remove(struct acpi_sbs *sbs)
812
{
813 814
	if (sbs->charger.dev)
		power_supply_unregister(&sbs->charger);
815 816
	if (sbs->charger_entry)
		acpi_sbs_remove_fs(&sbs->charger_entry, acpi_ac_dir);
817 818
}

819
void acpi_sbs_callback(void *context)
820
{
821 822 823 824 825 826 827
	int id;
	struct acpi_sbs *sbs = context;
	struct acpi_battery *bat;
	u8 saved_charger_state = sbs->charger_present;
	u8 saved_battery_state;
	acpi_ac_get_present(sbs);
	if (sbs->charger_present != saved_charger_state) {
828
#ifdef CONFIG_ACPI_PROC_EVENT
829 830 831
		acpi_bus_generate_proc_event4(ACPI_AC_CLASS, ACPI_AC_DIR_NAME,
					      ACPI_SBS_NOTIFY_STATUS,
					      sbs->charger_present);
832 833
#endif
		kobject_uevent(&sbs->charger.dev->kobj, KOBJ_CHANGE);
834
	}
835 836 837 838 839 840 841 842 843
	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;
844
#ifdef CONFIG_ACPI_PROC_EVENT
845 846 847 848
			acpi_bus_generate_proc_event4(ACPI_BATTERY_CLASS,
						      bat->name,
						      ACPI_SBS_NOTIFY_STATUS,
						      bat->present);
849 850
#endif
			kobject_uevent(&bat->bat.dev->kobj, KOBJ_CHANGE);
851 852 853 854
		}
	}
}

855
static int acpi_sbs_remove(struct acpi_device *device, int type);
856 857 858

static int acpi_sbs_add(struct acpi_device *device)
{
859 860
	struct acpi_sbs *sbs;
	int result = 0;
861
	int id;
862

863
	sbs = kzalloc(sizeof(struct acpi_sbs), GFP_KERNEL);
864
	if (!sbs) {
865 866
		result = -ENOMEM;
		goto end;
867 868
	}

869
	mutex_init(&sbs->lock);
870

871
	sbs->hc = acpi_driver_data(device->parent);
872
	sbs->device = device;
873 874 875 876
	strcpy(acpi_device_name(device), ACPI_SBS_DEVICE_NAME);
	strcpy(acpi_device_class(device), ACPI_SBS_CLASS);
	acpi_driver_data(device) = sbs;

877
	result = acpi_charger_add(sbs);
878 879
	if (result)
		goto end;
880

881 882 883 884 885 886 887 888 889
	result = acpi_manager_get_info(sbs);
	if (!result) {
		sbs->manager_present = 1;
		for (id = 0; id < MAX_SBS_BAT; ++id)
			if ((sbs->batteries_supported & (1 << id)))
				acpi_battery_add(sbs, id);
	} else
		acpi_battery_add(sbs, 0);
	acpi_smbus_register_callback(sbs->hc, acpi_sbs_callback, sbs);
890
      end:
891 892
	if (result)
		acpi_sbs_remove(device, 0);
893
	return result;
894 895
}

896
static int acpi_sbs_remove(struct acpi_device *device, int type)
897
{
L
Len Brown 已提交
898
	struct acpi_sbs *sbs;
899 900
	int id;

901
	if (!device)
902
		return -EINVAL;
903
	sbs = acpi_driver_data(device);
904
	if (!sbs)
905
		return -EINVAL;
906 907 908
	mutex_lock(&sbs->lock);
	acpi_smbus_unregister_callback(sbs->hc);
	for (id = 0; id < MAX_SBS_BAT; ++id)
909
		acpi_battery_remove(sbs, id);
910 911 912
	acpi_charger_remove(sbs);
	mutex_unlock(&sbs->lock);
	mutex_destroy(&sbs->lock);
913
	kfree(sbs);
914
	return 0;
915 916
}

917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934
static void acpi_sbs_rmdirs(void)
{
	if (acpi_ac_dir) {
		acpi_unlock_ac_dir(acpi_ac_dir);
		acpi_ac_dir = NULL;
	}
	if (acpi_battery_dir) {
		acpi_unlock_battery_dir(acpi_battery_dir);
		acpi_battery_dir = NULL;
	}
}

static int acpi_sbs_resume(struct acpi_device *device)
{
	struct acpi_sbs *sbs;
	if (!device)
		return -EINVAL;
	sbs = device->driver_data;
935
	acpi_sbs_callback(sbs);
936 937 938
	return 0;
}

939 940 941 942 943 944 945 946 947 948 949
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,
		.resume = acpi_sbs_resume,
		},
};

950 951 952 953
static int __init acpi_sbs_init(void)
{
	int result = 0;

954 955
	if (acpi_disabled)
		return -ENODEV;
956
	acpi_ac_dir = acpi_lock_ac_dir();
957
	if (!acpi_ac_dir)
958
		return -ENODEV;
959 960
	acpi_battery_dir = acpi_lock_battery_dir();
	if (!acpi_battery_dir) {
961
		acpi_sbs_rmdirs();
962
		return -ENODEV;
963 964 965
	}
	result = acpi_bus_register_driver(&acpi_sbs_driver);
	if (result < 0) {
966
		acpi_sbs_rmdirs();
967
		return -ENODEV;
968
	}
969
	return 0;
970 971 972 973 974
}

static void __exit acpi_sbs_exit(void)
{
	acpi_bus_unregister_driver(&acpi_sbs_driver);
975
	acpi_sbs_rmdirs();
976
	return;
977 978 979 980
}

module_init(acpi_sbs_init);
module_exit(acpi_sbs_exit);
新手
引导
客服 返回
顶部