Release 4.14 drivers/acpi/battery.c

/*
 *  battery.c - ACPI Battery Driver (Revision: 2.0)
 *
 *  Copyright (C) 2007 Alexey Starikovskiy <astarikovskiy@suse.de>
 *  Copyright (C) 2004-2007 Vladimir Lebedev <vladimir.p.lebedev@intel.com>
 *  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.
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/jiffies.h>
#include <linux/async.h>
#include <linux/dmi.h>
#include <linux/delay.h>
#include <linux/slab.h>
#include <linux/suspend.h>
#include <asm/unaligned.h>

#ifdef CONFIG_ACPI_PROCFS_POWER
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/uaccess.h>
#endif

#include <linux/acpi.h>
#include <linux/power_supply.h>

#include "battery.h"


#define PREFIX "ACPI: "


#define ACPI_BATTERY_VALUE_UNKNOWN 0xFFFFFFFF


#define ACPI_BATTERY_DEVICE_NAME	"Battery"

/* Battery power unit: 0 means mW, 1 means mA */

#define ACPI_BATTERY_POWER_UNIT_MA	1


#define ACPI_BATTERY_STATE_DISCHARGING	0x1

#define ACPI_BATTERY_STATE_CHARGING	0x2

#define ACPI_BATTERY_STATE_CRITICAL	0x4


#define _COMPONENT		ACPI_BATTERY_COMPONENT

ACPI_MODULE_NAME("battery");

MODULE_AUTHOR("Paul Diefenbaugh");
MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>");
MODULE_DESCRIPTION("ACPI Battery Driver");
MODULE_LICENSE("GPL");


static async_cookie_t async_cookie;

static bool battery_driver_registered;

static int battery_bix_broken_package;

static int battery_notification_delay_ms;

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

#ifdef CONFIG_ACPI_PROCFS_POWER
extern struct proc_dir_entry *acpi_lock_battery_dir(void);
extern void *acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir);


enum acpi_battery_files {
	
info_tag = 0,
	
state_tag,
	
alarm_tag,
	
ACPI_BATTERY_NUMFILES,
};

#endif


static const struct acpi_device_id battery_device_ids[] = {
	{"PNP0C0A", 0},
	{"", 0},
};

MODULE_DEVICE_TABLE(acpi, battery_device_ids);

/* Lists of PMIC ACPI HIDs with an (often better) native battery driver */

static const char * const acpi_battery_blacklist[] = {
	"INT33F4", /* X-Powers AXP288 PMIC */
};

enum {
	
ACPI_BATTERY_ALARM_PRESENT,
	
ACPI_BATTERY_XINFO_PRESENT,
	
ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY,
	/* On Lenovo Thinkpad models from 2010 and 2011, the power unit
           switches between mWh and mAh depending on whether the system
           is running on battery or not.  When mAh is the unit, most
           reported values are incorrect and need to be adjusted by
           10000/design_voltage.  Verified on x201, t410, t410s, and x220.
           Pre-2010 and 2012 models appear to always report in mWh and
           are thus unaffected (tested with t42, t61, t500, x200, x300,
           and x230).  Also, in mid-2012 Lenovo issued a BIOS update for
           the 2011 models that fixes the issue (tested on x220 with a
           post-1.29 BIOS), but as of Nov. 2012, no such update is
           available for the 2010 models.  */
	
ACPI_BATTERY_QUIRK_THINKPAD_MAH,
};


struct acpi_battery {
	
struct mutex lock;
	
struct mutex sysfs_lock;
	
struct power_supply *bat;
	
struct power_supply_desc bat_desc;
	
struct acpi_device *device;
	
struct notifier_block pm_nb;
	
unsigned long update_time;
	
int revision;
	
int rate_now;
	
int capacity_now;
	
int voltage_now;
	
int design_capacity;
	
int full_charge_capacity;
	
int technology;
	
int design_voltage;
	
int design_capacity_warning;
	
int design_capacity_low;
	
int cycle_count;
	
int measurement_accuracy;
	
int max_sampling_time;
	
int min_sampling_time;
	
int max_averaging_interval;
	
int min_averaging_interval;
	
int capacity_granularity_1;
	
int capacity_granularity_2;
	
int alarm;
	
char model_number[32];
	
char serial_number[32];
	
char type[32];
	
char oem_info[32];
	
int state;
	
int power_unit;
	
unsigned long flags;
};


#define to_acpi_battery(x) power_supply_get_drvdata(x)



