Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
Alexey Starikovskiy | aa650bb | 2007-09-26 19:42:58 +0400 | [diff] [blame] | 2 | * battery.c - ACPI Battery Driver (Revision: 2.0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3 | * |
Alexey Starikovskiy | aa650bb | 2007-09-26 19:42:58 +0400 | [diff] [blame] | 4 | * Copyright (C) 2007 Alexey Starikovskiy <astarikovskiy@suse.de> |
| 5 | * Copyright (C) 2004-2007 Vladimir Lebedev <vladimir.p.lebedev@intel.com> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 6 | * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com> |
| 7 | * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com> |
| 8 | * |
| 9 | * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| 10 | * |
| 11 | * This program is free software; you can redistribute it and/or modify |
| 12 | * it under the terms of the GNU General Public License as published by |
| 13 | * the Free Software Foundation; either version 2 of the License, or (at |
| 14 | * your option) any later version. |
| 15 | * |
| 16 | * This program is distributed in the hope that it will be useful, but |
| 17 | * WITHOUT ANY WARRANTY; without even the implied warranty of |
| 18 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 19 | * General Public License for more details. |
| 20 | * |
| 21 | * You should have received a copy of the GNU General Public License along |
| 22 | * with this program; if not, write to the Free Software Foundation, Inc., |
| 23 | * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
| 24 | * |
| 25 | * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| 26 | */ |
| 27 | |
| 28 | #include <linux/kernel.h> |
| 29 | #include <linux/module.h> |
| 30 | #include <linux/init.h> |
| 31 | #include <linux/types.h> |
Alexey Starikovskiy | f1d4661 | 2007-09-26 19:42:52 +0400 | [diff] [blame] | 32 | #include <linux/jiffies.h> |
Arjan van de Ven | 0f66af5 | 2009-01-10 14:19:05 -0500 | [diff] [blame] | 33 | #include <linux/async.h> |
Hector Martin | bc76f90 | 2009-08-06 15:57:48 -0700 | [diff] [blame] | 34 | #include <linux/dmi.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 35 | #include <linux/slab.h> |
Kyle McMartin | 25be582 | 2011-03-22 16:19:50 -0400 | [diff] [blame] | 36 | #include <linux/suspend.h> |
Kamil Iskra | 4000e62 | 2012-11-16 22:28:58 +0100 | [diff] [blame] | 37 | #include <asm/unaligned.h> |
Alexey Starikovskiy | d738096 | 2007-09-26 19:43:04 +0400 | [diff] [blame] | 38 | |
Lv Zheng | 8b48463 | 2013-12-03 08:49:16 +0800 | [diff] [blame] | 39 | #include <linux/acpi.h> |
Alexey Starikovskiy | d738096 | 2007-09-26 19:43:04 +0400 | [diff] [blame] | 40 | #include <linux/power_supply.h> |
| 41 | |
Len Brown | a192a95 | 2009-07-28 16:45:54 -0400 | [diff] [blame] | 42 | #define PREFIX "ACPI: " |
| 43 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 44 | #define ACPI_BATTERY_VALUE_UNKNOWN 0xFFFFFFFF |
| 45 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 46 | #define ACPI_BATTERY_CLASS "battery" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 47 | #define ACPI_BATTERY_DEVICE_NAME "Battery" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 48 | #define ACPI_BATTERY_NOTIFY_STATUS 0x80 |
| 49 | #define ACPI_BATTERY_NOTIFY_INFO 0x81 |
Alexey Starikovskiy | c67fcd6 | 2009-10-15 14:31:44 +0400 | [diff] [blame] | 50 | #define ACPI_BATTERY_NOTIFY_THRESHOLD 0x82 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 51 | |
Lan Tianyu | ae6f618 | 2011-06-30 11:32:40 +0800 | [diff] [blame] | 52 | /* Battery power unit: 0 means mW, 1 means mA */ |
| 53 | #define ACPI_BATTERY_POWER_UNIT_MA 1 |
| 54 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 55 | #define _COMPONENT ACPI_BATTERY_COMPONENT |
Vladimir Lebedev | b6ce408 | 2007-02-20 15:48:06 +0300 | [diff] [blame] | 56 | |
Len Brown | f52fd66 | 2007-02-12 22:42:12 -0500 | [diff] [blame] | 57 | ACPI_MODULE_NAME("battery"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 58 | |
Len Brown | f52fd66 | 2007-02-12 22:42:12 -0500 | [diff] [blame] | 59 | MODULE_AUTHOR("Paul Diefenbaugh"); |
Alexey Starikovskiy | aa650bb | 2007-09-26 19:42:58 +0400 | [diff] [blame] | 60 | MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>"); |
Len Brown | 7cda93e | 2007-02-12 23:50:02 -0500 | [diff] [blame] | 61 | MODULE_DESCRIPTION("ACPI Battery Driver"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 62 | MODULE_LICENSE("GPL"); |
| 63 | |
Alexey Starikovskiy | f1d4661 | 2007-09-26 19:42:52 +0400 | [diff] [blame] | 64 | static unsigned int cache_time = 1000; |
| 65 | module_param(cache_time, uint, 0644); |
| 66 | MODULE_PARM_DESC(cache_time, "cache time in milliseconds"); |
Vladimir Lebedev | b6ce408 | 2007-02-20 15:48:06 +0300 | [diff] [blame] | 67 | |
Alexey Starikovskiy | d738096 | 2007-09-26 19:43:04 +0400 | [diff] [blame] | 68 | static const struct acpi_device_id battery_device_ids[] = { |
| 69 | {"PNP0C0A", 0}, |
| 70 | {"", 0}, |
| 71 | }; |
| 72 | |
| 73 | MODULE_DEVICE_TABLE(acpi, battery_device_ids); |
| 74 | |
Alexey Starikovskiy | 7b3bcc4 | 2009-10-15 14:31:24 +0400 | [diff] [blame] | 75 | enum { |
| 76 | ACPI_BATTERY_ALARM_PRESENT, |
Alexey Starikovskiy | c67fcd6 | 2009-10-15 14:31:44 +0400 | [diff] [blame] | 77 | ACPI_BATTERY_XINFO_PRESENT, |
Zhang Rui | 557d586 | 2010-10-22 10:02:06 +0800 | [diff] [blame] | 78 | ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, |
Kamil Iskra | 4000e62 | 2012-11-16 22:28:58 +0100 | [diff] [blame] | 79 | /* On Lenovo Thinkpad models from 2010 and 2011, the power unit |
| 80 | switches between mWh and mAh depending on whether the system |
| 81 | is running on battery or not. When mAh is the unit, most |
| 82 | reported values are incorrect and need to be adjusted by |
| 83 | 10000/design_voltage. Verified on x201, t410, t410s, and x220. |
| 84 | Pre-2010 and 2012 models appear to always report in mWh and |
| 85 | are thus unaffected (tested with t42, t61, t500, x200, x300, |
| 86 | and x230). Also, in mid-2012 Lenovo issued a BIOS update for |
| 87 | the 2011 models that fixes the issue (tested on x220 with a |
| 88 | post-1.29 BIOS), but as of Nov. 2012, no such update is |
| 89 | available for the 2010 models. */ |
| 90 | ACPI_BATTERY_QUIRK_THINKPAD_MAH, |
Alexey Starikovskiy | 7b3bcc4 | 2009-10-15 14:31:24 +0400 | [diff] [blame] | 91 | }; |
Alexey Starikovskiy | d738096 | 2007-09-26 19:43:04 +0400 | [diff] [blame] | 92 | |
Alexey Starikovskiy | 038fdea | 2007-09-26 19:42:46 +0400 | [diff] [blame] | 93 | struct acpi_battery { |
Alexey Starikovskiy | 038fdea | 2007-09-26 19:42:46 +0400 | [diff] [blame] | 94 | struct mutex lock; |
Sergey Senozhatsky | 69d94ec | 2011-08-06 01:34:08 +0300 | [diff] [blame] | 95 | struct mutex sysfs_lock; |
Alexey Starikovskiy | d738096 | 2007-09-26 19:43:04 +0400 | [diff] [blame] | 96 | struct power_supply bat; |
Alexey Starikovskiy | f1d4661 | 2007-09-26 19:42:52 +0400 | [diff] [blame] | 97 | struct acpi_device *device; |
Kyle McMartin | 25be582 | 2011-03-22 16:19:50 -0400 | [diff] [blame] | 98 | struct notifier_block pm_nb; |
Alexey Starikovskiy | f1d4661 | 2007-09-26 19:42:52 +0400 | [diff] [blame] | 99 | unsigned long update_time; |
Lan Tianyu | 016d5ba | 2013-07-30 14:00:42 +0200 | [diff] [blame] | 100 | int revision; |
Alexey Starikovskiy | 7faa144 | 2009-03-27 22:23:52 -0400 | [diff] [blame] | 101 | int rate_now; |
Alexey Starikovskiy | d738096 | 2007-09-26 19:43:04 +0400 | [diff] [blame] | 102 | int capacity_now; |
| 103 | int voltage_now; |
Alexey Starikovskiy | 038fdea | 2007-09-26 19:42:46 +0400 | [diff] [blame] | 104 | int design_capacity; |
Alexey Starikovskiy | d738096 | 2007-09-26 19:43:04 +0400 | [diff] [blame] | 105 | int full_charge_capacity; |
Alexey Starikovskiy | 038fdea | 2007-09-26 19:42:46 +0400 | [diff] [blame] | 106 | int technology; |
| 107 | int design_voltage; |
| 108 | int design_capacity_warning; |
| 109 | int design_capacity_low; |
Alexey Starikovskiy | c67fcd6 | 2009-10-15 14:31:44 +0400 | [diff] [blame] | 110 | int cycle_count; |
| 111 | int measurement_accuracy; |
| 112 | int max_sampling_time; |
| 113 | int min_sampling_time; |
| 114 | int max_averaging_interval; |
| 115 | int min_averaging_interval; |
Alexey Starikovskiy | 038fdea | 2007-09-26 19:42:46 +0400 | [diff] [blame] | 116 | int capacity_granularity_1; |
| 117 | int capacity_granularity_2; |
Alexey Starikovskiy | f1d4661 | 2007-09-26 19:42:52 +0400 | [diff] [blame] | 118 | int alarm; |
Alexey Starikovskiy | 038fdea | 2007-09-26 19:42:46 +0400 | [diff] [blame] | 119 | char model_number[32]; |
| 120 | char serial_number[32]; |
| 121 | char type[32]; |
| 122 | char oem_info[32]; |
Alexey Starikovskiy | f1d4661 | 2007-09-26 19:42:52 +0400 | [diff] [blame] | 123 | int state; |
| 124 | int power_unit; |
Alexey Starikovskiy | 7b3bcc4 | 2009-10-15 14:31:24 +0400 | [diff] [blame] | 125 | unsigned long flags; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 126 | }; |
| 127 | |
Phil Carmody | 497888c | 2011-07-14 15:07:13 +0300 | [diff] [blame] | 128 | #define to_acpi_battery(x) container_of(x, struct acpi_battery, bat) |
Alexey Starikovskiy | d738096 | 2007-09-26 19:43:04 +0400 | [diff] [blame] | 129 | |
Andy Shevchenko | efd941f | 2013-03-11 09:17:06 +0000 | [diff] [blame] | 130 | static inline int acpi_battery_present(struct acpi_battery *battery) |
Alexey Starikovskiy | 78490d8 | 2007-05-11 13:18:55 -0400 | [diff] [blame] | 131 | { |
| 132 | return battery->device->status.battery_present; |
| 133 | } |
Alexey Starikovskiy | 038fdea | 2007-09-26 19:42:46 +0400 | [diff] [blame] | 134 | |
Alexey Starikovskiy | d738096 | 2007-09-26 19:43:04 +0400 | [diff] [blame] | 135 | static int acpi_battery_technology(struct acpi_battery *battery) |
| 136 | { |
| 137 | if (!strcasecmp("NiCd", battery->type)) |
| 138 | return POWER_SUPPLY_TECHNOLOGY_NiCd; |
| 139 | if (!strcasecmp("NiMH", battery->type)) |
| 140 | return POWER_SUPPLY_TECHNOLOGY_NiMH; |
| 141 | if (!strcasecmp("LION", battery->type)) |
| 142 | return POWER_SUPPLY_TECHNOLOGY_LION; |
Andrey Borzenkov | ad40e68 | 2007-11-10 20:02:49 +0300 | [diff] [blame] | 143 | if (!strncasecmp("LI-ION", battery->type, 6)) |
Alexey Starikovskiy | 0bde7ee | 2007-10-28 15:33:10 +0300 | [diff] [blame] | 144 | return POWER_SUPPLY_TECHNOLOGY_LION; |
Alexey Starikovskiy | d738096 | 2007-09-26 19:43:04 +0400 | [diff] [blame] | 145 | if (!strcasecmp("LiP", battery->type)) |
| 146 | return POWER_SUPPLY_TECHNOLOGY_LIPO; |
| 147 | return POWER_SUPPLY_TECHNOLOGY_UNKNOWN; |
| 148 | } |
| 149 | |
Alexey Starikovskiy | 9104476 | 2007-11-13 12:23:06 +0300 | [diff] [blame] | 150 | static int acpi_battery_get_state(struct acpi_battery *battery); |
Alexey Starikovskiy | b19073a | 2007-10-25 17:10:47 -0400 | [diff] [blame] | 151 | |
Richard Hughes | 56f382a | 2009-01-25 15:05:50 +0000 | [diff] [blame] | 152 | static int acpi_battery_is_charged(struct acpi_battery *battery) |
| 153 | { |
| 154 | /* either charging or discharging */ |
| 155 | if (battery->state != 0) |
| 156 | return 0; |
| 157 | |
| 158 | /* battery not reporting charge */ |
| 159 | if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN || |
| 160 | battery->capacity_now == 0) |
| 161 | return 0; |
| 162 | |
| 163 | /* good batteries update full_charge as the batteries degrade */ |
| 164 | if (battery->full_charge_capacity == battery->capacity_now) |
| 165 | return 1; |
| 166 | |
| 167 | /* fallback to using design values for broken batteries */ |
| 168 | if (battery->design_capacity == battery->capacity_now) |
| 169 | return 1; |
| 170 | |
| 171 | /* we don't do any sort of metric based on percentages */ |
| 172 | return 0; |
| 173 | } |
| 174 | |
Alexey Starikovskiy | d738096 | 2007-09-26 19:43:04 +0400 | [diff] [blame] | 175 | static int acpi_battery_get_property(struct power_supply *psy, |
| 176 | enum power_supply_property psp, |
| 177 | union power_supply_propval *val) |
| 178 | { |
Rafael J. Wysocki | a1b4bd6 | 2010-10-23 19:35:15 +0200 | [diff] [blame] | 179 | int ret = 0; |
Alexey Starikovskiy | d738096 | 2007-09-26 19:43:04 +0400 | [diff] [blame] | 180 | struct acpi_battery *battery = to_acpi_battery(psy); |
| 181 | |
Alexey Starikovskiy | 9104476 | 2007-11-13 12:23:06 +0300 | [diff] [blame] | 182 | if (acpi_battery_present(battery)) { |
| 183 | /* run battery update only if it is present */ |
| 184 | acpi_battery_get_state(battery); |
| 185 | } else if (psp != POWER_SUPPLY_PROP_PRESENT) |
Alexey Starikovskiy | d738096 | 2007-09-26 19:43:04 +0400 | [diff] [blame] | 186 | return -ENODEV; |
| 187 | switch (psp) { |
| 188 | case POWER_SUPPLY_PROP_STATUS: |
| 189 | if (battery->state & 0x01) |
| 190 | val->intval = POWER_SUPPLY_STATUS_DISCHARGING; |
| 191 | else if (battery->state & 0x02) |
| 192 | val->intval = POWER_SUPPLY_STATUS_CHARGING; |
Richard Hughes | 56f382a | 2009-01-25 15:05:50 +0000 | [diff] [blame] | 193 | else if (acpi_battery_is_charged(battery)) |
Alexey Starikovskiy | d738096 | 2007-09-26 19:43:04 +0400 | [diff] [blame] | 194 | val->intval = POWER_SUPPLY_STATUS_FULL; |
Roland Dreier | 4c41d3a | 2007-11-07 15:09:09 -0800 | [diff] [blame] | 195 | else |
| 196 | val->intval = POWER_SUPPLY_STATUS_UNKNOWN; |
Alexey Starikovskiy | d738096 | 2007-09-26 19:43:04 +0400 | [diff] [blame] | 197 | break; |
| 198 | case POWER_SUPPLY_PROP_PRESENT: |
| 199 | val->intval = acpi_battery_present(battery); |
| 200 | break; |
| 201 | case POWER_SUPPLY_PROP_TECHNOLOGY: |
| 202 | val->intval = acpi_battery_technology(battery); |
| 203 | break; |
Alexey Starikovskiy | c67fcd6 | 2009-10-15 14:31:44 +0400 | [diff] [blame] | 204 | case POWER_SUPPLY_PROP_CYCLE_COUNT: |
| 205 | val->intval = battery->cycle_count; |
| 206 | break; |
Alexey Starikovskiy | d738096 | 2007-09-26 19:43:04 +0400 | [diff] [blame] | 207 | case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN: |
Rafael J. Wysocki | a1b4bd6 | 2010-10-23 19:35:15 +0200 | [diff] [blame] | 208 | if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN) |
| 209 | ret = -ENODEV; |
| 210 | else |
| 211 | val->intval = battery->design_voltage * 1000; |
Alexey Starikovskiy | d738096 | 2007-09-26 19:43:04 +0400 | [diff] [blame] | 212 | break; |
| 213 | case POWER_SUPPLY_PROP_VOLTAGE_NOW: |
Rafael J. Wysocki | a1b4bd6 | 2010-10-23 19:35:15 +0200 | [diff] [blame] | 214 | if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN) |
| 215 | ret = -ENODEV; |
| 216 | else |
| 217 | val->intval = battery->voltage_now * 1000; |
Alexey Starikovskiy | d738096 | 2007-09-26 19:43:04 +0400 | [diff] [blame] | 218 | break; |
| 219 | case POWER_SUPPLY_PROP_CURRENT_NOW: |
Alexey Starikovskiy | 7faa144 | 2009-03-27 22:23:52 -0400 | [diff] [blame] | 220 | case POWER_SUPPLY_PROP_POWER_NOW: |
Rafael J. Wysocki | a1b4bd6 | 2010-10-23 19:35:15 +0200 | [diff] [blame] | 221 | if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN) |
| 222 | ret = -ENODEV; |
| 223 | else |
| 224 | val->intval = battery->rate_now * 1000; |
Alexey Starikovskiy | d738096 | 2007-09-26 19:43:04 +0400 | [diff] [blame] | 225 | break; |
| 226 | case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN: |
| 227 | case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN: |
Rafael J. Wysocki | a1b4bd6 | 2010-10-23 19:35:15 +0200 | [diff] [blame] | 228 | if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN) |
| 229 | ret = -ENODEV; |
| 230 | else |
| 231 | val->intval = battery->design_capacity * 1000; |
Alexey Starikovskiy | d738096 | 2007-09-26 19:43:04 +0400 | [diff] [blame] | 232 | break; |
| 233 | case POWER_SUPPLY_PROP_CHARGE_FULL: |
| 234 | case POWER_SUPPLY_PROP_ENERGY_FULL: |
Rafael J. Wysocki | a1b4bd6 | 2010-10-23 19:35:15 +0200 | [diff] [blame] | 235 | if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN) |
| 236 | ret = -ENODEV; |
| 237 | else |
| 238 | val->intval = battery->full_charge_capacity * 1000; |
Alexey Starikovskiy | d738096 | 2007-09-26 19:43:04 +0400 | [diff] [blame] | 239 | break; |
| 240 | case POWER_SUPPLY_PROP_CHARGE_NOW: |
| 241 | case POWER_SUPPLY_PROP_ENERGY_NOW: |
Rafael J. Wysocki | a1b4bd6 | 2010-10-23 19:35:15 +0200 | [diff] [blame] | 242 | if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN) |
| 243 | ret = -ENODEV; |
| 244 | else |
| 245 | val->intval = battery->capacity_now * 1000; |
Alexey Starikovskiy | d738096 | 2007-09-26 19:43:04 +0400 | [diff] [blame] | 246 | break; |
srinivas pandruvada | a58e115 | 2012-04-05 17:38:54 -0700 | [diff] [blame] | 247 | case POWER_SUPPLY_PROP_CAPACITY: |
| 248 | if (battery->capacity_now && battery->full_charge_capacity) |
| 249 | val->intval = battery->capacity_now * 100/ |
| 250 | battery->full_charge_capacity; |
| 251 | else |
| 252 | val->intval = 0; |
| 253 | break; |
Alexey Starikovskiy | d738096 | 2007-09-26 19:43:04 +0400 | [diff] [blame] | 254 | case POWER_SUPPLY_PROP_MODEL_NAME: |
| 255 | val->strval = battery->model_number; |
| 256 | break; |
| 257 | case POWER_SUPPLY_PROP_MANUFACTURER: |
| 258 | val->strval = battery->oem_info; |
| 259 | break; |
maximilian attems | 7c2670b | 2008-01-22 18:46:50 +0100 | [diff] [blame] | 260 | case POWER_SUPPLY_PROP_SERIAL_NUMBER: |
| 261 | val->strval = battery->serial_number; |
| 262 | break; |
Alexey Starikovskiy | d738096 | 2007-09-26 19:43:04 +0400 | [diff] [blame] | 263 | default: |
Rafael J. Wysocki | a1b4bd6 | 2010-10-23 19:35:15 +0200 | [diff] [blame] | 264 | ret = -EINVAL; |
Alexey Starikovskiy | d738096 | 2007-09-26 19:43:04 +0400 | [diff] [blame] | 265 | } |
Rafael J. Wysocki | a1b4bd6 | 2010-10-23 19:35:15 +0200 | [diff] [blame] | 266 | return ret; |
Alexey Starikovskiy | d738096 | 2007-09-26 19:43:04 +0400 | [diff] [blame] | 267 | } |
| 268 | |
| 269 | static enum power_supply_property charge_battery_props[] = { |
| 270 | POWER_SUPPLY_PROP_STATUS, |
| 271 | POWER_SUPPLY_PROP_PRESENT, |
| 272 | POWER_SUPPLY_PROP_TECHNOLOGY, |
Alexey Starikovskiy | c67fcd6 | 2009-10-15 14:31:44 +0400 | [diff] [blame] | 273 | POWER_SUPPLY_PROP_CYCLE_COUNT, |
Alexey Starikovskiy | d738096 | 2007-09-26 19:43:04 +0400 | [diff] [blame] | 274 | POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN, |
| 275 | POWER_SUPPLY_PROP_VOLTAGE_NOW, |
| 276 | POWER_SUPPLY_PROP_CURRENT_NOW, |
| 277 | POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, |
| 278 | POWER_SUPPLY_PROP_CHARGE_FULL, |
| 279 | POWER_SUPPLY_PROP_CHARGE_NOW, |
srinivas pandruvada | a58e115 | 2012-04-05 17:38:54 -0700 | [diff] [blame] | 280 | POWER_SUPPLY_PROP_CAPACITY, |
Alexey Starikovskiy | d738096 | 2007-09-26 19:43:04 +0400 | [diff] [blame] | 281 | POWER_SUPPLY_PROP_MODEL_NAME, |
| 282 | POWER_SUPPLY_PROP_MANUFACTURER, |
maximilian attems | 7c2670b | 2008-01-22 18:46:50 +0100 | [diff] [blame] | 283 | POWER_SUPPLY_PROP_SERIAL_NUMBER, |
Alexey Starikovskiy | d738096 | 2007-09-26 19:43:04 +0400 | [diff] [blame] | 284 | }; |
| 285 | |
| 286 | static enum power_supply_property energy_battery_props[] = { |
| 287 | POWER_SUPPLY_PROP_STATUS, |
| 288 | POWER_SUPPLY_PROP_PRESENT, |
| 289 | POWER_SUPPLY_PROP_TECHNOLOGY, |
Alexey Starikovskiy | c67fcd6 | 2009-10-15 14:31:44 +0400 | [diff] [blame] | 290 | POWER_SUPPLY_PROP_CYCLE_COUNT, |
Alexey Starikovskiy | d738096 | 2007-09-26 19:43:04 +0400 | [diff] [blame] | 291 | POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN, |
| 292 | POWER_SUPPLY_PROP_VOLTAGE_NOW, |
Alexey Starikovskiy | 7faa144 | 2009-03-27 22:23:52 -0400 | [diff] [blame] | 293 | POWER_SUPPLY_PROP_POWER_NOW, |
Alexey Starikovskiy | d738096 | 2007-09-26 19:43:04 +0400 | [diff] [blame] | 294 | POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN, |
| 295 | POWER_SUPPLY_PROP_ENERGY_FULL, |
| 296 | POWER_SUPPLY_PROP_ENERGY_NOW, |
srinivas pandruvada | a58e115 | 2012-04-05 17:38:54 -0700 | [diff] [blame] | 297 | POWER_SUPPLY_PROP_CAPACITY, |
Alexey Starikovskiy | d738096 | 2007-09-26 19:43:04 +0400 | [diff] [blame] | 298 | POWER_SUPPLY_PROP_MODEL_NAME, |
| 299 | POWER_SUPPLY_PROP_MANUFACTURER, |
maximilian attems | 7c2670b | 2008-01-22 18:46:50 +0100 | [diff] [blame] | 300 | POWER_SUPPLY_PROP_SERIAL_NUMBER, |
Alexey Starikovskiy | d738096 | 2007-09-26 19:43:04 +0400 | [diff] [blame] | 301 | }; |
| 302 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 303 | /* -------------------------------------------------------------------------- |
| 304 | Battery Management |
| 305 | -------------------------------------------------------------------------- */ |
Alexey Starikovskiy | 038fdea | 2007-09-26 19:42:46 +0400 | [diff] [blame] | 306 | struct acpi_offsets { |
| 307 | size_t offset; /* offset inside struct acpi_sbs_battery */ |
| 308 | u8 mode; /* int or string? */ |
| 309 | }; |
| 310 | |
| 311 | static struct acpi_offsets state_offsets[] = { |
| 312 | {offsetof(struct acpi_battery, state), 0}, |
Alexey Starikovskiy | 7faa144 | 2009-03-27 22:23:52 -0400 | [diff] [blame] | 313 | {offsetof(struct acpi_battery, rate_now), 0}, |
Alexey Starikovskiy | d738096 | 2007-09-26 19:43:04 +0400 | [diff] [blame] | 314 | {offsetof(struct acpi_battery, capacity_now), 0}, |
| 315 | {offsetof(struct acpi_battery, voltage_now), 0}, |
Alexey Starikovskiy | 038fdea | 2007-09-26 19:42:46 +0400 | [diff] [blame] | 316 | }; |
| 317 | |
| 318 | static struct acpi_offsets info_offsets[] = { |
| 319 | {offsetof(struct acpi_battery, power_unit), 0}, |
| 320 | {offsetof(struct acpi_battery, design_capacity), 0}, |
Alexey Starikovskiy | d738096 | 2007-09-26 19:43:04 +0400 | [diff] [blame] | 321 | {offsetof(struct acpi_battery, full_charge_capacity), 0}, |
Alexey Starikovskiy | 038fdea | 2007-09-26 19:42:46 +0400 | [diff] [blame] | 322 | {offsetof(struct acpi_battery, technology), 0}, |
| 323 | {offsetof(struct acpi_battery, design_voltage), 0}, |
| 324 | {offsetof(struct acpi_battery, design_capacity_warning), 0}, |
| 325 | {offsetof(struct acpi_battery, design_capacity_low), 0}, |
| 326 | {offsetof(struct acpi_battery, capacity_granularity_1), 0}, |
| 327 | {offsetof(struct acpi_battery, capacity_granularity_2), 0}, |
| 328 | {offsetof(struct acpi_battery, model_number), 1}, |
| 329 | {offsetof(struct acpi_battery, serial_number), 1}, |
| 330 | {offsetof(struct acpi_battery, type), 1}, |
| 331 | {offsetof(struct acpi_battery, oem_info), 1}, |
| 332 | }; |
| 333 | |
Alexey Starikovskiy | c67fcd6 | 2009-10-15 14:31:44 +0400 | [diff] [blame] | 334 | static struct acpi_offsets extended_info_offsets[] = { |
Lan Tianyu | 016d5ba | 2013-07-30 14:00:42 +0200 | [diff] [blame] | 335 | {offsetof(struct acpi_battery, revision), 0}, |
Alexey Starikovskiy | c67fcd6 | 2009-10-15 14:31:44 +0400 | [diff] [blame] | 336 | {offsetof(struct acpi_battery, power_unit), 0}, |
| 337 | {offsetof(struct acpi_battery, design_capacity), 0}, |
| 338 | {offsetof(struct acpi_battery, full_charge_capacity), 0}, |
| 339 | {offsetof(struct acpi_battery, technology), 0}, |
| 340 | {offsetof(struct acpi_battery, design_voltage), 0}, |
| 341 | {offsetof(struct acpi_battery, design_capacity_warning), 0}, |
| 342 | {offsetof(struct acpi_battery, design_capacity_low), 0}, |
| 343 | {offsetof(struct acpi_battery, cycle_count), 0}, |
| 344 | {offsetof(struct acpi_battery, measurement_accuracy), 0}, |
| 345 | {offsetof(struct acpi_battery, max_sampling_time), 0}, |
| 346 | {offsetof(struct acpi_battery, min_sampling_time), 0}, |
| 347 | {offsetof(struct acpi_battery, max_averaging_interval), 0}, |
| 348 | {offsetof(struct acpi_battery, min_averaging_interval), 0}, |
| 349 | {offsetof(struct acpi_battery, capacity_granularity_1), 0}, |
| 350 | {offsetof(struct acpi_battery, capacity_granularity_2), 0}, |
| 351 | {offsetof(struct acpi_battery, model_number), 1}, |
| 352 | {offsetof(struct acpi_battery, serial_number), 1}, |
| 353 | {offsetof(struct acpi_battery, type), 1}, |
| 354 | {offsetof(struct acpi_battery, oem_info), 1}, |
| 355 | }; |
| 356 | |
Alexey Starikovskiy | 038fdea | 2007-09-26 19:42:46 +0400 | [diff] [blame] | 357 | static int extract_package(struct acpi_battery *battery, |
| 358 | union acpi_object *package, |
| 359 | struct acpi_offsets *offsets, int num) |
Vladimir Lebedev | b6ce408 | 2007-02-20 15:48:06 +0300 | [diff] [blame] | 360 | { |
Alexey Starikovskiy | 106449e | 2007-10-29 23:29:40 +0300 | [diff] [blame] | 361 | int i; |
Alexey Starikovskiy | 038fdea | 2007-09-26 19:42:46 +0400 | [diff] [blame] | 362 | union acpi_object *element; |
| 363 | if (package->type != ACPI_TYPE_PACKAGE) |
| 364 | return -EFAULT; |
| 365 | for (i = 0; i < num; ++i) { |
| 366 | if (package->package.count <= i) |
| 367 | return -EFAULT; |
| 368 | element = &package->package.elements[i]; |
| 369 | if (offsets[i].mode) { |
Alexey Starikovskiy | 106449e | 2007-10-29 23:29:40 +0300 | [diff] [blame] | 370 | u8 *ptr = (u8 *)battery + offsets[i].offset; |
| 371 | if (element->type == ACPI_TYPE_STRING || |
| 372 | element->type == ACPI_TYPE_BUFFER) |
| 373 | strncpy(ptr, element->string.pointer, 32); |
| 374 | else if (element->type == ACPI_TYPE_INTEGER) { |
| 375 | strncpy(ptr, (u8 *)&element->integer.value, |
Lin Ming | 439913f | 2010-01-28 10:53:19 +0800 | [diff] [blame] | 376 | sizeof(u64)); |
| 377 | ptr[sizeof(u64)] = 0; |
Alexey Starikovskiy | b8a1bdb | 2008-03-17 22:37:42 -0400 | [diff] [blame] | 378 | } else |
| 379 | *ptr = 0; /* don't have value */ |
Alexey Starikovskiy | 038fdea | 2007-09-26 19:42:46 +0400 | [diff] [blame] | 380 | } else { |
Alexey Starikovskiy | b8a1bdb | 2008-03-17 22:37:42 -0400 | [diff] [blame] | 381 | int *x = (int *)((u8 *)battery + offsets[i].offset); |
| 382 | *x = (element->type == ACPI_TYPE_INTEGER) ? |
| 383 | element->integer.value : -1; |
Vladimir Lebedev | b6ce408 | 2007-02-20 15:48:06 +0300 | [diff] [blame] | 384 | } |
Vladimir Lebedev | b6ce408 | 2007-02-20 15:48:06 +0300 | [diff] [blame] | 385 | } |
Vladimir Lebedev | b6ce408 | 2007-02-20 15:48:06 +0300 | [diff] [blame] | 386 | return 0; |
| 387 | } |
| 388 | |
| 389 | static int acpi_battery_get_status(struct acpi_battery *battery) |
| 390 | { |
Alexey Starikovskiy | aa650bb | 2007-09-26 19:42:58 +0400 | [diff] [blame] | 391 | if (acpi_bus_get_status(battery->device)) { |
Vladimir Lebedev | b6ce408 | 2007-02-20 15:48:06 +0300 | [diff] [blame] | 392 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, "Evaluating _STA")); |
| 393 | return -ENODEV; |
| 394 | } |
Alexey Starikovskiy | aa650bb | 2007-09-26 19:42:58 +0400 | [diff] [blame] | 395 | return 0; |
Vladimir Lebedev | b6ce408 | 2007-02-20 15:48:06 +0300 | [diff] [blame] | 396 | } |
| 397 | |
| 398 | static int acpi_battery_get_info(struct acpi_battery *battery) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 399 | { |
Alexey Starikovskiy | aa650bb | 2007-09-26 19:42:58 +0400 | [diff] [blame] | 400 | int result = -EFAULT; |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 401 | acpi_status status = 0; |
Nicholas Mazzuca | 0f4c654 | 2013-05-08 23:11:15 +0000 | [diff] [blame] | 402 | char *name = test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags) ? |
Alexey Starikovskiy | c67fcd6 | 2009-10-15 14:31:44 +0400 | [diff] [blame] | 403 | "_BIX" : "_BIF"; |
| 404 | |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 405 | struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 406 | |
Vladimir Lebedev | b6ce408 | 2007-02-20 15:48:06 +0300 | [diff] [blame] | 407 | if (!acpi_battery_present(battery)) |
| 408 | return 0; |
Alexey Starikovskiy | 038fdea | 2007-09-26 19:42:46 +0400 | [diff] [blame] | 409 | mutex_lock(&battery->lock); |
Alexey Starikovskiy | c67fcd6 | 2009-10-15 14:31:44 +0400 | [diff] [blame] | 410 | status = acpi_evaluate_object(battery->device->handle, name, |
| 411 | NULL, &buffer); |
Alexey Starikovskiy | 038fdea | 2007-09-26 19:42:46 +0400 | [diff] [blame] | 412 | mutex_unlock(&battery->lock); |
Alexey Starikovskiy | aa650bb | 2007-09-26 19:42:58 +0400 | [diff] [blame] | 413 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 414 | if (ACPI_FAILURE(status)) { |
Alexey Starikovskiy | c67fcd6 | 2009-10-15 14:31:44 +0400 | [diff] [blame] | 415 | ACPI_EXCEPTION((AE_INFO, status, "Evaluating %s", name)); |
Patrick Mochel | d550d98 | 2006-06-27 00:41:40 -0400 | [diff] [blame] | 416 | return -ENODEV; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 417 | } |
Alexey Starikovskiy | c67fcd6 | 2009-10-15 14:31:44 +0400 | [diff] [blame] | 418 | if (test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags)) |
| 419 | result = extract_package(battery, buffer.pointer, |
| 420 | extended_info_offsets, |
| 421 | ARRAY_SIZE(extended_info_offsets)); |
| 422 | else |
| 423 | result = extract_package(battery, buffer.pointer, |
| 424 | info_offsets, ARRAY_SIZE(info_offsets)); |
Alexey Starikovskiy | 78490d8 | 2007-05-11 13:18:55 -0400 | [diff] [blame] | 425 | kfree(buffer.pointer); |
Zhang Rui | 557d586 | 2010-10-22 10:02:06 +0800 | [diff] [blame] | 426 | if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags)) |
| 427 | battery->full_charge_capacity = battery->design_capacity; |
Kamil Iskra | 4000e62 | 2012-11-16 22:28:58 +0100 | [diff] [blame] | 428 | if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) && |
| 429 | battery->power_unit && battery->design_voltage) { |
| 430 | battery->design_capacity = battery->design_capacity * |
| 431 | 10000 / battery->design_voltage; |
| 432 | battery->full_charge_capacity = battery->full_charge_capacity * |
| 433 | 10000 / battery->design_voltage; |
| 434 | battery->design_capacity_warning = |
| 435 | battery->design_capacity_warning * |
| 436 | 10000 / battery->design_voltage; |
| 437 | /* Curiously, design_capacity_low, unlike the rest of them, |
| 438 | is correct. */ |
| 439 | /* capacity_granularity_* equal 1 on the systems tested, so |
| 440 | it's impossible to tell if they would need an adjustment |
| 441 | or not if their values were higher. */ |
| 442 | } |
Patrick Mochel | d550d98 | 2006-06-27 00:41:40 -0400 | [diff] [blame] | 443 | return result; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 444 | } |
| 445 | |
Vladimir Lebedev | b6ce408 | 2007-02-20 15:48:06 +0300 | [diff] [blame] | 446 | static int acpi_battery_get_state(struct acpi_battery *battery) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 447 | { |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 448 | int result = 0; |
| 449 | acpi_status status = 0; |
| 450 | struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 451 | |
Vladimir Lebedev | b6ce408 | 2007-02-20 15:48:06 +0300 | [diff] [blame] | 452 | if (!acpi_battery_present(battery)) |
| 453 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 454 | |
Alexey Starikovskiy | f1d4661 | 2007-09-26 19:42:52 +0400 | [diff] [blame] | 455 | if (battery->update_time && |
| 456 | time_before(jiffies, battery->update_time + |
| 457 | msecs_to_jiffies(cache_time))) |
| 458 | return 0; |
| 459 | |
Alexey Starikovskiy | 038fdea | 2007-09-26 19:42:46 +0400 | [diff] [blame] | 460 | mutex_lock(&battery->lock); |
Alexey Starikovskiy | f1d4661 | 2007-09-26 19:42:52 +0400 | [diff] [blame] | 461 | status = acpi_evaluate_object(battery->device->handle, "_BST", |
Alexey Starikovskiy | 038fdea | 2007-09-26 19:42:46 +0400 | [diff] [blame] | 462 | NULL, &buffer); |
| 463 | mutex_unlock(&battery->lock); |
Len Brown | 5b31d89 | 2007-08-15 00:19:26 -0400 | [diff] [blame] | 464 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 465 | if (ACPI_FAILURE(status)) { |
Thomas Renninger | a6fc672 | 2006-06-26 23:58:43 -0400 | [diff] [blame] | 466 | ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST")); |
Patrick Mochel | d550d98 | 2006-06-27 00:41:40 -0400 | [diff] [blame] | 467 | return -ENODEV; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 468 | } |
Alexey Starikovskiy | aa650bb | 2007-09-26 19:42:58 +0400 | [diff] [blame] | 469 | |
Alexey Starikovskiy | 038fdea | 2007-09-26 19:42:46 +0400 | [diff] [blame] | 470 | result = extract_package(battery, buffer.pointer, |
| 471 | state_offsets, ARRAY_SIZE(state_offsets)); |
Alexey Starikovskiy | f1d4661 | 2007-09-26 19:42:52 +0400 | [diff] [blame] | 472 | battery->update_time = jiffies; |
Alexey Starikovskiy | 78490d8 | 2007-05-11 13:18:55 -0400 | [diff] [blame] | 473 | kfree(buffer.pointer); |
Hector Martin | bc76f90 | 2009-08-06 15:57:48 -0700 | [diff] [blame] | 474 | |
Lan Tianyu | 55003b2 | 2011-06-30 11:33:12 +0800 | [diff] [blame] | 475 | /* For buggy DSDTs that report negative 16-bit values for either |
| 476 | * charging or discharging current and/or report 0 as 65536 |
| 477 | * due to bad math. |
| 478 | */ |
| 479 | if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA && |
| 480 | battery->rate_now != ACPI_BATTERY_VALUE_UNKNOWN && |
| 481 | (s16)(battery->rate_now) < 0) { |
Hector Martin | bc76f90 | 2009-08-06 15:57:48 -0700 | [diff] [blame] | 482 | battery->rate_now = abs((s16)battery->rate_now); |
Lan Tianyu | 55003b2 | 2011-06-30 11:33:12 +0800 | [diff] [blame] | 483 | printk_once(KERN_WARNING FW_BUG "battery: (dis)charge rate" |
| 484 | " invalid.\n"); |
| 485 | } |
Hector Martin | bc76f90 | 2009-08-06 15:57:48 -0700 | [diff] [blame] | 486 | |
Zhang Rui | 557d586 | 2010-10-22 10:02:06 +0800 | [diff] [blame] | 487 | if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags) |
| 488 | && battery->capacity_now >= 0 && battery->capacity_now <= 100) |
| 489 | battery->capacity_now = (battery->capacity_now * |
| 490 | battery->full_charge_capacity) / 100; |
Kamil Iskra | 4000e62 | 2012-11-16 22:28:58 +0100 | [diff] [blame] | 491 | if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) && |
| 492 | battery->power_unit && battery->design_voltage) { |
| 493 | battery->capacity_now = battery->capacity_now * |
| 494 | 10000 / battery->design_voltage; |
| 495 | } |
Patrick Mochel | d550d98 | 2006-06-27 00:41:40 -0400 | [diff] [blame] | 496 | return result; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 497 | } |
| 498 | |
Alexey Starikovskiy | aa650bb | 2007-09-26 19:42:58 +0400 | [diff] [blame] | 499 | static int acpi_battery_set_alarm(struct acpi_battery *battery) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 500 | { |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 501 | acpi_status status = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 502 | |
Alexey Starikovskiy | c67fcd6 | 2009-10-15 14:31:44 +0400 | [diff] [blame] | 503 | if (!acpi_battery_present(battery) || |
Alexey Starikovskiy | 7b3bcc4 | 2009-10-15 14:31:24 +0400 | [diff] [blame] | 504 | !test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags)) |
Vladimir Lebedev | b6ce408 | 2007-02-20 15:48:06 +0300 | [diff] [blame] | 505 | return -ENODEV; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 506 | |
Alexey Starikovskiy | 038fdea | 2007-09-26 19:42:46 +0400 | [diff] [blame] | 507 | mutex_lock(&battery->lock); |
Jiang Liu | 0db9820 | 2013-06-29 00:24:39 +0800 | [diff] [blame] | 508 | status = acpi_execute_simple_method(battery->device->handle, "_BTP", |
| 509 | battery->alarm); |
Alexey Starikovskiy | 038fdea | 2007-09-26 19:42:46 +0400 | [diff] [blame] | 510 | mutex_unlock(&battery->lock); |
Alexey Starikovskiy | aa650bb | 2007-09-26 19:42:58 +0400 | [diff] [blame] | 511 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 512 | if (ACPI_FAILURE(status)) |
Patrick Mochel | d550d98 | 2006-06-27 00:41:40 -0400 | [diff] [blame] | 513 | return -ENODEV; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 514 | |
Alexey Starikovskiy | aa650bb | 2007-09-26 19:42:58 +0400 | [diff] [blame] | 515 | ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", battery->alarm)); |
Patrick Mochel | d550d98 | 2006-06-27 00:41:40 -0400 | [diff] [blame] | 516 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 517 | } |
| 518 | |
Vladimir Lebedev | b6ce408 | 2007-02-20 15:48:06 +0300 | [diff] [blame] | 519 | static int acpi_battery_init_alarm(struct acpi_battery *battery) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 520 | { |
Vladimir Lebedev | b6ce408 | 2007-02-20 15:48:06 +0300 | [diff] [blame] | 521 | /* See if alarms are supported, and if so, set default */ |
Jiang Liu | 952c63e | 2013-06-29 00:24:38 +0800 | [diff] [blame] | 522 | if (!acpi_has_method(battery->device->handle, "_BTP")) { |
Alexey Starikovskiy | 7b3bcc4 | 2009-10-15 14:31:24 +0400 | [diff] [blame] | 523 | clear_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags); |
Alexey Starikovskiy | f1d4661 | 2007-09-26 19:42:52 +0400 | [diff] [blame] | 524 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 525 | } |
Alexey Starikovskiy | 7b3bcc4 | 2009-10-15 14:31:24 +0400 | [diff] [blame] | 526 | set_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags); |
Alexey Starikovskiy | f1d4661 | 2007-09-26 19:42:52 +0400 | [diff] [blame] | 527 | if (!battery->alarm) |
| 528 | battery->alarm = battery->design_capacity_warning; |
Alexey Starikovskiy | aa650bb | 2007-09-26 19:42:58 +0400 | [diff] [blame] | 529 | return acpi_battery_set_alarm(battery); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 530 | } |
| 531 | |
Andrey Borzenkov | 508df92 | 2007-10-28 12:50:09 +0300 | [diff] [blame] | 532 | static ssize_t acpi_battery_alarm_show(struct device *dev, |
| 533 | struct device_attribute *attr, |
| 534 | char *buf) |
| 535 | { |
| 536 | struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev)); |
| 537 | return sprintf(buf, "%d\n", battery->alarm * 1000); |
| 538 | } |
| 539 | |
| 540 | static ssize_t acpi_battery_alarm_store(struct device *dev, |
| 541 | struct device_attribute *attr, |
| 542 | const char *buf, size_t count) |
| 543 | { |
| 544 | unsigned long x; |
| 545 | struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev)); |
| 546 | if (sscanf(buf, "%ld\n", &x) == 1) |
| 547 | battery->alarm = x/1000; |
| 548 | if (acpi_battery_present(battery)) |
| 549 | acpi_battery_set_alarm(battery); |
| 550 | return count; |
| 551 | } |
| 552 | |
| 553 | static struct device_attribute alarm_attr = { |
Parag Warudkar | 01e8ef1 | 2008-10-18 20:28:50 -0700 | [diff] [blame] | 554 | .attr = {.name = "alarm", .mode = 0644}, |
Andrey Borzenkov | 508df92 | 2007-10-28 12:50:09 +0300 | [diff] [blame] | 555 | .show = acpi_battery_alarm_show, |
| 556 | .store = acpi_battery_alarm_store, |
| 557 | }; |
| 558 | |
| 559 | static int sysfs_add_battery(struct acpi_battery *battery) |
| 560 | { |
| 561 | int result; |
| 562 | |
Lan Tianyu | ae6f618 | 2011-06-30 11:32:40 +0800 | [diff] [blame] | 563 | if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) { |
Andrey Borzenkov | 508df92 | 2007-10-28 12:50:09 +0300 | [diff] [blame] | 564 | battery->bat.properties = charge_battery_props; |
| 565 | battery->bat.num_properties = |
| 566 | ARRAY_SIZE(charge_battery_props); |
| 567 | } else { |
| 568 | battery->bat.properties = energy_battery_props; |
| 569 | battery->bat.num_properties = |
| 570 | ARRAY_SIZE(energy_battery_props); |
| 571 | } |
| 572 | |
| 573 | battery->bat.name = acpi_device_bid(battery->device); |
| 574 | battery->bat.type = POWER_SUPPLY_TYPE_BATTERY; |
| 575 | battery->bat.get_property = acpi_battery_get_property; |
| 576 | |
| 577 | result = power_supply_register(&battery->device->dev, &battery->bat); |
| 578 | if (result) |
| 579 | return result; |
| 580 | return device_create_file(battery->bat.dev, &alarm_attr); |
| 581 | } |
| 582 | |
| 583 | static void sysfs_remove_battery(struct acpi_battery *battery) |
| 584 | { |
Sergey Senozhatsky | 69d94ec | 2011-08-06 01:34:08 +0300 | [diff] [blame] | 585 | mutex_lock(&battery->sysfs_lock); |
Lan Tianyu | 9c921c22 | 2011-06-30 11:34:12 +0800 | [diff] [blame] | 586 | if (!battery->bat.dev) { |
Sergey Senozhatsky | 69d94ec | 2011-08-06 01:34:08 +0300 | [diff] [blame] | 587 | mutex_unlock(&battery->sysfs_lock); |
Andrey Borzenkov | 508df92 | 2007-10-28 12:50:09 +0300 | [diff] [blame] | 588 | return; |
Lan Tianyu | 9c921c22 | 2011-06-30 11:34:12 +0800 | [diff] [blame] | 589 | } |
| 590 | |
Andrey Borzenkov | 508df92 | 2007-10-28 12:50:09 +0300 | [diff] [blame] | 591 | device_remove_file(battery->bat.dev, &alarm_attr); |
| 592 | power_supply_unregister(&battery->bat); |
Alexey Starikovskiy | 9104476 | 2007-11-13 12:23:06 +0300 | [diff] [blame] | 593 | battery->bat.dev = NULL; |
Sergey Senozhatsky | 69d94ec | 2011-08-06 01:34:08 +0300 | [diff] [blame] | 594 | mutex_unlock(&battery->sysfs_lock); |
Hector Martin | bc76f90 | 2009-08-06 15:57:48 -0700 | [diff] [blame] | 595 | } |
| 596 | |
Kamil Iskra | 4000e62 | 2012-11-16 22:28:58 +0100 | [diff] [blame] | 597 | static void find_battery(const struct dmi_header *dm, void *private) |
| 598 | { |
| 599 | struct acpi_battery *battery = (struct acpi_battery *)private; |
| 600 | /* Note: the hardcoded offsets below have been extracted from |
| 601 | the source code of dmidecode. */ |
| 602 | if (dm->type == DMI_ENTRY_PORTABLE_BATTERY && dm->length >= 8) { |
| 603 | const u8 *dmi_data = (const u8 *)(dm + 1); |
| 604 | int dmi_capacity = get_unaligned((const u16 *)(dmi_data + 6)); |
| 605 | if (dm->length >= 18) |
| 606 | dmi_capacity *= dmi_data[17]; |
| 607 | if (battery->design_capacity * battery->design_voltage / 1000 |
| 608 | != dmi_capacity && |
| 609 | battery->design_capacity * 10 == dmi_capacity) |
| 610 | set_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, |
| 611 | &battery->flags); |
| 612 | } |
| 613 | } |
| 614 | |
Zhang Rui | 557d586 | 2010-10-22 10:02:06 +0800 | [diff] [blame] | 615 | /* |
| 616 | * According to the ACPI spec, some kinds of primary batteries can |
| 617 | * report percentage battery remaining capacity directly to OS. |
| 618 | * In this case, it reports the Last Full Charged Capacity == 100 |
| 619 | * and BatteryPresentRate == 0xFFFFFFFF. |
| 620 | * |
| 621 | * Now we found some battery reports percentage remaining capacity |
| 622 | * even if it's rechargeable. |
| 623 | * https://bugzilla.kernel.org/show_bug.cgi?id=15979 |
| 624 | * |
| 625 | * Handle this correctly so that they won't break userspace. |
| 626 | */ |
Lan Tianyu | 7b78622 | 2011-06-30 11:33:27 +0800 | [diff] [blame] | 627 | static void acpi_battery_quirks(struct acpi_battery *battery) |
Zhang Rui | 557d586 | 2010-10-22 10:02:06 +0800 | [diff] [blame] | 628 | { |
| 629 | if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags)) |
Nicholas Mazzuca | 0f4c654 | 2013-05-08 23:11:15 +0000 | [diff] [blame] | 630 | return; |
Zhang Rui | 557d586 | 2010-10-22 10:02:06 +0800 | [diff] [blame] | 631 | |
Nicholas Mazzuca | 0f4c654 | 2013-05-08 23:11:15 +0000 | [diff] [blame] | 632 | if (battery->full_charge_capacity == 100 && |
| 633 | battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN && |
| 634 | battery->capacity_now >= 0 && battery->capacity_now <= 100) { |
Zhang Rui | 557d586 | 2010-10-22 10:02:06 +0800 | [diff] [blame] | 635 | set_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags); |
| 636 | battery->full_charge_capacity = battery->design_capacity; |
| 637 | battery->capacity_now = (battery->capacity_now * |
| 638 | battery->full_charge_capacity) / 100; |
| 639 | } |
Kamil Iskra | 4000e62 | 2012-11-16 22:28:58 +0100 | [diff] [blame] | 640 | |
| 641 | if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags)) |
Nicholas Mazzuca | 0f4c654 | 2013-05-08 23:11:15 +0000 | [diff] [blame] | 642 | return; |
Kamil Iskra | 4000e62 | 2012-11-16 22:28:58 +0100 | [diff] [blame] | 643 | |
| 644 | if (battery->power_unit && dmi_name_in_vendors("LENOVO")) { |
| 645 | const char *s; |
| 646 | s = dmi_get_system_info(DMI_PRODUCT_VERSION); |
| 647 | if (s && !strnicmp(s, "ThinkPad", 8)) { |
| 648 | dmi_walk(find_battery, battery); |
| 649 | if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, |
| 650 | &battery->flags) && |
| 651 | battery->design_voltage) { |
| 652 | battery->design_capacity = |
| 653 | battery->design_capacity * |
| 654 | 10000 / battery->design_voltage; |
| 655 | battery->full_charge_capacity = |
| 656 | battery->full_charge_capacity * |
| 657 | 10000 / battery->design_voltage; |
| 658 | battery->design_capacity_warning = |
| 659 | battery->design_capacity_warning * |
| 660 | 10000 / battery->design_voltage; |
| 661 | battery->capacity_now = battery->capacity_now * |
| 662 | 10000 / battery->design_voltage; |
| 663 | } |
| 664 | } |
| 665 | } |
Zhang Rui | 557d586 | 2010-10-22 10:02:06 +0800 | [diff] [blame] | 666 | } |
| 667 | |
Alexey Starikovskiy | f1d4661 | 2007-09-26 19:42:52 +0400 | [diff] [blame] | 668 | static int acpi_battery_update(struct acpi_battery *battery) |
Vladimir Lebedev | 4bd35cd | 2007-02-10 01:43:48 -0500 | [diff] [blame] | 669 | { |
Alexey Starikovskiy | 50b1785 | 2008-12-23 02:44:54 +0300 | [diff] [blame] | 670 | int result, old_present = acpi_battery_present(battery); |
Alexey Starikovskiy | 97749cd | 2008-01-01 14:27:24 -0500 | [diff] [blame] | 671 | result = acpi_battery_get_status(battery); |
Andrey Borzenkov | 508df92 | 2007-10-28 12:50:09 +0300 | [diff] [blame] | 672 | if (result) |
Vladimir Lebedev | b6ce408 | 2007-02-20 15:48:06 +0300 | [diff] [blame] | 673 | return result; |
Andrey Borzenkov | 508df92 | 2007-10-28 12:50:09 +0300 | [diff] [blame] | 674 | if (!acpi_battery_present(battery)) { |
| 675 | sysfs_remove_battery(battery); |
Alexey Starikovskiy | 97749cd | 2008-01-01 14:27:24 -0500 | [diff] [blame] | 676 | battery->update_time = 0; |
Andrey Borzenkov | 508df92 | 2007-10-28 12:50:09 +0300 | [diff] [blame] | 677 | return 0; |
Vladimir Lebedev | b6ce408 | 2007-02-20 15:48:06 +0300 | [diff] [blame] | 678 | } |
Alexey Starikovskiy | 50b1785 | 2008-12-23 02:44:54 +0300 | [diff] [blame] | 679 | if (!battery->update_time || |
| 680 | old_present != acpi_battery_present(battery)) { |
Alexey Starikovskiy | 97749cd | 2008-01-01 14:27:24 -0500 | [diff] [blame] | 681 | result = acpi_battery_get_info(battery); |
| 682 | if (result) |
| 683 | return result; |
| 684 | acpi_battery_init_alarm(battery); |
| 685 | } |
Stefan Hajnoczi | eb03cb0 | 2011-07-12 09:03:29 +0100 | [diff] [blame] | 686 | if (!battery->bat.dev) { |
| 687 | result = sysfs_add_battery(battery); |
| 688 | if (result) |
| 689 | return result; |
| 690 | } |
Zhang Rui | 557d586 | 2010-10-22 10:02:06 +0800 | [diff] [blame] | 691 | result = acpi_battery_get_state(battery); |
Lan Tianyu | 7b78622 | 2011-06-30 11:33:27 +0800 | [diff] [blame] | 692 | acpi_battery_quirks(battery); |
Zhang Rui | 557d586 | 2010-10-22 10:02:06 +0800 | [diff] [blame] | 693 | return result; |
Vladimir Lebedev | 4bd35cd | 2007-02-10 01:43:48 -0500 | [diff] [blame] | 694 | } |
| 695 | |
Rafael J. Wysocki | da8aeb9 | 2011-01-06 23:42:27 +0100 | [diff] [blame] | 696 | static void acpi_battery_refresh(struct acpi_battery *battery) |
| 697 | { |
Andy Whitcroft | c597145 | 2012-05-03 14:48:26 +0100 | [diff] [blame] | 698 | int power_unit; |
| 699 | |
Rafael J. Wysocki | da8aeb9 | 2011-01-06 23:42:27 +0100 | [diff] [blame] | 700 | if (!battery->bat.dev) |
| 701 | return; |
| 702 | |
Andy Whitcroft | c597145 | 2012-05-03 14:48:26 +0100 | [diff] [blame] | 703 | power_unit = battery->power_unit; |
| 704 | |
Rafael J. Wysocki | da8aeb9 | 2011-01-06 23:42:27 +0100 | [diff] [blame] | 705 | acpi_battery_get_info(battery); |
Andy Whitcroft | c597145 | 2012-05-03 14:48:26 +0100 | [diff] [blame] | 706 | |
| 707 | if (power_unit == battery->power_unit) |
| 708 | return; |
| 709 | |
| 710 | /* The battery has changed its reporting units. */ |
Rafael J. Wysocki | da8aeb9 | 2011-01-06 23:42:27 +0100 | [diff] [blame] | 711 | sysfs_remove_battery(battery); |
| 712 | sysfs_add_battery(battery); |
| 713 | } |
| 714 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 715 | /* -------------------------------------------------------------------------- |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 716 | Driver Interface |
| 717 | -------------------------------------------------------------------------- */ |
| 718 | |
Bjorn Helgaas | d940669 | 2009-04-30 09:35:47 -0600 | [diff] [blame] | 719 | static void acpi_battery_notify(struct acpi_device *device, u32 event) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 720 | { |
Bjorn Helgaas | d940669 | 2009-04-30 09:35:47 -0600 | [diff] [blame] | 721 | struct acpi_battery *battery = acpi_driver_data(device); |
Zhang Rui | 153e500 | 2010-07-07 09:11:57 +0800 | [diff] [blame] | 722 | struct device *old; |
Bjorn Helgaas | d940669 | 2009-04-30 09:35:47 -0600 | [diff] [blame] | 723 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 724 | if (!battery) |
Patrick Mochel | d550d98 | 2006-06-27 00:41:40 -0400 | [diff] [blame] | 725 | return; |
Zhang Rui | 153e500 | 2010-07-07 09:11:57 +0800 | [diff] [blame] | 726 | old = battery->bat.dev; |
Rafael J. Wysocki | da8aeb9 | 2011-01-06 23:42:27 +0100 | [diff] [blame] | 727 | if (event == ACPI_BATTERY_NOTIFY_INFO) |
| 728 | acpi_battery_refresh(battery); |
Alexey Starikovskiy | f1d4661 | 2007-09-26 19:42:52 +0400 | [diff] [blame] | 729 | acpi_battery_update(battery); |
Alexey Starikovskiy | f1d4661 | 2007-09-26 19:42:52 +0400 | [diff] [blame] | 730 | acpi_bus_generate_netlink_event(device->pnp.device_class, |
Kay Sievers | 0794469 | 2008-10-30 01:18:59 +0100 | [diff] [blame] | 731 | dev_name(&device->dev), event, |
Vladimir Lebedev | 9ea7d57 | 2007-02-20 15:48:06 +0300 | [diff] [blame] | 732 | acpi_battery_present(battery)); |
Justin P. Mattock | 2345baf | 2009-12-13 14:42:36 -0800 | [diff] [blame] | 733 | /* acpi_battery_update could remove power_supply object */ |
Zhang Rui | 153e500 | 2010-07-07 09:11:57 +0800 | [diff] [blame] | 734 | if (old && battery->bat.dev) |
Alan Jenkins | f79e1ce | 2009-06-30 14:36:16 +0000 | [diff] [blame] | 735 | power_supply_changed(&battery->bat); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 736 | } |
| 737 | |
Kyle McMartin | 25be582 | 2011-03-22 16:19:50 -0400 | [diff] [blame] | 738 | static int battery_notify(struct notifier_block *nb, |
| 739 | unsigned long mode, void *_unused) |
| 740 | { |
| 741 | struct acpi_battery *battery = container_of(nb, struct acpi_battery, |
| 742 | pm_nb); |
| 743 | switch (mode) { |
Lan Tianyu | d5a5911 | 2011-06-30 11:33:40 +0800 | [diff] [blame] | 744 | case PM_POST_HIBERNATION: |
Kyle McMartin | 25be582 | 2011-03-22 16:19:50 -0400 | [diff] [blame] | 745 | case PM_POST_SUSPEND: |
Lan Tianyu | 6e17fb6 | 2011-06-30 11:33:58 +0800 | [diff] [blame] | 746 | if (battery->bat.dev) { |
| 747 | sysfs_remove_battery(battery); |
| 748 | sysfs_add_battery(battery); |
| 749 | } |
Kyle McMartin | 25be582 | 2011-03-22 16:19:50 -0400 | [diff] [blame] | 750 | break; |
| 751 | } |
| 752 | |
| 753 | return 0; |
| 754 | } |
| 755 | |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 756 | static int acpi_battery_add(struct acpi_device *device) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 757 | { |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 758 | int result = 0; |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 759 | struct acpi_battery *battery = NULL; |
Jiang Liu | 952c63e | 2013-06-29 00:24:38 +0800 | [diff] [blame] | 760 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 761 | if (!device) |
Patrick Mochel | d550d98 | 2006-06-27 00:41:40 -0400 | [diff] [blame] | 762 | return -EINVAL; |
Burman Yan | 36bcbec | 2006-12-19 12:56:11 -0800 | [diff] [blame] | 763 | battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 764 | if (!battery) |
Patrick Mochel | d550d98 | 2006-06-27 00:41:40 -0400 | [diff] [blame] | 765 | return -ENOMEM; |
Patrick Mochel | 145def8 | 2006-05-19 16:54:39 -0400 | [diff] [blame] | 766 | battery->device = device; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 767 | strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME); |
| 768 | strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS); |
Pavel Machek | db89b4f | 2008-09-22 14:37:34 -0700 | [diff] [blame] | 769 | device->driver_data = battery; |
Alexey Starikovskiy | 038fdea | 2007-09-26 19:42:46 +0400 | [diff] [blame] | 770 | mutex_init(&battery->lock); |
Sergey Senozhatsky | 69d94ec | 2011-08-06 01:34:08 +0300 | [diff] [blame] | 771 | mutex_init(&battery->sysfs_lock); |
Jiang Liu | 952c63e | 2013-06-29 00:24:38 +0800 | [diff] [blame] | 772 | if (acpi_has_method(battery->device->handle, "_BIX")) |
Alexey Starikovskiy | c67fcd6 | 2009-10-15 14:31:44 +0400 | [diff] [blame] | 773 | set_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags); |
Stefan Hajnoczi | eb03cb0 | 2011-07-12 09:03:29 +0100 | [diff] [blame] | 774 | result = acpi_battery_update(battery); |
| 775 | if (result) |
| 776 | goto fail; |
Kyle McMartin | 25be582 | 2011-03-22 16:19:50 -0400 | [diff] [blame] | 777 | |
Stefan Hajnoczi | e80bba4 | 2011-07-12 09:03:28 +0100 | [diff] [blame] | 778 | printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n", |
| 779 | ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device), |
| 780 | device->status.battery_present ? "present" : "absent"); |
| 781 | |
Kyle McMartin | 25be582 | 2011-03-22 16:19:50 -0400 | [diff] [blame] | 782 | battery->pm_nb.notifier_call = battery_notify; |
| 783 | register_pm_notifier(&battery->pm_nb); |
| 784 | |
Patrick Mochel | d550d98 | 2006-06-27 00:41:40 -0400 | [diff] [blame] | 785 | return result; |
Stefan Hajnoczi | e80bba4 | 2011-07-12 09:03:28 +0100 | [diff] [blame] | 786 | |
| 787 | fail: |
| 788 | sysfs_remove_battery(battery); |
| 789 | mutex_destroy(&battery->lock); |
Sergey Senozhatsky | 69d94ec | 2011-08-06 01:34:08 +0300 | [diff] [blame] | 790 | mutex_destroy(&battery->sysfs_lock); |
Stefan Hajnoczi | e80bba4 | 2011-07-12 09:03:28 +0100 | [diff] [blame] | 791 | kfree(battery); |
| 792 | return result; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 793 | } |
| 794 | |
Rafael J. Wysocki | 51fac83 | 2013-01-24 00:24:48 +0100 | [diff] [blame] | 795 | static int acpi_battery_remove(struct acpi_device *device) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 796 | { |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 797 | struct acpi_battery *battery = NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 798 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 799 | if (!device || !acpi_driver_data(device)) |
Patrick Mochel | d550d98 | 2006-06-27 00:41:40 -0400 | [diff] [blame] | 800 | return -EINVAL; |
Jan Engelhardt | 50dd096 | 2006-10-01 00:28:50 +0200 | [diff] [blame] | 801 | battery = acpi_driver_data(device); |
Kyle McMartin | 25be582 | 2011-03-22 16:19:50 -0400 | [diff] [blame] | 802 | unregister_pm_notifier(&battery->pm_nb); |
Andrey Borzenkov | 508df92 | 2007-10-28 12:50:09 +0300 | [diff] [blame] | 803 | sysfs_remove_battery(battery); |
Alexey Starikovskiy | 038fdea | 2007-09-26 19:42:46 +0400 | [diff] [blame] | 804 | mutex_destroy(&battery->lock); |
Sergey Senozhatsky | 69d94ec | 2011-08-06 01:34:08 +0300 | [diff] [blame] | 805 | mutex_destroy(&battery->sysfs_lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 806 | kfree(battery); |
Patrick Mochel | d550d98 | 2006-06-27 00:41:40 -0400 | [diff] [blame] | 807 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 808 | } |
| 809 | |
Rafael J. Wysocki | 9069240 | 2012-08-09 23:00:02 +0200 | [diff] [blame] | 810 | #ifdef CONFIG_PM_SLEEP |
Jiri Kosina | 34c4415 | 2006-10-10 14:20:41 -0700 | [diff] [blame] | 811 | /* this is needed to learn about changes made in suspended state */ |
Rafael J. Wysocki | a6f50dc | 2012-06-27 23:26:43 +0200 | [diff] [blame] | 812 | static int acpi_battery_resume(struct device *dev) |
Jiri Kosina | 34c4415 | 2006-10-10 14:20:41 -0700 | [diff] [blame] | 813 | { |
| 814 | struct acpi_battery *battery; |
Rafael J. Wysocki | a6f50dc | 2012-06-27 23:26:43 +0200 | [diff] [blame] | 815 | |
| 816 | if (!dev) |
Jiri Kosina | 34c4415 | 2006-10-10 14:20:41 -0700 | [diff] [blame] | 817 | return -EINVAL; |
Rafael J. Wysocki | a6f50dc | 2012-06-27 23:26:43 +0200 | [diff] [blame] | 818 | |
| 819 | battery = acpi_driver_data(to_acpi_device(dev)); |
| 820 | if (!battery) |
| 821 | return -EINVAL; |
| 822 | |
Alexey Starikovskiy | f1d4661 | 2007-09-26 19:42:52 +0400 | [diff] [blame] | 823 | battery->update_time = 0; |
Andrey Borzenkov | 508df92 | 2007-10-28 12:50:09 +0300 | [diff] [blame] | 824 | acpi_battery_update(battery); |
Vladimir Lebedev | b6ce408 | 2007-02-20 15:48:06 +0300 | [diff] [blame] | 825 | return 0; |
Jiri Kosina | 34c4415 | 2006-10-10 14:20:41 -0700 | [diff] [blame] | 826 | } |
Rafael J. Wysocki | 9069240 | 2012-08-09 23:00:02 +0200 | [diff] [blame] | 827 | #endif |
Jiri Kosina | 34c4415 | 2006-10-10 14:20:41 -0700 | [diff] [blame] | 828 | |
Rafael J. Wysocki | a6f50dc | 2012-06-27 23:26:43 +0200 | [diff] [blame] | 829 | static SIMPLE_DEV_PM_OPS(acpi_battery_pm, NULL, acpi_battery_resume); |
| 830 | |
Alexey Starikovskiy | aa650bb | 2007-09-26 19:42:58 +0400 | [diff] [blame] | 831 | static struct acpi_driver acpi_battery_driver = { |
| 832 | .name = "battery", |
| 833 | .class = ACPI_BATTERY_CLASS, |
| 834 | .ids = battery_device_ids, |
Bjorn Helgaas | d940669 | 2009-04-30 09:35:47 -0600 | [diff] [blame] | 835 | .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS, |
Alexey Starikovskiy | aa650bb | 2007-09-26 19:42:58 +0400 | [diff] [blame] | 836 | .ops = { |
| 837 | .add = acpi_battery_add, |
Alexey Starikovskiy | aa650bb | 2007-09-26 19:42:58 +0400 | [diff] [blame] | 838 | .remove = acpi_battery_remove, |
Bjorn Helgaas | d940669 | 2009-04-30 09:35:47 -0600 | [diff] [blame] | 839 | .notify = acpi_battery_notify, |
Alexey Starikovskiy | aa650bb | 2007-09-26 19:42:58 +0400 | [diff] [blame] | 840 | }, |
Rafael J. Wysocki | a6f50dc | 2012-06-27 23:26:43 +0200 | [diff] [blame] | 841 | .drv.pm = &acpi_battery_pm, |
Alexey Starikovskiy | aa650bb | 2007-09-26 19:42:58 +0400 | [diff] [blame] | 842 | }; |
| 843 | |
Linus Torvalds | b0cbc86 | 2009-04-11 12:45:20 -0700 | [diff] [blame] | 844 | static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 845 | { |
Pavel Machek | 4d8316d | 2006-08-14 22:37:22 -0700 | [diff] [blame] | 846 | if (acpi_disabled) |
Arjan van de Ven | 0f66af5 | 2009-01-10 14:19:05 -0500 | [diff] [blame] | 847 | return; |
Lan Tianyu | 1e2d9cd | 2013-10-11 09:54:08 +0800 | [diff] [blame] | 848 | acpi_bus_register_driver(&acpi_battery_driver); |
Arjan van de Ven | 0f66af5 | 2009-01-10 14:19:05 -0500 | [diff] [blame] | 849 | } |
| 850 | |
| 851 | static int __init acpi_battery_init(void) |
| 852 | { |
| 853 | async_schedule(acpi_battery_init_async, NULL); |
Patrick Mochel | d550d98 | 2006-06-27 00:41:40 -0400 | [diff] [blame] | 854 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 855 | } |
| 856 | |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 857 | static void __exit acpi_battery_exit(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 858 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 859 | acpi_bus_unregister_driver(&acpi_battery_driver); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 860 | } |
| 861 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 862 | module_init(acpi_battery_init); |
| 863 | module_exit(acpi_battery_exit); |