cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

battery.c (37610B)


      1// SPDX-License-Identifier: GPL-2.0-or-later
      2/*
      3 *  battery.c - ACPI Battery Driver (Revision: 2.0)
      4 *
      5 *  Copyright (C) 2007 Alexey Starikovskiy <astarikovskiy@suse.de>
      6 *  Copyright (C) 2004-2007 Vladimir Lebedev <vladimir.p.lebedev@intel.com>
      7 *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
      8 *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
      9 */
     10
     11#define pr_fmt(fmt) "ACPI: battery: " fmt
     12
     13#include <linux/async.h>
     14#include <linux/delay.h>
     15#include <linux/dmi.h>
     16#include <linux/jiffies.h>
     17#include <linux/kernel.h>
     18#include <linux/list.h>
     19#include <linux/module.h>
     20#include <linux/mutex.h>
     21#include <linux/slab.h>
     22#include <linux/suspend.h>
     23#include <linux/types.h>
     24
     25#include <asm/unaligned.h>
     26
     27#include <linux/acpi.h>
     28#include <linux/power_supply.h>
     29
     30#include <acpi/battery.h>
     31
     32#define ACPI_BATTERY_VALUE_UNKNOWN 0xFFFFFFFF
     33#define ACPI_BATTERY_CAPACITY_VALID(capacity) \
     34	((capacity) != 0 && (capacity) != ACPI_BATTERY_VALUE_UNKNOWN)
     35
     36#define ACPI_BATTERY_DEVICE_NAME	"Battery"
     37
     38/* Battery power unit: 0 means mW, 1 means mA */
     39#define ACPI_BATTERY_POWER_UNIT_MA	1
     40
     41#define ACPI_BATTERY_STATE_DISCHARGING	0x1
     42#define ACPI_BATTERY_STATE_CHARGING	0x2
     43#define ACPI_BATTERY_STATE_CRITICAL	0x4
     44
     45MODULE_AUTHOR("Paul Diefenbaugh");
     46MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>");
     47MODULE_DESCRIPTION("ACPI Battery Driver");
     48MODULE_LICENSE("GPL");
     49
     50static async_cookie_t async_cookie;
     51static bool battery_driver_registered;
     52static int battery_bix_broken_package;
     53static int battery_notification_delay_ms;
     54static int battery_ac_is_broken;
     55static unsigned int cache_time = 1000;
     56module_param(cache_time, uint, 0644);
     57MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
     58
     59static const struct acpi_device_id battery_device_ids[] = {
     60	{"PNP0C0A", 0},
     61
     62	/* Microsoft Surface Go 3 */
     63	{"MSHW0146", 0},
     64
     65	{"", 0},
     66};
     67
     68MODULE_DEVICE_TABLE(acpi, battery_device_ids);
     69
     70enum {
     71	ACPI_BATTERY_ALARM_PRESENT,
     72	ACPI_BATTERY_XINFO_PRESENT,
     73	ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY,
     74	/* On Lenovo Thinkpad models from 2010 and 2011, the power unit
     75	 * switches between mWh and mAh depending on whether the system
     76	 * is running on battery or not.  When mAh is the unit, most
     77	 * reported values are incorrect and need to be adjusted by
     78	 * 10000/design_voltage.  Verified on x201, t410, t410s, and x220.
     79	 * Pre-2010 and 2012 models appear to always report in mWh and
     80	 * are thus unaffected (tested with t42, t61, t500, x200, x300,
     81	 * and x230).  Also, in mid-2012 Lenovo issued a BIOS update for
     82	 *  the 2011 models that fixes the issue (tested on x220 with a
     83	 * post-1.29 BIOS), but as of Nov. 2012, no such update is
     84	 * available for the 2010 models.
     85	 */
     86	ACPI_BATTERY_QUIRK_THINKPAD_MAH,
     87	/* for batteries reporting current capacity with design capacity
     88	 * on a full charge, but showing degradation in full charge cap.
     89	 */
     90	ACPI_BATTERY_QUIRK_DEGRADED_FULL_CHARGE,
     91};
     92
     93struct acpi_battery {
     94	struct mutex lock;
     95	struct mutex sysfs_lock;
     96	struct power_supply *bat;
     97	struct power_supply_desc bat_desc;
     98	struct acpi_device *device;
     99	struct notifier_block pm_nb;
    100	struct list_head list;
    101	unsigned long update_time;
    102	int revision;
    103	int rate_now;
    104	int capacity_now;
    105	int voltage_now;
    106	int design_capacity;
    107	int full_charge_capacity;
    108	int technology;
    109	int design_voltage;
    110	int design_capacity_warning;
    111	int design_capacity_low;
    112	int cycle_count;
    113	int measurement_accuracy;
    114	int max_sampling_time;
    115	int min_sampling_time;
    116	int max_averaging_interval;
    117	int min_averaging_interval;
    118	int capacity_granularity_1;
    119	int capacity_granularity_2;
    120	int alarm;
    121	char model_number[32];
    122	char serial_number[32];
    123	char type[32];
    124	char oem_info[32];
    125	int state;
    126	int power_unit;
    127	unsigned long flags;
    128};
    129
    130#define to_acpi_battery(x) power_supply_get_drvdata(x)
    131
    132static inline int acpi_battery_present(struct acpi_battery *battery)
    133{
    134	return battery->device->status.battery_present;
    135}
    136
    137static int acpi_battery_technology(struct acpi_battery *battery)
    138{
    139	if (!strcasecmp("NiCd", battery->type))
    140		return POWER_SUPPLY_TECHNOLOGY_NiCd;
    141	if (!strcasecmp("NiMH", battery->type))
    142		return POWER_SUPPLY_TECHNOLOGY_NiMH;
    143	if (!strcasecmp("LION", battery->type))
    144		return POWER_SUPPLY_TECHNOLOGY_LION;
    145	if (!strncasecmp("LI-ION", battery->type, 6))
    146		return POWER_SUPPLY_TECHNOLOGY_LION;
    147	if (!strcasecmp("LiP", battery->type))
    148		return POWER_SUPPLY_TECHNOLOGY_LIPO;
    149	return POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
    150}
    151
    152static int acpi_battery_get_state(struct acpi_battery *battery);
    153
    154static int acpi_battery_is_charged(struct acpi_battery *battery)
    155{
    156	/* charging, discharging or critical low */
    157	if (battery->state != 0)
    158		return 0;
    159
    160	/* battery not reporting charge */
    161	if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN ||
    162	    battery->capacity_now == 0)
    163		return 0;
    164
    165	/* good batteries update full_charge as the batteries degrade */
    166	if (battery->full_charge_capacity == battery->capacity_now)
    167		return 1;
    168
    169	/* fallback to using design values for broken batteries */
    170	if (battery->design_capacity <= battery->capacity_now)
    171		return 1;
    172
    173	/* we don't do any sort of metric based on percentages */
    174	return 0;
    175}
    176
    177static bool acpi_battery_is_degraded(struct acpi_battery *battery)
    178{
    179	return ACPI_BATTERY_CAPACITY_VALID(battery->full_charge_capacity) &&
    180		ACPI_BATTERY_CAPACITY_VALID(battery->design_capacity) &&
    181		battery->full_charge_capacity < battery->design_capacity;
    182}
    183
    184static int acpi_battery_handle_discharging(struct acpi_battery *battery)
    185{
    186	/*
    187	 * Some devices wrongly report discharging if the battery's charge level
    188	 * was above the device's start charging threshold atm the AC adapter
    189	 * was plugged in and the device thus did not start a new charge cycle.
    190	 */
    191	if ((battery_ac_is_broken || power_supply_is_system_supplied()) &&
    192	    battery->rate_now == 0)
    193		return POWER_SUPPLY_STATUS_NOT_CHARGING;
    194
    195	return POWER_SUPPLY_STATUS_DISCHARGING;
    196}
    197
    198static int acpi_battery_get_property(struct power_supply *psy,
    199				     enum power_supply_property psp,
    200				     union power_supply_propval *val)
    201{
    202	int full_capacity = ACPI_BATTERY_VALUE_UNKNOWN, ret = 0;
    203	struct acpi_battery *battery = to_acpi_battery(psy);
    204
    205	if (acpi_battery_present(battery)) {
    206		/* run battery update only if it is present */
    207		acpi_battery_get_state(battery);
    208	} else if (psp != POWER_SUPPLY_PROP_PRESENT)
    209		return -ENODEV;
    210	switch (psp) {
    211	case POWER_SUPPLY_PROP_STATUS:
    212		if (battery->state & ACPI_BATTERY_STATE_DISCHARGING)
    213			val->intval = acpi_battery_handle_discharging(battery);
    214		else if (battery->state & ACPI_BATTERY_STATE_CHARGING)
    215			val->intval = POWER_SUPPLY_STATUS_CHARGING;
    216		else if (acpi_battery_is_charged(battery))
    217			val->intval = POWER_SUPPLY_STATUS_FULL;
    218		else
    219			val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
    220		break;
    221	case POWER_SUPPLY_PROP_PRESENT:
    222		val->intval = acpi_battery_present(battery);
    223		break;
    224	case POWER_SUPPLY_PROP_TECHNOLOGY:
    225		val->intval = acpi_battery_technology(battery);
    226		break;
    227	case POWER_SUPPLY_PROP_CYCLE_COUNT:
    228		val->intval = battery->cycle_count;
    229		break;
    230	case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
    231		if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
    232			ret = -ENODEV;
    233		else
    234			val->intval = battery->design_voltage * 1000;
    235		break;
    236	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
    237		if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
    238			ret = -ENODEV;
    239		else
    240			val->intval = battery->voltage_now * 1000;
    241		break;
    242	case POWER_SUPPLY_PROP_CURRENT_NOW:
    243	case POWER_SUPPLY_PROP_POWER_NOW:
    244		if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
    245			ret = -ENODEV;
    246		else
    247			val->intval = battery->rate_now * 1000;
    248		break;
    249	case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
    250	case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
    251		if (!ACPI_BATTERY_CAPACITY_VALID(battery->design_capacity))
    252			ret = -ENODEV;
    253		else
    254			val->intval = battery->design_capacity * 1000;
    255		break;
    256	case POWER_SUPPLY_PROP_CHARGE_FULL:
    257	case POWER_SUPPLY_PROP_ENERGY_FULL:
    258		if (!ACPI_BATTERY_CAPACITY_VALID(battery->full_charge_capacity))
    259			ret = -ENODEV;
    260		else
    261			val->intval = battery->full_charge_capacity * 1000;
    262		break;
    263	case POWER_SUPPLY_PROP_CHARGE_NOW:
    264	case POWER_SUPPLY_PROP_ENERGY_NOW:
    265		if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
    266			ret = -ENODEV;
    267		else
    268			val->intval = battery->capacity_now * 1000;
    269		break;
    270	case POWER_SUPPLY_PROP_CAPACITY:
    271		if (ACPI_BATTERY_CAPACITY_VALID(battery->full_charge_capacity))
    272			full_capacity = battery->full_charge_capacity;
    273		else if (ACPI_BATTERY_CAPACITY_VALID(battery->design_capacity))
    274			full_capacity = battery->design_capacity;
    275
    276		if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN ||
    277		    full_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
    278			ret = -ENODEV;
    279		else
    280			val->intval = battery->capacity_now * 100/
    281					full_capacity;
    282		break;
    283	case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
    284		if (battery->state & ACPI_BATTERY_STATE_CRITICAL)
    285			val->intval = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
    286		else if (test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags) &&
    287			(battery->capacity_now <= battery->alarm))
    288			val->intval = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
    289		else if (acpi_battery_is_charged(battery))
    290			val->intval = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
    291		else
    292			val->intval = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
    293		break;
    294	case POWER_SUPPLY_PROP_MODEL_NAME:
    295		val->strval = battery->model_number;
    296		break;
    297	case POWER_SUPPLY_PROP_MANUFACTURER:
    298		val->strval = battery->oem_info;
    299		break;
    300	case POWER_SUPPLY_PROP_SERIAL_NUMBER:
    301		val->strval = battery->serial_number;
    302		break;
    303	default:
    304		ret = -EINVAL;
    305	}
    306	return ret;
    307}
    308
    309static enum power_supply_property charge_battery_props[] = {
    310	POWER_SUPPLY_PROP_STATUS,
    311	POWER_SUPPLY_PROP_PRESENT,
    312	POWER_SUPPLY_PROP_TECHNOLOGY,
    313	POWER_SUPPLY_PROP_CYCLE_COUNT,
    314	POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
    315	POWER_SUPPLY_PROP_VOLTAGE_NOW,
    316	POWER_SUPPLY_PROP_CURRENT_NOW,
    317	POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
    318	POWER_SUPPLY_PROP_CHARGE_FULL,
    319	POWER_SUPPLY_PROP_CHARGE_NOW,
    320	POWER_SUPPLY_PROP_CAPACITY,
    321	POWER_SUPPLY_PROP_CAPACITY_LEVEL,
    322	POWER_SUPPLY_PROP_MODEL_NAME,
    323	POWER_SUPPLY_PROP_MANUFACTURER,
    324	POWER_SUPPLY_PROP_SERIAL_NUMBER,
    325};
    326
    327static enum power_supply_property charge_battery_full_cap_broken_props[] = {
    328	POWER_SUPPLY_PROP_STATUS,
    329	POWER_SUPPLY_PROP_PRESENT,
    330	POWER_SUPPLY_PROP_TECHNOLOGY,
    331	POWER_SUPPLY_PROP_CYCLE_COUNT,
    332	POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
    333	POWER_SUPPLY_PROP_VOLTAGE_NOW,
    334	POWER_SUPPLY_PROP_CURRENT_NOW,
    335	POWER_SUPPLY_PROP_CHARGE_NOW,
    336	POWER_SUPPLY_PROP_MODEL_NAME,
    337	POWER_SUPPLY_PROP_MANUFACTURER,
    338	POWER_SUPPLY_PROP_SERIAL_NUMBER,
    339};
    340
    341static enum power_supply_property energy_battery_props[] = {
    342	POWER_SUPPLY_PROP_STATUS,
    343	POWER_SUPPLY_PROP_PRESENT,
    344	POWER_SUPPLY_PROP_TECHNOLOGY,
    345	POWER_SUPPLY_PROP_CYCLE_COUNT,
    346	POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
    347	POWER_SUPPLY_PROP_VOLTAGE_NOW,
    348	POWER_SUPPLY_PROP_POWER_NOW,
    349	POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
    350	POWER_SUPPLY_PROP_ENERGY_FULL,
    351	POWER_SUPPLY_PROP_ENERGY_NOW,
    352	POWER_SUPPLY_PROP_CAPACITY,
    353	POWER_SUPPLY_PROP_CAPACITY_LEVEL,
    354	POWER_SUPPLY_PROP_MODEL_NAME,
    355	POWER_SUPPLY_PROP_MANUFACTURER,
    356	POWER_SUPPLY_PROP_SERIAL_NUMBER,
    357};
    358
    359static enum power_supply_property energy_battery_full_cap_broken_props[] = {
    360	POWER_SUPPLY_PROP_STATUS,
    361	POWER_SUPPLY_PROP_PRESENT,
    362	POWER_SUPPLY_PROP_TECHNOLOGY,
    363	POWER_SUPPLY_PROP_CYCLE_COUNT,
    364	POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
    365	POWER_SUPPLY_PROP_VOLTAGE_NOW,
    366	POWER_SUPPLY_PROP_POWER_NOW,
    367	POWER_SUPPLY_PROP_ENERGY_NOW,
    368	POWER_SUPPLY_PROP_MODEL_NAME,
    369	POWER_SUPPLY_PROP_MANUFACTURER,
    370	POWER_SUPPLY_PROP_SERIAL_NUMBER,
    371};
    372
    373/* Battery Management */
    374struct acpi_offsets {
    375	size_t offset;		/* offset inside struct acpi_sbs_battery */
    376	u8 mode;		/* int or string? */
    377};
    378
    379static const struct acpi_offsets state_offsets[] = {
    380	{offsetof(struct acpi_battery, state), 0},
    381	{offsetof(struct acpi_battery, rate_now), 0},
    382	{offsetof(struct acpi_battery, capacity_now), 0},
    383	{offsetof(struct acpi_battery, voltage_now), 0},
    384};
    385
    386static const struct acpi_offsets info_offsets[] = {
    387	{offsetof(struct acpi_battery, power_unit), 0},
    388	{offsetof(struct acpi_battery, design_capacity), 0},
    389	{offsetof(struct acpi_battery, full_charge_capacity), 0},
    390	{offsetof(struct acpi_battery, technology), 0},
    391	{offsetof(struct acpi_battery, design_voltage), 0},
    392	{offsetof(struct acpi_battery, design_capacity_warning), 0},
    393	{offsetof(struct acpi_battery, design_capacity_low), 0},
    394	{offsetof(struct acpi_battery, capacity_granularity_1), 0},
    395	{offsetof(struct acpi_battery, capacity_granularity_2), 0},
    396	{offsetof(struct acpi_battery, model_number), 1},
    397	{offsetof(struct acpi_battery, serial_number), 1},
    398	{offsetof(struct acpi_battery, type), 1},
    399	{offsetof(struct acpi_battery, oem_info), 1},
    400};
    401
    402static const struct acpi_offsets extended_info_offsets[] = {
    403	{offsetof(struct acpi_battery, revision), 0},
    404	{offsetof(struct acpi_battery, power_unit), 0},
    405	{offsetof(struct acpi_battery, design_capacity), 0},
    406	{offsetof(struct acpi_battery, full_charge_capacity), 0},
    407	{offsetof(struct acpi_battery, technology), 0},
    408	{offsetof(struct acpi_battery, design_voltage), 0},
    409	{offsetof(struct acpi_battery, design_capacity_warning), 0},
    410	{offsetof(struct acpi_battery, design_capacity_low), 0},
    411	{offsetof(struct acpi_battery, cycle_count), 0},
    412	{offsetof(struct acpi_battery, measurement_accuracy), 0},
    413	{offsetof(struct acpi_battery, max_sampling_time), 0},
    414	{offsetof(struct acpi_battery, min_sampling_time), 0},
    415	{offsetof(struct acpi_battery, max_averaging_interval), 0},
    416	{offsetof(struct acpi_battery, min_averaging_interval), 0},
    417	{offsetof(struct acpi_battery, capacity_granularity_1), 0},
    418	{offsetof(struct acpi_battery, capacity_granularity_2), 0},
    419	{offsetof(struct acpi_battery, model_number), 1},
    420	{offsetof(struct acpi_battery, serial_number), 1},
    421	{offsetof(struct acpi_battery, type), 1},
    422	{offsetof(struct acpi_battery, oem_info), 1},
    423};
    424
    425static int extract_package(struct acpi_battery *battery,
    426			   union acpi_object *package,
    427			   const struct acpi_offsets *offsets, int num)
    428{
    429	int i;
    430	union acpi_object *element;
    431
    432	if (package->type != ACPI_TYPE_PACKAGE)
    433		return -EFAULT;
    434	for (i = 0; i < num; ++i) {
    435		if (package->package.count <= i)
    436			return -EFAULT;
    437		element = &package->package.elements[i];
    438		if (offsets[i].mode) {
    439			u8 *ptr = (u8 *)battery + offsets[i].offset;
    440
    441			if (element->type == ACPI_TYPE_STRING ||
    442			    element->type == ACPI_TYPE_BUFFER)
    443				strncpy(ptr, element->string.pointer, 32);
    444			else if (element->type == ACPI_TYPE_INTEGER) {
    445				strncpy(ptr, (u8 *)&element->integer.value,
    446					sizeof(u64));
    447				ptr[sizeof(u64)] = 0;
    448			} else
    449				*ptr = 0; /* don't have value */
    450		} else {
    451			int *x = (int *)((u8 *)battery + offsets[i].offset);
    452			*x = (element->type == ACPI_TYPE_INTEGER) ?
    453				element->integer.value : -1;
    454		}
    455	}
    456	return 0;
    457}
    458
    459static int acpi_battery_get_status(struct acpi_battery *battery)
    460{
    461	if (acpi_bus_get_status(battery->device)) {
    462		acpi_handle_info(battery->device->handle,
    463				 "_STA evaluation failed\n");
    464		return -ENODEV;
    465	}
    466	return 0;
    467}
    468
    469
    470static int extract_battery_info(const int use_bix,
    471			 struct acpi_battery *battery,
    472			 const struct acpi_buffer *buffer)
    473{
    474	int result = -EFAULT;
    475
    476	if (use_bix && battery_bix_broken_package)
    477		result = extract_package(battery, buffer->pointer,
    478				extended_info_offsets + 1,
    479				ARRAY_SIZE(extended_info_offsets) - 1);
    480	else if (use_bix)
    481		result = extract_package(battery, buffer->pointer,
    482				extended_info_offsets,
    483				ARRAY_SIZE(extended_info_offsets));
    484	else
    485		result = extract_package(battery, buffer->pointer,
    486				info_offsets, ARRAY_SIZE(info_offsets));
    487	if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
    488		battery->full_charge_capacity = battery->design_capacity;
    489	if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
    490	    battery->power_unit && battery->design_voltage) {
    491		battery->design_capacity = battery->design_capacity *
    492		    10000 / battery->design_voltage;
    493		battery->full_charge_capacity = battery->full_charge_capacity *
    494		    10000 / battery->design_voltage;
    495		battery->design_capacity_warning =
    496		    battery->design_capacity_warning *
    497		    10000 / battery->design_voltage;
    498		/* Curiously, design_capacity_low, unlike the rest of them,
    499		 *  is correct.
    500		 */
    501		/* capacity_granularity_* equal 1 on the systems tested, so
    502		 * it's impossible to tell if they would need an adjustment
    503		 * or not if their values were higher.
    504		 */
    505	}
    506	if (test_bit(ACPI_BATTERY_QUIRK_DEGRADED_FULL_CHARGE, &battery->flags) &&
    507	    battery->capacity_now > battery->full_charge_capacity)
    508		battery->capacity_now = battery->full_charge_capacity;
    509
    510	return result;
    511}
    512
    513static int acpi_battery_get_info(struct acpi_battery *battery)
    514{
    515	const int xinfo = test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
    516	int use_bix;
    517	int result = -ENODEV;
    518
    519	if (!acpi_battery_present(battery))
    520		return 0;
    521
    522
    523	for (use_bix = xinfo ? 1 : 0; use_bix >= 0; use_bix--) {
    524		struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
    525		acpi_status status = AE_ERROR;
    526
    527		mutex_lock(&battery->lock);
    528		status = acpi_evaluate_object(battery->device->handle,
    529					      use_bix ? "_BIX":"_BIF",
    530					      NULL, &buffer);
    531		mutex_unlock(&battery->lock);
    532
    533		if (ACPI_FAILURE(status)) {
    534			acpi_handle_info(battery->device->handle,
    535					 "%s evaluation failed: %s\n",
    536					 use_bix ? "_BIX":"_BIF",
    537					 acpi_format_exception(status));
    538		} else {
    539			result = extract_battery_info(use_bix,
    540						      battery,
    541						      &buffer);
    542
    543			kfree(buffer.pointer);
    544			break;
    545		}
    546	}
    547
    548	if (!result && !use_bix && xinfo)
    549		pr_warn(FW_BUG "The _BIX method is broken, using _BIF.\n");
    550
    551	return result;
    552}
    553
    554static int acpi_battery_get_state(struct acpi_battery *battery)
    555{
    556	int result = 0;
    557	acpi_status status = 0;
    558	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
    559
    560	if (!acpi_battery_present(battery))
    561		return 0;
    562
    563	if (battery->update_time &&
    564	    time_before(jiffies, battery->update_time +
    565			msecs_to_jiffies(cache_time)))
    566		return 0;
    567
    568	mutex_lock(&battery->lock);
    569	status = acpi_evaluate_object(battery->device->handle, "_BST",
    570				      NULL, &buffer);
    571	mutex_unlock(&battery->lock);
    572
    573	if (ACPI_FAILURE(status)) {
    574		acpi_handle_info(battery->device->handle,
    575				 "_BST evaluation failed: %s",
    576				 acpi_format_exception(status));
    577		return -ENODEV;
    578	}
    579
    580	result = extract_package(battery, buffer.pointer,
    581				 state_offsets, ARRAY_SIZE(state_offsets));
    582	battery->update_time = jiffies;
    583	kfree(buffer.pointer);
    584
    585	/* For buggy DSDTs that report negative 16-bit values for either
    586	 * charging or discharging current and/or report 0 as 65536
    587	 * due to bad math.
    588	 */
    589	if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA &&
    590		battery->rate_now != ACPI_BATTERY_VALUE_UNKNOWN &&
    591		(s16)(battery->rate_now) < 0) {
    592		battery->rate_now = abs((s16)battery->rate_now);
    593		pr_warn_once(FW_BUG "(dis)charge rate invalid.\n");
    594	}
    595
    596	if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags)
    597	    && battery->capacity_now >= 0 && battery->capacity_now <= 100)
    598		battery->capacity_now = (battery->capacity_now *
    599				battery->full_charge_capacity) / 100;
    600	if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
    601	    battery->power_unit && battery->design_voltage) {
    602		battery->capacity_now = battery->capacity_now *
    603		    10000 / battery->design_voltage;
    604	}
    605	if (test_bit(ACPI_BATTERY_QUIRK_DEGRADED_FULL_CHARGE, &battery->flags) &&
    606	    battery->capacity_now > battery->full_charge_capacity)
    607		battery->capacity_now = battery->full_charge_capacity;
    608
    609	return result;
    610}
    611
    612static int acpi_battery_set_alarm(struct acpi_battery *battery)
    613{
    614	acpi_status status = 0;
    615
    616	if (!acpi_battery_present(battery) ||
    617	    !test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags))
    618		return -ENODEV;
    619
    620	mutex_lock(&battery->lock);
    621	status = acpi_execute_simple_method(battery->device->handle, "_BTP",
    622					    battery->alarm);
    623	mutex_unlock(&battery->lock);
    624
    625	if (ACPI_FAILURE(status))
    626		return -ENODEV;
    627
    628	acpi_handle_debug(battery->device->handle, "Alarm set to %d\n",
    629			  battery->alarm);
    630
    631	return 0;
    632}
    633
    634static int acpi_battery_init_alarm(struct acpi_battery *battery)
    635{
    636	/* See if alarms are supported, and if so, set default */
    637	if (!acpi_has_method(battery->device->handle, "_BTP")) {
    638		clear_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
    639		return 0;
    640	}
    641	set_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
    642	if (!battery->alarm)
    643		battery->alarm = battery->design_capacity_warning;
    644	return acpi_battery_set_alarm(battery);
    645}
    646
    647static ssize_t acpi_battery_alarm_show(struct device *dev,
    648					struct device_attribute *attr,
    649					char *buf)
    650{
    651	struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
    652
    653	return sprintf(buf, "%d\n", battery->alarm * 1000);
    654}
    655
    656static ssize_t acpi_battery_alarm_store(struct device *dev,
    657					struct device_attribute *attr,
    658					const char *buf, size_t count)
    659{
    660	unsigned long x;
    661	struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
    662
    663	if (sscanf(buf, "%lu\n", &x) == 1)
    664		battery->alarm = x/1000;
    665	if (acpi_battery_present(battery))
    666		acpi_battery_set_alarm(battery);
    667	return count;
    668}
    669
    670static const struct device_attribute alarm_attr = {
    671	.attr = {.name = "alarm", .mode = 0644},
    672	.show = acpi_battery_alarm_show,
    673	.store = acpi_battery_alarm_store,
    674};
    675
    676/*
    677 * The Battery Hooking API
    678 *
    679 * This API is used inside other drivers that need to expose
    680 * platform-specific behaviour within the generic driver in a
    681 * generic way.
    682 *
    683 */
    684
    685static LIST_HEAD(acpi_battery_list);
    686static LIST_HEAD(battery_hook_list);
    687static DEFINE_MUTEX(hook_mutex);
    688
    689static void __battery_hook_unregister(struct acpi_battery_hook *hook, int lock)
    690{
    691	struct acpi_battery *battery;
    692	/*
    693	 * In order to remove a hook, we first need to
    694	 * de-register all the batteries that are registered.
    695	 */
    696	if (lock)
    697		mutex_lock(&hook_mutex);
    698	list_for_each_entry(battery, &acpi_battery_list, list) {
    699		hook->remove_battery(battery->bat);
    700	}
    701	list_del(&hook->list);
    702	if (lock)
    703		mutex_unlock(&hook_mutex);
    704	pr_info("extension unregistered: %s\n", hook->name);
    705}
    706
    707void battery_hook_unregister(struct acpi_battery_hook *hook)
    708{
    709	__battery_hook_unregister(hook, 1);
    710}
    711EXPORT_SYMBOL_GPL(battery_hook_unregister);
    712
    713void battery_hook_register(struct acpi_battery_hook *hook)
    714{
    715	struct acpi_battery *battery;
    716
    717	mutex_lock(&hook_mutex);
    718	INIT_LIST_HEAD(&hook->list);
    719	list_add(&hook->list, &battery_hook_list);
    720	/*
    721	 * Now that the driver is registered, we need
    722	 * to notify the hook that a battery is available
    723	 * for each battery, so that the driver may add
    724	 * its attributes.
    725	 */
    726	list_for_each_entry(battery, &acpi_battery_list, list) {
    727		if (hook->add_battery(battery->bat)) {
    728			/*
    729			 * If a add-battery returns non-zero,
    730			 * the registration of the extension has failed,
    731			 * and we will not add it to the list of loaded
    732			 * hooks.
    733			 */
    734			pr_err("extension failed to load: %s", hook->name);
    735			__battery_hook_unregister(hook, 0);
    736			goto end;
    737		}
    738	}
    739	pr_info("new extension: %s\n", hook->name);
    740end:
    741	mutex_unlock(&hook_mutex);
    742}
    743EXPORT_SYMBOL_GPL(battery_hook_register);
    744
    745/*
    746 * This function gets called right after the battery sysfs
    747 * attributes have been added, so that the drivers that
    748 * define custom sysfs attributes can add their own.
    749 */
    750static void battery_hook_add_battery(struct acpi_battery *battery)
    751{
    752	struct acpi_battery_hook *hook_node, *tmp;
    753
    754	mutex_lock(&hook_mutex);
    755	INIT_LIST_HEAD(&battery->list);
    756	list_add(&battery->list, &acpi_battery_list);
    757	/*
    758	 * Since we added a new battery to the list, we need to
    759	 * iterate over the hooks and call add_battery for each
    760	 * hook that was registered. This usually happens
    761	 * when a battery gets hotplugged or initialized
    762	 * during the battery module initialization.
    763	 */
    764	list_for_each_entry_safe(hook_node, tmp, &battery_hook_list, list) {
    765		if (hook_node->add_battery(battery->bat)) {
    766			/*
    767			 * The notification of the extensions has failed, to
    768			 * prevent further errors we will unload the extension.
    769			 */
    770			pr_err("error in extension, unloading: %s",
    771					hook_node->name);
    772			__battery_hook_unregister(hook_node, 0);
    773		}
    774	}
    775	mutex_unlock(&hook_mutex);
    776}
    777
    778static void battery_hook_remove_battery(struct acpi_battery *battery)
    779{
    780	struct acpi_battery_hook *hook;
    781
    782	mutex_lock(&hook_mutex);
    783	/*
    784	 * Before removing the hook, we need to remove all
    785	 * custom attributes from the battery.
    786	 */
    787	list_for_each_entry(hook, &battery_hook_list, list) {
    788		hook->remove_battery(battery->bat);
    789	}
    790	/* Then, just remove the battery from the list */
    791	list_del(&battery->list);
    792	mutex_unlock(&hook_mutex);
    793}
    794
    795static void __exit battery_hook_exit(void)
    796{
    797	struct acpi_battery_hook *hook;
    798	struct acpi_battery_hook *ptr;
    799	/*
    800	 * At this point, the acpi_bus_unregister_driver()
    801	 * has called remove for all batteries. We just
    802	 * need to remove the hooks.
    803	 */
    804	list_for_each_entry_safe(hook, ptr, &battery_hook_list, list) {
    805		__battery_hook_unregister(hook, 1);
    806	}
    807	mutex_destroy(&hook_mutex);
    808}
    809
    810static int sysfs_add_battery(struct acpi_battery *battery)
    811{
    812	struct power_supply_config psy_cfg = { .drv_data = battery, };
    813	bool full_cap_broken = false;
    814
    815	if (!ACPI_BATTERY_CAPACITY_VALID(battery->full_charge_capacity) &&
    816	    !ACPI_BATTERY_CAPACITY_VALID(battery->design_capacity))
    817		full_cap_broken = true;
    818
    819	if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) {
    820		if (full_cap_broken) {
    821			battery->bat_desc.properties =
    822			    charge_battery_full_cap_broken_props;
    823			battery->bat_desc.num_properties =
    824			    ARRAY_SIZE(charge_battery_full_cap_broken_props);
    825		} else {
    826			battery->bat_desc.properties = charge_battery_props;
    827			battery->bat_desc.num_properties =
    828			    ARRAY_SIZE(charge_battery_props);
    829		}
    830	} else {
    831		if (full_cap_broken) {
    832			battery->bat_desc.properties =
    833			    energy_battery_full_cap_broken_props;
    834			battery->bat_desc.num_properties =
    835			    ARRAY_SIZE(energy_battery_full_cap_broken_props);
    836		} else {
    837			battery->bat_desc.properties = energy_battery_props;
    838			battery->bat_desc.num_properties =
    839			    ARRAY_SIZE(energy_battery_props);
    840		}
    841	}
    842
    843	battery->bat_desc.name = acpi_device_bid(battery->device);
    844	battery->bat_desc.type = POWER_SUPPLY_TYPE_BATTERY;
    845	battery->bat_desc.get_property = acpi_battery_get_property;
    846
    847	battery->bat = power_supply_register_no_ws(&battery->device->dev,
    848				&battery->bat_desc, &psy_cfg);
    849
    850	if (IS_ERR(battery->bat)) {
    851		int result = PTR_ERR(battery->bat);
    852
    853		battery->bat = NULL;
    854		return result;
    855	}
    856	battery_hook_add_battery(battery);
    857	return device_create_file(&battery->bat->dev, &alarm_attr);
    858}
    859
    860static void sysfs_remove_battery(struct acpi_battery *battery)
    861{
    862	mutex_lock(&battery->sysfs_lock);
    863	if (!battery->bat) {
    864		mutex_unlock(&battery->sysfs_lock);
    865		return;
    866	}
    867	battery_hook_remove_battery(battery);
    868	device_remove_file(&battery->bat->dev, &alarm_attr);
    869	power_supply_unregister(battery->bat);
    870	battery->bat = NULL;
    871	mutex_unlock(&battery->sysfs_lock);
    872}
    873
    874static void find_battery(const struct dmi_header *dm, void *private)
    875{
    876	struct acpi_battery *battery = (struct acpi_battery *)private;
    877	/* Note: the hardcoded offsets below have been extracted from
    878	 * the source code of dmidecode.
    879	 */
    880	if (dm->type == DMI_ENTRY_PORTABLE_BATTERY && dm->length >= 8) {
    881		const u8 *dmi_data = (const u8 *)(dm + 1);
    882		int dmi_capacity = get_unaligned((const u16 *)(dmi_data + 6));
    883
    884		if (dm->length >= 18)
    885			dmi_capacity *= dmi_data[17];
    886		if (battery->design_capacity * battery->design_voltage / 1000
    887		    != dmi_capacity &&
    888		    battery->design_capacity * 10 == dmi_capacity)
    889			set_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
    890				&battery->flags);
    891	}
    892}
    893
    894/*
    895 * According to the ACPI spec, some kinds of primary batteries can
    896 * report percentage battery remaining capacity directly to OS.
    897 * In this case, it reports the Last Full Charged Capacity == 100
    898 * and BatteryPresentRate == 0xFFFFFFFF.
    899 *
    900 * Now we found some battery reports percentage remaining capacity
    901 * even if it's rechargeable.
    902 * https://bugzilla.kernel.org/show_bug.cgi?id=15979
    903 *
    904 * Handle this correctly so that they won't break userspace.
    905 */
    906static void acpi_battery_quirks(struct acpi_battery *battery)
    907{
    908	if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
    909		return;
    910
    911	if (battery->full_charge_capacity == 100 &&
    912		battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN &&
    913		battery->capacity_now >= 0 && battery->capacity_now <= 100) {
    914		set_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags);
    915		battery->full_charge_capacity = battery->design_capacity;
    916		battery->capacity_now = (battery->capacity_now *
    917				battery->full_charge_capacity) / 100;
    918	}
    919
    920	if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags))
    921		return;
    922
    923	if (battery->power_unit && dmi_name_in_vendors("LENOVO")) {
    924		const char *s;
    925
    926		s = dmi_get_system_info(DMI_PRODUCT_VERSION);
    927		if (s && !strncasecmp(s, "ThinkPad", 8)) {
    928			dmi_walk(find_battery, battery);
    929			if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
    930				     &battery->flags) &&
    931			    battery->design_voltage) {
    932				battery->design_capacity =
    933				    battery->design_capacity *
    934				    10000 / battery->design_voltage;
    935				battery->full_charge_capacity =
    936				    battery->full_charge_capacity *
    937				    10000 / battery->design_voltage;
    938				battery->design_capacity_warning =
    939				    battery->design_capacity_warning *
    940				    10000 / battery->design_voltage;
    941				battery->capacity_now = battery->capacity_now *
    942				    10000 / battery->design_voltage;
    943			}
    944		}
    945	}
    946
    947	if (test_bit(ACPI_BATTERY_QUIRK_DEGRADED_FULL_CHARGE, &battery->flags))
    948		return;
    949
    950	if (acpi_battery_is_degraded(battery) &&
    951	    battery->capacity_now > battery->full_charge_capacity) {
    952		set_bit(ACPI_BATTERY_QUIRK_DEGRADED_FULL_CHARGE, &battery->flags);
    953		battery->capacity_now = battery->full_charge_capacity;
    954	}
    955}
    956
    957static int acpi_battery_update(struct acpi_battery *battery, bool resume)
    958{
    959	int result = acpi_battery_get_status(battery);
    960
    961	if (result)
    962		return result;
    963
    964	if (!acpi_battery_present(battery)) {
    965		sysfs_remove_battery(battery);
    966		battery->update_time = 0;
    967		return 0;
    968	}
    969
    970	if (resume)
    971		return 0;
    972
    973	if (!battery->update_time) {
    974		result = acpi_battery_get_info(battery);
    975		if (result)
    976			return result;
    977		acpi_battery_init_alarm(battery);
    978	}
    979
    980	result = acpi_battery_get_state(battery);
    981	if (result)
    982		return result;
    983	acpi_battery_quirks(battery);
    984
    985	if (!battery->bat) {
    986		result = sysfs_add_battery(battery);
    987		if (result)
    988			return result;
    989	}
    990
    991	/*
    992	 * Wakeup the system if battery is critical low
    993	 * or lower than the alarm level
    994	 */
    995	if ((battery->state & ACPI_BATTERY_STATE_CRITICAL) ||
    996	    (test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags) &&
    997	     (battery->capacity_now <= battery->alarm)))
    998		acpi_pm_wakeup_event(&battery->device->dev);
    999
   1000	return result;
   1001}
   1002
   1003static void acpi_battery_refresh(struct acpi_battery *battery)
   1004{
   1005	int power_unit;
   1006
   1007	if (!battery->bat)
   1008		return;
   1009
   1010	power_unit = battery->power_unit;
   1011
   1012	acpi_battery_get_info(battery);
   1013
   1014	if (power_unit == battery->power_unit)
   1015		return;
   1016
   1017	/* The battery has changed its reporting units. */
   1018	sysfs_remove_battery(battery);
   1019	sysfs_add_battery(battery);
   1020}
   1021
   1022/* Driver Interface */
   1023static void acpi_battery_notify(struct acpi_device *device, u32 event)
   1024{
   1025	struct acpi_battery *battery = acpi_driver_data(device);
   1026	struct power_supply *old;
   1027
   1028	if (!battery)
   1029		return;
   1030	old = battery->bat;
   1031	/*
   1032	 * On Acer Aspire V5-573G notifications are sometimes triggered too
   1033	 * early. For example, when AC is unplugged and notification is
   1034	 * triggered, battery state is still reported as "Full", and changes to
   1035	 * "Discharging" only after short delay, without any notification.
   1036	 */
   1037	if (battery_notification_delay_ms > 0)
   1038		msleep(battery_notification_delay_ms);
   1039	if (event == ACPI_BATTERY_NOTIFY_INFO)
   1040		acpi_battery_refresh(battery);
   1041	acpi_battery_update(battery, false);
   1042	acpi_bus_generate_netlink_event(device->pnp.device_class,
   1043					dev_name(&device->dev), event,
   1044					acpi_battery_present(battery));
   1045	acpi_notifier_call_chain(device, event, acpi_battery_present(battery));
   1046	/* acpi_battery_update could remove power_supply object */
   1047	if (old && battery->bat)
   1048		power_supply_changed(battery->bat);
   1049}
   1050
   1051static int battery_notify(struct notifier_block *nb,
   1052			       unsigned long mode, void *_unused)
   1053{
   1054	struct acpi_battery *battery = container_of(nb, struct acpi_battery,
   1055						    pm_nb);
   1056	int result;
   1057
   1058	switch (mode) {
   1059	case PM_POST_HIBERNATION:
   1060	case PM_POST_SUSPEND:
   1061		if (!acpi_battery_present(battery))
   1062			return 0;
   1063
   1064		if (battery->bat) {
   1065			acpi_battery_refresh(battery);
   1066		} else {
   1067			result = acpi_battery_get_info(battery);
   1068			if (result)
   1069				return result;
   1070
   1071			result = sysfs_add_battery(battery);
   1072			if (result)
   1073				return result;
   1074		}
   1075
   1076		acpi_battery_init_alarm(battery);
   1077		acpi_battery_get_state(battery);
   1078		break;
   1079	}
   1080
   1081	return 0;
   1082}
   1083
   1084static int __init
   1085battery_bix_broken_package_quirk(const struct dmi_system_id *d)
   1086{
   1087	battery_bix_broken_package = 1;
   1088	return 0;
   1089}
   1090
   1091static int __init
   1092battery_notification_delay_quirk(const struct dmi_system_id *d)
   1093{
   1094	battery_notification_delay_ms = 1000;
   1095	return 0;
   1096}
   1097
   1098static int __init
   1099battery_ac_is_broken_quirk(const struct dmi_system_id *d)
   1100{
   1101	battery_ac_is_broken = 1;
   1102	return 0;
   1103}
   1104
   1105static const struct dmi_system_id bat_dmi_table[] __initconst = {
   1106	{
   1107		/* NEC LZ750/LS */
   1108		.callback = battery_bix_broken_package_quirk,
   1109		.matches = {
   1110			DMI_MATCH(DMI_SYS_VENDOR, "NEC"),
   1111			DMI_MATCH(DMI_PRODUCT_NAME, "PC-LZ750LS"),
   1112		},
   1113	},
   1114	{
   1115		/* Acer Aspire V5-573G */
   1116		.callback = battery_notification_delay_quirk,
   1117		.matches = {
   1118			DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
   1119			DMI_MATCH(DMI_PRODUCT_NAME, "Aspire V5-573G"),
   1120		},
   1121	},
   1122	{
   1123		/* Point of View mobii wintab p800w */
   1124		.callback = battery_ac_is_broken_quirk,
   1125		.matches = {
   1126			DMI_MATCH(DMI_BOARD_VENDOR, "AMI Corporation"),
   1127			DMI_MATCH(DMI_BOARD_NAME, "Aptio CRB"),
   1128			DMI_MATCH(DMI_BIOS_VERSION, "3BAIR1013"),
   1129			/* Above matches are too generic, add bios-date match */
   1130			DMI_MATCH(DMI_BIOS_DATE, "08/22/2014"),
   1131		},
   1132	},
   1133	{
   1134		/* Microsoft Surface Go 3 */
   1135		.callback = battery_notification_delay_quirk,
   1136		.matches = {
   1137			DMI_MATCH(DMI_SYS_VENDOR, "Microsoft Corporation"),
   1138			DMI_MATCH(DMI_PRODUCT_NAME, "Surface Go 3"),
   1139		},
   1140	},
   1141	{},
   1142};
   1143
   1144/*
   1145 * Some machines'(E,G Lenovo Z480) ECs are not stable
   1146 * during boot up and this causes battery driver fails to be
   1147 * probed due to failure of getting battery information
   1148 * from EC sometimes. After several retries, the operation
   1149 * may work. So add retry code here and 20ms sleep between
   1150 * every retries.
   1151 */
   1152static int acpi_battery_update_retry(struct acpi_battery *battery)
   1153{
   1154	int retry, ret;
   1155
   1156	for (retry = 5; retry; retry--) {
   1157		ret = acpi_battery_update(battery, false);
   1158		if (!ret)
   1159			break;
   1160
   1161		msleep(20);
   1162	}
   1163	return ret;
   1164}
   1165
   1166static int acpi_battery_add(struct acpi_device *device)
   1167{
   1168	int result = 0;
   1169	struct acpi_battery *battery = NULL;
   1170
   1171	if (!device)
   1172		return -EINVAL;
   1173
   1174	if (device->dep_unmet)
   1175		return -EPROBE_DEFER;
   1176
   1177	battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
   1178	if (!battery)
   1179		return -ENOMEM;
   1180	battery->device = device;
   1181	strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
   1182	strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
   1183	device->driver_data = battery;
   1184	mutex_init(&battery->lock);
   1185	mutex_init(&battery->sysfs_lock);
   1186	if (acpi_has_method(battery->device->handle, "_BIX"))
   1187		set_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
   1188
   1189	result = acpi_battery_update_retry(battery);
   1190	if (result)
   1191		goto fail;
   1192
   1193	pr_info("Slot [%s] (battery %s)\n", acpi_device_bid(device),
   1194		device->status.battery_present ? "present" : "absent");
   1195
   1196	battery->pm_nb.notifier_call = battery_notify;
   1197	register_pm_notifier(&battery->pm_nb);
   1198
   1199	device_init_wakeup(&device->dev, 1);
   1200
   1201	return result;
   1202
   1203fail:
   1204	sysfs_remove_battery(battery);
   1205	mutex_destroy(&battery->lock);
   1206	mutex_destroy(&battery->sysfs_lock);
   1207	kfree(battery);
   1208	return result;
   1209}
   1210
   1211static int acpi_battery_remove(struct acpi_device *device)
   1212{
   1213	struct acpi_battery *battery = NULL;
   1214
   1215	if (!device || !acpi_driver_data(device))
   1216		return -EINVAL;
   1217	device_init_wakeup(&device->dev, 0);
   1218	battery = acpi_driver_data(device);
   1219	unregister_pm_notifier(&battery->pm_nb);
   1220	sysfs_remove_battery(battery);
   1221	mutex_destroy(&battery->lock);
   1222	mutex_destroy(&battery->sysfs_lock);
   1223	kfree(battery);
   1224	return 0;
   1225}
   1226
   1227#ifdef CONFIG_PM_SLEEP
   1228/* this is needed to learn about changes made in suspended state */
   1229static int acpi_battery_resume(struct device *dev)
   1230{
   1231	struct acpi_battery *battery;
   1232
   1233	if (!dev)
   1234		return -EINVAL;
   1235
   1236	battery = acpi_driver_data(to_acpi_device(dev));
   1237	if (!battery)
   1238		return -EINVAL;
   1239
   1240	battery->update_time = 0;
   1241	acpi_battery_update(battery, true);
   1242	return 0;
   1243}
   1244#else
   1245#define acpi_battery_resume NULL
   1246#endif
   1247
   1248static SIMPLE_DEV_PM_OPS(acpi_battery_pm, NULL, acpi_battery_resume);
   1249
   1250static struct acpi_driver acpi_battery_driver = {
   1251	.name = "battery",
   1252	.class = ACPI_BATTERY_CLASS,
   1253	.ids = battery_device_ids,
   1254	.flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
   1255	.ops = {
   1256		.add = acpi_battery_add,
   1257		.remove = acpi_battery_remove,
   1258		.notify = acpi_battery_notify,
   1259		},
   1260	.drv.pm = &acpi_battery_pm,
   1261};
   1262
   1263static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie)
   1264{
   1265	int result;
   1266
   1267	if (acpi_quirk_skip_acpi_ac_and_battery())
   1268		return;
   1269
   1270	dmi_check_system(bat_dmi_table);
   1271
   1272	result = acpi_bus_register_driver(&acpi_battery_driver);
   1273	battery_driver_registered = (result == 0);
   1274}
   1275
   1276static int __init acpi_battery_init(void)
   1277{
   1278	if (acpi_disabled)
   1279		return -ENODEV;
   1280
   1281	async_cookie = async_schedule(acpi_battery_init_async, NULL);
   1282	return 0;
   1283}
   1284
   1285static void __exit acpi_battery_exit(void)
   1286{
   1287	async_synchronize_cookie(async_cookie + 1);
   1288	if (battery_driver_registered) {
   1289		acpi_bus_unregister_driver(&acpi_battery_driver);
   1290		battery_hook_exit();
   1291	}
   1292}
   1293
   1294module_init(acpi_battery_init);
   1295module_exit(acpi_battery_exit);