static inline int acpi_battery_present(struct acpi_battery *battery)
{
	return battery->device->status.battery_present;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Alexey Y. Starikovskiy
15
71.43%
1
33.33%
Vladimir Lebedev
5
23.81%
1
33.33%
Andy Shevchenko
1
4.76%
1
33.33%
Total
21
100.00%
3
100.00%



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;
	if (!strncasecmp("LI-ION", battery->type, 6))
		return POWER_SUPPLY_TECHNOLOGY_LION;
	if (!strcasecmp("LiP", battery->type))
		return POWER_SUPPLY_TECHNOLOGY_LIPO;
	return POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Alexey Y. Starikovskiy
88
96.70%
2
66.67%
Andrey Borzenkov
3
3.30%
1
33.33%
Total
91
100.00%
3
100.00%

static int acpi_battery_get_state(struct acpi_battery *battery);



static int acpi_battery_is_charged(struct acpi_battery *battery)
{
	/* charging, discharging or critical low */
	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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Richard Hughes
72
98.63%
1
50.00%
Rui Zhang
1
1.37%
1
50.00%
Total
73
100.00%
2
100.00%



static int acpi_battery_get_property(struct power_supply *psy,
				     enum power_supply_property psp,
				     union power_supply_propval *val)
{
	int ret = 0;
	struct acpi_battery *battery = to_acpi_battery(psy);

	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)
		return -ENODEV;
	switch (psp) {
	case POWER_SUPPLY_PROP_STATUS:
		if (battery->state & ACPI_BATTERY_STATE_DISCHARGING)
			val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
		else if (battery->state & ACPI_BATTERY_STATE_CHARGING)
			val->intval = POWER_SUPPLY_STATUS_CHARGING;
		else if (acpi_battery_is_charged(battery))
			val->intval = POWER_SUPPLY_STATUS_FULL;
		else
			val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
		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_CYCLE_COUNT:
		val->intval = battery->cycle_count;
		break;
	case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
		if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
			ret = -ENODEV;
		else
			val->intval = battery->design_voltage * 1000;
		break;
	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
		if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
			ret = -ENODEV;
		else
			val->intval = battery->voltage_now * 1000;
		break;
	case POWER_SUPPLY_PROP_CURRENT_NOW:
	case POWER_SUPPLY_PROP_POWER_NOW:
		if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
			ret = -ENODEV;
		else
			val->intval = battery->rate_now * 1000;
		break;
	case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
	case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
		if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
			ret = -ENODEV;
		else
			val->intval = battery->design_capacity * 1000;
		break;
	case POWER_SUPPLY_PROP_CHARGE_FULL:
	case POWER_SUPPLY_PROP_ENERGY_FULL:
		if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
			ret = -ENODEV;
		else
			val->intval = battery->full_charge_capacity * 1000;
		break;
	case POWER_SUPPLY_PROP_CHARGE_NOW:
	case POWER_SUPPLY_PROP_ENERGY_NOW:
		if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
			ret = -ENODEV;
		else
			val->intval = battery->capacity_now * 1000;
		break;
	case POWER_SUPPLY_PROP_CAPACITY:
		if (battery->capacity_now && battery->full_charge_capacity)
			val->intval = battery->capacity_now * 100/
					battery->full_charge_capacity;
		else
			val->intval = 0;
		break;
	case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
		if (battery->state & ACPI_BATTERY_STATE_CRITICAL)
			val->intval = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
		else if (test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags) &&
			(battery->capacity_now <= battery->alarm))
			val->intval = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
		else if (acpi_battery_is_charged(battery))
			val->intval = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
		else
			val->intval = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
		break;
	case POWER_SUPPLY_PROP_MODEL_NAME:
		val->strval = battery->model_number;
		break;
	case POWER_SUPPLY_PROP_MANUFACTURER:
		val->strval = battery->oem_info;
		break;
	case POWER_SUPPLY_PROP_SERIAL_NUMBER:
		val->strval = battery->serial_number;
		break;
	default:
		ret = -EINVAL;
	}
	return ret;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Alexey Y. Starikovskiy
264
54.21%
4
33.33%
Rafael J. Wysocki
95
19.51%
2
16.67%
Rui Zhang
70
14.37%
1
8.33%
Srinivas Pandruvada
35
7.19%
1
8.33%
Maximilian Attems
12
2.46%
1
8.33%
Roland Dreier
7
1.44%
1
8.33%
Richard Hughes
3
0.62%
1
8.33%
Linus Torvalds
1
0.21%
1
8.33%
Total
487
100.00%
12
100.00%


static enum power_supply_property charge_battery_props[] = {
	POWER_SUPPLY_PROP_STATUS,
	POWER_SUPPLY_PROP_PRESENT,
	POWER_SUPPLY_PROP_TECHNOLOGY,
	POWER_SUPPLY_PROP_CYCLE_COUNT,
	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_CAPACITY,
	POWER_SUPPLY_PROP_CAPACITY_LEVEL,
	POWER_SUPPLY_PROP_MODEL_NAME,
	POWER_SUPPLY_PROP_MANUFACTURER,
	POWER_SUPPLY_PROP_SERIAL_NUMBER,
};


static enum power_supply_property energy_battery_props[] = {
	POWER_SUPPLY_PROP_STATUS,
	POWER_SUPPLY_PROP_PRESENT,
	POWER_SUPPLY_PROP_TECHNOLOGY,
	POWER_SUPPLY_PROP_CYCLE_COUNT,
	POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
	POWER_SUPPLY_PROP_VOLTAGE_NOW,
	POWER_SUPPLY_PROP_POWER_NOW,
	POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
	POWER_SUPPLY_PROP_ENERGY_FULL,
	POWER_SUPPLY_PROP_ENERGY_NOW,
	POWER_SUPPLY_PROP_CAPACITY,
	POWER_SUPPLY_PROP_CAPACITY_LEVEL,
	POWER_SUPPLY_PROP_MODEL_NAME,
	POWER_SUPPLY_PROP_MANUFACTURER,
	POWER_SUPPLY_PROP_SERIAL_NUMBER,
};

/* --------------------------------------------------------------------------
                               Battery Management
   -------------------------------------------------------------------------- */

struct acpi_offsets {
	
size_t offset;		/* offset inside struct acpi_sbs_battery */
	
u8 mode;		/* int or string? */
};


static const struct acpi_offsets state_offsets[] = {
	{offsetof(struct acpi_battery, state), 0},
	{offsetof(struct acpi_battery, rate_now), 0},
	{offsetof(struct acpi_battery, capacity_now), 0},
	{offsetof(struct acpi_battery, voltage_now), 0},
};


static const struct acpi_offsets 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, 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},
};


static const struct acpi_offsets extended_info_offsets[] = {
	{offsetof(struct acpi_battery, revision), 0},
	{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},
};



static int extract_package(struct acpi_battery *battery,
			   union acpi_object *package,
			   const struct acpi_offsets *offsets, int num)
{
	int i;
	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) {
			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(u64));
				ptr[sizeof(u64)] = 0;
			} else
				*ptr = 0; /* don't have value */
		} else {
			int *x = (int *)((u8 *)battery + offsets[i].offset);
			*x = (element->type == ACPI_TYPE_INTEGER) ?
				element->integer.value : -1;
		}
	}
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Alexey Y. Starikovskiy
212
88.70%
3
42.86%
Andy Grover
15
6.28%
1
14.29%
Vladimir Lebedev
9
3.77%
1
14.29%
Lin Ming
2
0.84%
1
14.29%
Mathias Krause
1
0.42%
1
14.29%
Total
239
100.00%
7
100.00%



static int acpi_battery_get_status(struct acpi_battery *battery)
{
	if (acpi_bus_get_status(battery->device)) {
		ACPI_EXCEPTION((AE_INFO, AE_ERROR, "Evaluating _STA"));
		return -ENODEV;
	}
	return 0;
}


Contributors
Person
Tokens
Prop
Commits
CommitProp
Vladimir Lebedev
28
70.00%
1
20.00%
Andy Grover
7
17.50%
2
40.00%
Alexey Y. Starikovskiy
3
7.50%
1
20.00%
Patrick Mochel
2
5.00%
1
20.00%
Total
40
100.00%
5
100.00%



static int extract_battery_info(const int use_bix,
			 struct acpi_battery *battery,
			 const struct acpi_buffer *buffer)
{
	int result = -EFAULT;

	if (use_bix && battery_bix_broken_package)
		result = extract_package(battery, buffer->pointer,
				extended_info_offsets + 1,
				ARRAY_SIZE(extended_info_offsets) - 1);
	else if (use_bix)
		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));
	if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
		battery->full_charge_capacity = battery->design_capacity;
	if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
	    battery->power_unit && battery->design_voltage) {
		battery->design_capacity = battery->design_capacity *
		    10000 / battery->design_voltage;
		battery->full_charge_capacity = battery->full_charge_capacity *
		    10000 / battery->design_voltage;
		battery->design_capacity_warning =
		    battery->design_capacity_warning *
		    10000 / battery->design_voltage;
		/* Curiously, design_capacity_low, unlike the rest of them,
                   is correct.  */
		/* capacity_granularity_* equal 1 on the systems tested, so
                   it's impossible to tell if they would need an adjustment
                   or not if their values were higher.  */
	}
	return result;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Kamil Iskra
66
35.48%
1
9.09%
Alexey Y. Starikovskiy
31
16.67%
3
27.27%
Lan Tianyu
26
13.98%
1
9.09%
Andy Grover
22
11.83%
2
18.18%
Rui Zhang
20
10.75%
1
9.09%
Dave Lambley
17
9.14%
1
9.09%
Vladimir Lebedev
2
1.08%
1
9.09%
Patrick Mochel
2
1.08%
1
9.09%
Total
186
100.00%
11
100.00%



static int acpi_battery_get_info(struct acpi_battery *battery)
{
	const int xinfo = test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
	int use_bix;
	int result = -ENODEV;

	if (!acpi_battery_present(battery))
		return 0;


	for (use_bix = xinfo ? 1 : 0; use_bix >= 0; use_bix--) {
		struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
		acpi_status status = AE_ERROR;

		mutex_lock(&battery->lock);
		status = acpi_evaluate_object(battery->device->handle,
					      use_bix ? "_BIX":"_BIF",
					      NULL, &buffer);
		mutex_unlock(&battery->lock);

		if (ACPI_FAILURE(status)) {
			ACPI_EXCEPTION((AE_INFO, status, "Evaluating %s",
					use_bix ? "_BIX":"_BIF"));
		} else {
			result = extract_battery_info(use_bix,
						      battery,
						      &buffer);

			kfree(buffer.pointer);
			break;
		}
	}

	if (!result && !use_bix && xinfo)
		pr_warn(FW_BUG "The _BIX method is broken, using _BIF.\n");

	return result;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Dave Lambley
185
100.00%
1
100.00%
Total
185
100.00%
1
100.00%



static int acpi_battery_get_state(struct acpi_battery *battery)
{
	int result = 0;
	acpi_status status = 0;
	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };

	if (!acpi_battery_present(battery))
		return 0;

	if (battery->update_time &&
	    time_before(jiffies, battery->update_time +
			msecs_to_jiffies(cache_time)))
		return 0;

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

	if (ACPI_FAILURE(status)) {
		ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST"));
		return -ENODEV;
	}

	result = extract_package(battery, buffer.pointer,
				 state_offsets, ARRAY_SIZE(state_offsets));
	battery->update_time = jiffies;
	kfree(buffer.pointer);

	/* 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.
         */
	if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA &&
		battery->rate_now != ACPI_BATTERY_VALUE_UNKNOWN &&
		(s16)(battery->rate_now) < 0) {
		battery->rate_now = abs((s16)battery->rate_now);
		printk_once(KERN_WARNING FW_BUG
			    "battery: (dis)charge rate invalid.\n");
	}

	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;
	if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
	    battery->power_unit && battery->design_voltage) {
		battery->capacity_now = battery->capacity_now *
		    10000 / battery->design_voltage;
	}
	return result;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Vladimir Lebedev
69
24.56%
1
9.09%
Alexey Y. Starikovskiy
59
21.00%
2
18.18%
Rui Zhang
40
14.23%
1
9.09%
Kamil Iskra
36
12.81%
1
9.09%
Andy Grover
27
9.61%
2
18.18%
Hector Martin
24
8.54%
1
9.09%
Lan Tianyu
23
8.19%
1
9.09%
Patrick Mochel
2
0.71%
1
9.09%
Martin Kepplinger
1
0.36%
1
9.09%
Total
281
100.00%
11
100.00%



static int acpi_battery_set_alarm(struct acpi_battery *battery)
{
	acpi_status status = 0;

	if (!acpi_battery_present(battery) ||
	    !test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags))
		return -ENODEV;

	mutex_lock(&battery->lock);
	status = acpi_execute_simple_method(battery->device->handle, "_BTP",
					    battery->alarm);
	mutex_unlock(&battery->lock);

	if (ACPI_FAILURE(status))
		return -ENODEV;

	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", battery->alarm));
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Vladimir Lebedev
33
33.33%
1
11.11%
Alexey Y. Starikovskiy
31
31.31%
5
55.56%
Andy Grover
27
27.27%
1
11.11%
Jiang Liu
4
4.04%
1
11.11%
Patrick Mochel
4
4.04%
1
11.11%
Total
99
100.00%
9
100.00%



static int acpi_battery_init_alarm(struct acpi_battery *battery)
{
	/* See if alarms are supported, and if so, set default */
	if (!acpi_has_method(battery->device->handle, "_BTP")) {
		clear_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
		return 0;
	}
	set_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
	if (!battery->alarm)
		battery->alarm = battery->design_capacity_warning;
	return acpi_battery_set_alarm(battery);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Alexey Y. Starikovskiy
29
40.28%
3
42.86%
Andy Grover
19
26.39%
1
14.29%
Vladimir Lebedev
19
26.39%
1
14.29%
Jiang Liu
4
5.56%
1
14.29%
Patrick Mochel
1
1.39%
1
14.29%
Total
72
100.00%
7
100.00%



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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Andrey Borzenkov
37
78.72%
1
33.33%
Vladimir Lebedev
8
17.02%
1
33.33%
Andy Grover
2
4.26%
1
33.33%
Total
47
100.00%
3
100.00%



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, "%lu\n", &x) == 1)
		battery->alarm = x/1000;
	if (acpi_battery_present(battery))
		acpi_battery_set_alarm(battery);
	return count;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Andrey Borzenkov
60
76.92%
1
16.67%
Vladimir Lebedev
9
11.54%
1
16.67%
Alexey Y. Starikovskiy
7
8.97%
2
33.33%
Luis Gonzalez Fernandez
1
1.28%
1
16.67%
Andy Grover
1
1.28%
1
16.67%
Total
78
100.00%
6
100.00%


static const struct device_attribute alarm_attr = {
	.attr = {.name = "alarm", .mode = 0644},
	.show = acpi_battery_alarm_show,
	.store = acpi_battery_alarm_store,
};



static int sysfs_add_battery(struct acpi_battery *battery)
{
	struct power_supply_config psy_cfg = { .drv_data = battery, };

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

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

	battery->bat = power_supply_register_no_ws(&battery->device->dev,
				&battery->bat_desc, &psy_cfg);

	if (IS_ERR(battery->bat)) {
		int result = PTR_ERR(battery->bat);

		battery->bat = NULL;
		return result;
	}
	return device_create_file(&battery->bat->dev, &alarm_attr);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Andrey Borzenkov
70
41.67%
1
16.67%
Krzysztof Kozlowski
50
29.76%
2
33.33%
Alexey Y. Starikovskiy
45
26.79%
1
16.67%
Lan Tianyu
2
1.19%
1
16.67%
Rui Zhang
1
0.60%
1
16.67%
Total
168
100.00%
6
100.00%



static void sysfs_remove_battery(struct acpi_battery *battery)
{
	mutex_lock(&battery->sysfs_lock);
	if (!battery->bat) {
		mutex_unlock(&battery->sysfs_lock);
		return;
	}

	device_remove_file(&battery->bat->dev, &alarm_attr);
	power_supply_unregister(battery->bat);
	battery->bat = NULL;
	mutex_unlock(&battery->sysfs_lock);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Andrey Borzenkov
36
50.70%
1
14.29%
Lan Tianyu
17
23.94%
1
14.29%
Alexey Y. Starikovskiy
9
12.68%
2
28.57%
Hector Martin
4
5.63%
1
14.29%
Sergey Senozhatsky
3
4.23%
1
14.29%
Krzysztof Kozlowski
2
2.82%
1
14.29%
Total
71
100.00%
7
100.00%



static void find_battery(const struct dmi_header *dm, void *private)
{
	struct acpi_battery *battery = (struct acpi_battery *)private;
	/* Note: the hardcoded offsets below have been extracted from
           the source code of dmidecode.  */
	if (dm->type == DMI_ENTRY_PORTABLE_BATTERY && dm->length >= 8) {
		const u8 *dmi_data = (const u8 *)(dm + 1);
		int dmi_capacity = get_unaligned((const u16 *)(dmi_data + 6));
		if (dm->length >= 18)
			dmi_capacity *= dmi_data[17];
		if (battery->design_capacity * battery->design_voltage / 1000
		    != dmi_capacity &&
		    battery->design_capacity * 10 == dmi_capacity)
			set_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
				&battery->flags);
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Kamil Iskra
125
100.00%
1
100.00%
Total
125
100.00%
1
100.00%

/*
 * 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_quirks(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;
	}

	if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags))
		return;

	if (battery->power_unit && dmi_name_in_vendors("LENOVO")) {
		const char *s;
		s = dmi_get_system_info(DMI_PRODUCT_VERSION);
		if (s && !strncasecmp(s, "ThinkPad", 8)) {
			dmi_walk(find_battery, battery);
			if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
				     &battery->flags) &&
			    battery->design_voltage) {
				battery->design_capacity =
				    battery->design_capacity *
				    10000 / battery->design_voltage;
				battery->full_charge_capacity =
				    battery->full_charge_capacity *
				    10000 / battery->design_voltage;
				battery->design_capacity_warning =
				    battery->design_capacity_warning *
				    10000 / battery->design_voltage;
				battery->capacity_now = battery->capacity_now *
				    10000 / battery->design_voltage;
			}
		}
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Kamil Iskra
133
60.18%
1
20.00%
Rui Zhang
84
38.01%
1
20.00%
Nicholas Mazzuca
2
0.90%
1
20.00%
Rasmus Villemoes
1
0.45%
1
20.00%
Lan Tianyu
1
0.45%
1
20.00%
Total
221
100.00%
5
100.00%



static int acpi_battery_update(struct acpi_battery *battery, bool resume)
{
	int result, old_present = acpi_battery_present(battery);
	result = acpi_battery_get_status(battery);
	if (result)
		return result;
	if (!acpi_battery_present(battery)) {
		sysfs_remove_battery(battery);
		battery->update_time = 0;
		return 0;
	}

	if (resume)
		return 0;

	if (!battery->update_time ||
	    old_present != acpi_battery_present(battery)) {
		result = acpi_battery_get_info(battery);
		if (result)
			return result;
		acpi_battery_init_alarm(battery);
	}

	result = acpi_battery_get_state(battery);
	if (result)
		return result;
	acpi_battery_quirks(battery);

	if (!battery->bat) {
		result = sysfs_add_battery(battery);
		if (result)
			return result;
	}

	/*
         * Wakeup the system if battery is critical low
         * or lower than the alarm level
         */
	if ((battery->state & ACPI_BATTERY_STATE_CRITICAL) ||
	    (test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags) &&
            (battery->capacity_now <= battery->alarm)))
		acpi_pm_wakeup_event(&battery->device->dev);

	return result;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Alexey Y. Starikovskiy
58
30.21%
3
27.27%
Rui Zhang
54
28.12%
2
18.18%
Andrey Borzenkov
40
20.83%
1
9.09%
Carlos Garnacho
16
8.33%
1
9.09%
Lan Tianyu
10
5.21%
1
9.09%
Stefan Hajnoczi
9
4.69%
1
9.09%
Vladimir Lebedev
4
2.08%
1
9.09%
Rafael J. Wysocki
1
0.52%
1
9.09%
Total
192
100.00%
11
100.00%



static void acpi_battery_refresh(struct acpi_battery *battery)
{
	int power_unit;

	if (!battery->bat)
		return;

	power_unit = battery->power_unit;

	acpi_battery_get_info(battery);

	if (power_unit == battery->power_unit)
		return;

	/* The battery has changed its reporting units. */
	sysfs_remove_battery(battery);
	sysfs_add_battery(battery);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Rafael J. Wysocki
34
64.15%
1
50.00%
Andy Whitcroft
19
35.85%
1
50.00%
Total
53
100.00%
2
100.00%

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

#ifdef CONFIG_ACPI_PROCFS_POWER

static struct proc_dir_entry *acpi_battery_dir;



static const char *acpi_battery_units(const struct acpi_battery *battery)
{
	return (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) ?
		"mA" : "mW";
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Mathias Krause
27
100.00%
1
100.00%
Total
27
100.00%
1
100.00%



static int acpi_battery_print_info(struct seq_file *seq, int result)
{
	struct acpi_battery *battery = seq->private;

	if (result)
		goto end;

	seq_printf(seq, "present:                 %s\n",
		   acpi_battery_present(battery) ? "yes" : "no");
	if (!acpi_battery_present(battery))
		goto end;
	if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
		seq_printf(seq, "design capacity:         unknown\n");
	else
		seq_printf(seq, "design capacity:         %d %sh\n",
			   battery->design_capacity,
			   acpi_battery_units(battery));

	if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
		seq_printf(seq, "last full capacity:      unknown\n");
	else
		seq_printf(seq, "last full capacity:      %d %sh\n",
			   battery->full_charge_capacity,
			   acpi_battery_units(battery));

	seq_printf(seq, "battery technology:      %srechargeable\n",
		   (!battery->technology)?"non-":"");

	if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
		seq_printf(seq, "design voltage:          unknown\n");
	else
		seq_printf(seq, "design voltage:          %d mV\n",
			   battery->design_voltage);
	seq_printf(seq, "design capacity warning: %d %sh\n",
		   battery->design_capacity_warning,
		   acpi_battery_units(battery));
	seq_printf(seq, "design capacity low:     %d %sh\n",
		   battery->design_capacity_low,
		   acpi_battery_units(battery));
	seq_printf(seq, "cycle count:             %i\n", battery->cycle_count);
	seq_printf(seq, "capacity granularity 1:  %d %sh\n",
		   battery->capacity_granularity_1,
		   acpi_battery_units(battery));
	seq_printf(seq, "capacity granularity 2:  %d %sh\n",
		   battery->capacity_granularity_2,
		   acpi_battery_units(battery));
	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);
      end:
	if (result)
		seq_printf(seq, "ERROR: Unable to read battery info\n");
	return result;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Lan Tianyu
248
82.39%
2
22.22%
Andy Grover
32
10.63%
1
11.11%
Alexey Y. Starikovskiy
12
3.99%
3
33.33%
Alexander Mezin
6
1.99%
1
11.11%
Vladimir Lebedev
2
0.66%
1
11.11%
Len Brown
1
0.33%
1
11.11%
Total
301
100.00%
9
100.00%



static int acpi_battery_print_state(struct seq_file *seq, int result)
{
	struct acpi_battery *battery = seq->private;

	if (result)
		goto end;

	seq_printf(seq, "present:                 %s\n",
		   acpi_battery_present(battery) ? "yes" : "no");
	if (!acpi_battery_present(battery))
		goto end;

	seq_printf(seq, "capacity state:          %s\n",
			(battery->state & 0x04) ? "critical" : "ok");
	if ((battery->state & 0x01) && (battery->state & 0x02))
		seq_printf(seq,
			   "charging state:          charging/discharging\n");
	else if (battery->state & 0x01)
		seq_printf(seq, "charging state:          discharging\n");
	else if (battery->state & 0x02)
		seq_printf(seq, "charging state:          charging\n");
	else
		seq_printf(seq, "charging state:          charged\n");

	if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
		seq_printf(seq, "present rate:            unknown\n");
	else
		seq_printf(seq, "present rate:            %d %s\n",
			   battery->rate_now, acpi_battery_units(battery));

	if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
		seq_printf(seq, "remaining capacity:      unknown\n");
	else
		seq_printf(seq, "remaining capacity:      %d %sh\n",
			   battery->capacity_now, acpi_battery_units(battery));
	if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
		seq_printf(seq, "present voltage:         unknown\n");
	else
		seq_printf(seq, "present voltage:         %d mV\n",
			   battery->voltage_now);
      end:
	if (result)
		seq_printf(seq, "ERROR: Unable to read battery state\n");

	return result;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Lan Tianyu
248
100.00%
1
100.00%
Total
248
100.00%
1
100.00%



static int acpi_battery_print_alarm(struct seq_file *seq, int result)
{
	struct acpi_battery *battery = seq->private;

	if (result)
		goto end;

	if (!acpi_battery_present(battery)) {
		seq_printf(seq, "present:                 no\n");
		goto end;
	}
	seq_printf(seq, "alarm:                   ");
	if (!battery->alarm)
		seq_printf(seq, "unsupported\n");
	else
		seq_printf(seq, "%u %sh\n", battery->alarm,
				acpi_battery_units(battery));
      end:
	if (result)
		seq_printf(seq, "ERROR: Unable to read battery alarm\n");
	return result;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Lan Tianyu
104
100.00%
1
100.00%
Total
104
100.00%
1
100.00%



static ssize_t acpi_battery_write_alarm(struct file *file,
					const char __user * buffer,
					size_t count, loff_t * ppos)
{
	int result = 0;
	char alarm_string[12] = { '\0' };
	struct seq_file *m = file->private_data;
	struct acpi_battery *battery = m->private;

	if (!battery || (count > sizeof(alarm_string) - 1))
		return -EINVAL;
	if (!acpi_battery_present(battery)) {
		result = -ENODEV;
		goto end;
	}
	if (copy_from_user(alarm_string, buffer, count)) {
		result = -EFAULT;
		goto end;
	}
	alarm_string[count] = '\0';
	if (kstrtoint(alarm_string, 0, &battery->alarm)) {
		result = -EINVAL;
		goto end;
	}
	result = acpi_battery_set_alarm(battery);
      end:
	if (!result)
		return count;
	return result;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Lan Tianyu
149
89.22%
1
50.00%
Christoph Jaeger
18
10.78%
1
50.00%
Total
167
100.00%
2
100.00%


typedef int(*print_func)(struct seq_file *seq, int result);


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



static int acpi_battery_read(int fid, struct seq_file *seq)
{
	struct acpi_battery *battery = seq->private;
	int result = acpi_battery_update(battery, false);
	return acpi_print_funcs[fid](seq, result);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Lan Tianyu
44
100.00%
2
100.00%
Total
44
100.00%
2
100.00%


#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_DATA(inode)); \
}


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, \
                }, \
        }


#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, \
                }, \
        }


static const struct battery_file {
	
struct file_operations ops;
	
umode_t mode;
	
const char *name;

} acpi_battery_file[] = {
	FILE_DESCRIPTION_RO(info),
	FILE_DESCRIPTION_RO(state),
	FILE_DESCRIPTION_RW(alarm),
};


#undef FILE_DESCRIPTION_RO

#undef FILE_DESCRIPTION_RW



static int acpi_battery_add_fs(struct acpi_device *device)
{
	struct proc_dir_entry *entry = NULL;
	int i;

	printk(KERN_WARNING PREFIX "Deprecated procfs I/F for battery is loaded,"
			" please retry with CONFIG_ACPI_PROCFS_POWER cleared\n");
	if (!acpi_device_dir(device)) {
		acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
						     acpi_battery_dir);
		if (!acpi_device_dir(device))
			return -ENODEV;
	}

	for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i) {
		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));
		if (!entry)
			return -ENODEV;
	}
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Lan Tianyu
129
100.00%
1
100.00%
Total
129
100.00%
1
100.00%



static void acpi_battery_remove_fs(struct acpi_device *device)
{
	int i;
	if (!acpi_device_dir(device))
		return;
	for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i)
		remove_proc_entry(acpi_battery_file[i].name,
				  acpi_device_dir(device));

	remove_proc_entry(acpi_device_bid(device), acpi_battery_dir);
	acpi_device_dir(device) = NULL;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Lan Tianyu
68
100.00%
1
100.00%
Total
68
100.00%
1
100.00%

#endif

/* --------------------------------------------------------------------------
                                 Driver Interface
   -------------------------------------------------------------------------- */



static void acpi_battery_notify(struct acpi_device *device, u32 event)
{
	struct acpi_battery *battery = acpi_driver_data(device);
	struct power_supply *old;

	if (!battery)
		return;
	old = battery->bat;
	/*
        * On Acer Aspire V5-573G notifications are sometimes triggered too
        * early. For example, when AC is unplugged and notification is
        * triggered, battery state is still reported as "Full", and changes to
        * "Discharging" only after short delay, without any notification.
        */
	if (battery_notification_delay_ms > 0)
		msleep(battery_notification_delay_ms);
	if (event == ACPI_BATTERY_NOTIFY_INFO)
		acpi_battery_refresh(battery);
	acpi_battery_update(battery, false);
	acpi_bus_generate_netlink_event(device->pnp.device_class,
					dev_name(&device->dev), event,
					acpi_battery_present(battery));
	acpi_notifier_call_chain(device, event, acpi_battery_present(battery));
	/* acpi_battery_update could remove power_supply object */
	if (old && battery->bat)
		power_supply_changed(battery->bat);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Lan Tianyu
110
89.43%
2
50.00%
Alexander Mezin
12
9.76%
1
25.00%
Krzysztof Kozlowski
1
0.81%
1
25.00%
Total
123
100.00%
4
100.00%



static int battery_notify(struct notifier_block *nb,
			       unsigned long mode, void *_unused)
{
	struct acpi_battery *battery = container_of(nb, struct acpi_battery,
						    pm_nb);
	int result;

	switch (mode) {
	case PM_POST_HIBERNATION:
	case PM_POST_SUSPEND:
		if (!acpi_battery_present(battery))
			return 0;

		if (!battery->bat) {
			result = acpi_battery_get_info(battery);
			if (result)
				return result;

			result = sysfs_add_battery(battery);
			if (result)
				return result;
		} else
			acpi_battery_refresh(battery);

		acpi_battery_init_alarm(battery);
		acpi_battery_get_state(battery);
		break;
	}

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Lan Tianyu
65
55.56%
4
66.67%
Kyle McMartin
51
43.59%
1
16.67%
Krzysztof Kozlowski
1
0.85%
1
16.67%
Total
117
100.00%
6
100.00%


static int __init

battery_bix_broken_package_quirk(const struct dmi_system_id *d)
{
	battery_bix_broken_package = 1;
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Alexander Mezin
19
95.00%
1
50.00%
Mathias Krause
1
5.00%
1
50.00%
Total
20
100.00%
2
100.00%


static int __init

battery_notification_delay_quirk(const struct dmi_system_id *d)
{
	battery_notification_delay_ms = 1000;
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Alexander Mezin
19
95.00%
1
50.00%
Mathias Krause
1
5.00%
1
50.00%
Total
20
100.00%
2
100.00%


static const struct dmi_system_id bat_dmi_table[] __initconst = {
	{
		.callback = battery_bix_broken_package_quirk,
		.ident = "NEC LZ750/LS",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "NEC"),
			DMI_MATCH(DMI_PRODUCT_NAME, "PC-LZ750LS"),
                },
        },
	{
		.callback = battery_notification_delay_quirk,
		.ident = "Acer Aspire V5-573G",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
			DMI_MATCH(DMI_PRODUCT_NAME, "Aspire V5-573G"),
                },
        },
	{},
};

/*
 * Some machines'(E,G Lenovo Z480) ECs are not stable
 * during boot up and this causes battery driver fails to be
 * probed due to failure of getting battery information
 * from EC sometimes. After several retries, the operation
 * may work. So add retry code here and 20ms sleep between
 * every retries.
 */


static int acpi_battery_update_retry(struct acpi_battery *battery)
{
	int retry, ret;

	for (retry = 5; retry; retry--) {
		ret = acpi_battery_update(battery, false);
		if (!ret)
			break;

		msleep(20);
	}
	return ret;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Lan Tianyu
52
100.00%
1
100.00%
Total
52
100.00%
1
100.00%



static int acpi_battery_add(struct acpi_device *device)
{
	int result = 0;
	struct acpi_battery *battery = NULL;

	if (!device)
		return -EINVAL;

	if (device->dep_unmet)
		return -EPROBE_DEFER;

	battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
	if (!battery)
		return -ENOMEM;
	battery->device = device;
	strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
	strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
	device->driver_data = battery;
	mutex_init(&battery->lock);
	mutex_init(&battery->sysfs_lock);
	if (acpi_has_method(battery->device->handle, "_BIX"))
		set_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);

	result = acpi_battery_update_retry(battery);
	if (result)
		goto fail;

#ifdef CONFIG_ACPI_PROCFS_POWER
	result = acpi_battery_add_fs(device);
#endif
	if (result) {
#ifdef CONFIG_ACPI_PROCFS_POWER
		acpi_battery_remove_fs(device);
#endif
		goto fail;
	}

	printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n",
		ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device),
		device->status.battery_present ? "present" : "absent");

	battery->pm_nb.notifier_call = battery_notify;
	register_pm_notifier(&battery->pm_nb);

	device_init_wakeup(&device->dev, 1);

	return result;

fail:
	sysfs_remove_battery(battery);
	mutex_destroy(&battery->lock);
	mutex_destroy(&battery->sysfs_lock);
	kfree(battery);
	return result;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Andy Grover
95
37.25%
1
5.56%
Lan Tianyu
42
16.47%
3
16.67%
Stefan Hajnoczi
32
12.55%
2
11.11%
Alexey Y. Starikovskiy
30
11.76%
2
11.11%
Kyle McMartin
16
6.27%
1
5.56%
Sergey Senozhatsky
16
6.27%
1
5.56%
Rui Zhang
10
3.92%
1
5.56%
Patrick Mochel
7
2.75%
2
11.11%
Pavel Machek
2
0.78%
1
5.56%
Andrew Morton
2
0.78%
1
5.56%
Len Brown
1
0.39%
1
5.56%
Burman Yan
1
0.39%
1
5.56%
Jiang Liu
1
0.39%
1
5.56%
Total
255
100.00%
18
100.00%



static int acpi_battery_remove(struct acpi_device *device)
{
	struct acpi_battery *battery = NULL;

	if (!device || !acpi_driver_data(device))
		return -EINVAL;
	device_init_wakeup(&device->dev, 0);
	battery = acpi_driver_data(device);
	unregister_pm_notifier(&battery->pm_nb);
#ifdef CONFIG_ACPI_PROCFS_POWER
	acpi_battery_remove_fs(device);
#endif
	sysfs_remove_battery(battery);
	mutex_destroy(&battery->lock);
	mutex_destroy(&battery->sysfs_lock);
	kfree(battery);
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Andy Grover
44
45.36%
1
10.00%
Lan Tianyu
10
10.31%
1
10.00%
Rui Zhang
10
10.31%
1
10.00%
Kyle McMartin
8
8.25%
1
10.00%
Sergey Senozhatsky
8
8.25%
1
10.00%
Vladimir Lebedev
7
7.22%
1
10.00%
Alexey Y. Starikovskiy
5
5.15%
2
20.00%
Patrick Mochel
4
4.12%
1
10.00%
Andrey Borzenkov
1
1.03%
1
10.00%
Total
97
100.00%
10
100.00%

#ifdef CONFIG_PM_SLEEP
/* this is needed to learn about changes made in suspended state */


static int acpi_battery_resume(struct device *dev)
{
	struct acpi_battery *battery;

	if (!dev)
		return -EINVAL;

	battery = acpi_driver_data(to_acpi_device(dev));
	if (!battery)
		return -EINVAL;

	battery->update_time = 0;
	acpi_battery_update(battery, true);
	return 0;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Jiri Kosina
27
45.00%
1
14.29%
Rafael J. Wysocki
16
26.67%
1
14.29%
Alexey Y. Starikovskiy
6
10.00%
2
28.57%
Andrey Borzenkov
5
8.33%
1
14.29%
Vladimir Lebedev
4
6.67%
1
14.29%
Lan Tianyu
2
3.33%
1
14.29%
Total
60
100.00%
7
100.00%

#else

#define acpi_battery_resume NULL
#endif

static SIMPLE_DEV_PM_OPS(acpi_battery_pm, NULL, acpi_battery_resume);


static struct acpi_driver acpi_battery_driver = {
	.name = "battery",
	.class = ACPI_BATTERY_CLASS,
	.ids = battery_device_ids,
	.flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
	.ops = {
		.add = acpi_battery_add,
		.remove = acpi_battery_remove,
		.notify = acpi_battery_notify,
                },
	.drv.pm = &acpi_battery_pm,
};



static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie)
{
	unsigned int i;
	int result;

	for (i = 0; i < ARRAY_SIZE(acpi_battery_blacklist); i++)
		if (acpi_dev_present(acpi_battery_blacklist[i], "1", -1)) {
			pr_info(PREFIX ACPI_BATTERY_DEVICE_NAME
				": found native %s PMIC, not loading\n",
				acpi_battery_blacklist[i]);
			return;
		}

	dmi_check_system(bat_dmi_table);

#ifdef CONFIG_ACPI_PROCFS_POWER
	acpi_battery_dir = acpi_lock_battery_dir();
	if (!acpi_battery_dir)
		return;
#endif
	result = acpi_bus_register_driver(&acpi_battery_driver);
#ifdef CONFIG_ACPI_PROCFS_POWER
	if (result < 0)
		acpi_unlock_battery_dir(acpi_battery_dir);
#endif
	battery_driver_registered = (result == 0);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Hans de Goede
54
46.55%
2
25.00%
Lan Tianyu
30
25.86%
2
25.00%
Luis Henriques
12
10.34%
1
12.50%
Andy Grover
11
9.48%
1
12.50%
Arjan van de Ven
8
6.90%
1
12.50%
Linus Torvalds
1
0.86%
1
12.50%
Total
116
100.00%
8
100.00%



static int __init acpi_battery_init(void)
{
	if (acpi_disabled)
		return -ENODEV;

	async_cookie = async_schedule(acpi_battery_init_async, NULL);
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Arjan van de Ven
15
51.72%
1
20.00%
Luis Henriques
10
34.48%
2
40.00%
Andy Grover
2
6.90%
1
20.00%
Patrick Mochel
2
6.90%
1
20.00%
Total
29
100.00%
5
100.00%



static void __exit acpi_battery_exit(void)
{
	async_synchronize_cookie(async_cookie + 1);
	if (battery_driver_registered)
		acpi_bus_unregister_driver(&acpi_battery_driver);
#ifdef CONFIG_ACPI_PROCFS_POWER
	if (acpi_battery_dir)
		acpi_unlock_battery_dir(acpi_battery_dir);
#endif
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Andy Grover
15
37.50%
1
20.00%
Lan Tianyu
10
25.00%
1
20.00%
Hans de Goede
8
20.00%
1
20.00%
Luis Henriques
5
12.50%
1
20.00%
Chris Wilson
2
5.00%
1
20.00%
Total
40
100.00%
5
100.00%


module_init(acpi_battery_init);

module_exit(acpi_battery_exit);
Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
Lan Tianyu
1634
27.12%
13
12.15%
Alexey Y. Starikovskiy
1578
26.20%
15
14.02%
Andy Grover
405
6.72%
4
3.74%
Kamil Iskra
365
6.06%
1
0.93%
Rui Zhang
308
5.11%
3
2.80%
Andrey Borzenkov
283
4.70%
2
1.87%
Vladimir Lebedev
224
3.72%
2
1.87%
Dave Lambley
202
3.35%
1
0.93%
Rafael J. Wysocki
169
2.81%
6
5.61%
Alexander Mezin
102
1.69%
4
3.74%
Kyle McMartin
82
1.36%
1
0.93%
Hans de Goede
81
1.34%
2
1.87%
Richard Hughes
75
1.25%
1
0.93%
Krzysztof Kozlowski
60
1.00%
3
2.80%
Stefan Hajnoczi
41
0.68%
2
1.87%
Srinivas Pandruvada
39
0.65%
1
0.93%
Mathias Krause
35
0.58%
3
2.80%
Hector Martin
33
0.55%
1
0.93%
Luis Henriques
31
0.51%
3
2.80%
Sergey Senozhatsky
31
0.51%
1
0.93%
Patrick Mochel
28
0.46%
3
2.80%
Jiri Kosina
28
0.46%
1
0.93%
Thomas Renninger
28
0.46%
1
0.93%
Arjan van de Ven
26
0.43%
1
0.93%
Andy Whitcroft
19
0.32%
1
0.93%
Christoph Jaeger
18
0.30%
1
0.93%
Maximilian Attems
16
0.27%
1
0.93%
Carlos Garnacho
16
0.27%
1
0.93%
Björn Helgaas
10
0.17%
1
0.93%
Len Brown
9
0.15%
5
4.67%
Jiang Liu
9
0.15%
2
1.87%
Roland Dreier
7
0.12%
1
0.93%
Shuah Khan
6
0.10%
1
0.93%
Linus Torvalds
5
0.08%
4
3.74%
Tejun Heo
3
0.05%
1
0.93%
Chris Wilson
2
0.03%
1
0.93%
Pavel Machek
2
0.03%
1
0.93%
Nicholas Mazzuca
2
0.03%
1
0.93%
Lin Ming
2
0.03%
1
0.93%
Andrew Morton
2
0.03%
1
0.93%
Rasmus Villemoes
1
0.02%
1
0.93%
Lv Zheng
1
0.02%
1
0.93%
Martin Kepplinger
1
0.02%
1
0.93%
Burman Yan
1
0.02%
1
0.93%
Jarkko Nikula
1
0.02%
1
0.93%
Andy Shevchenko
1
0.02%
1
0.93%
Luis Gonzalez Fernandez
1
0.02%
1
0.93%
Bhumika Goyal
1
0.02%
1
0.93%
Total
6024
100.00%
107
100.00%
Directory: drivers/acpi

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.