]>
Commit | Line | Data |
---|---|---|
c942fddf | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
1da177e4 LT |
2 | /* |
3 | * acpi_ac.c - ACPI AC Adapter Driver ($Revision: 27 $) | |
4 | * | |
5 | * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com> | |
6 | * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com> | |
1da177e4 LT |
7 | */ |
8 | ||
9 | #include <linux/kernel.h> | |
10 | #include <linux/module.h> | |
5a0e3ad6 | 11 | #include <linux/slab.h> |
1da177e4 LT |
12 | #include <linux/init.h> |
13 | #include <linux/types.h> | |
0ab5bb64 LT |
14 | #include <linux/dmi.h> |
15 | #include <linux/delay.h> | |
cc8ef527 | 16 | #include <linux/platform_device.h> |
d5b4a3d0 | 17 | #include <linux/power_supply.h> |
8b48463f | 18 | #include <linux/acpi.h> |
fa93854f | 19 | #include <acpi/battery.h> |
1da177e4 | 20 | |
a192a958 LB |
21 | #define PREFIX "ACPI: " |
22 | ||
1da177e4 | 23 | #define ACPI_AC_CLASS "ac_adapter" |
1da177e4 LT |
24 | #define ACPI_AC_DEVICE_NAME "AC Adapter" |
25 | #define ACPI_AC_FILE_STATE "state" | |
26 | #define ACPI_AC_NOTIFY_STATUS 0x80 | |
27 | #define ACPI_AC_STATUS_OFFLINE 0x00 | |
28 | #define ACPI_AC_STATUS_ONLINE 0x01 | |
29 | #define ACPI_AC_STATUS_UNKNOWN 0xFF | |
30 | ||
31 | #define _COMPONENT ACPI_AC_COMPONENT | |
f52fd66d | 32 | ACPI_MODULE_NAME("ac"); |
1da177e4 | 33 | |
f52fd66d | 34 | MODULE_AUTHOR("Paul Diefenbaugh"); |
7cda93e0 | 35 | MODULE_DESCRIPTION("ACPI AC Adapter Driver"); |
1da177e4 LT |
36 | MODULE_LICENSE("GPL"); |
37 | ||
e63f6e28 | 38 | |
98012849 GR |
39 | static int acpi_ac_add(struct acpi_device *device); |
40 | static int acpi_ac_remove(struct acpi_device *device); | |
41 | static void acpi_ac_notify(struct acpi_device *device, u32 event); | |
42 | ||
af3ec837 HG |
43 | struct acpi_ac_bl { |
44 | const char *hid; | |
45 | int hrv; | |
46 | }; | |
47 | ||
98012849 GR |
48 | static const struct acpi_device_id ac_device_ids[] = { |
49 | {"ACPI0003", 0}, | |
50 | {"", 0}, | |
51 | }; | |
52 | MODULE_DEVICE_TABLE(acpi, ac_device_ids); | |
53 | ||
af3ec837 HG |
54 | /* Lists of PMIC ACPI HIDs with an (often better) native charger driver */ |
55 | static const struct acpi_ac_bl acpi_ac_blacklist[] = { | |
56 | { "INT33F4", -1 }, /* X-Powers AXP288 PMIC */ | |
57 | { "INT34D3", 3 }, /* Intel Cherrytrail Whiskey Cove PMIC */ | |
58 | }; | |
59 | ||
98012849 GR |
60 | #ifdef CONFIG_PM_SLEEP |
61 | static int acpi_ac_resume(struct device *dev); | |
62 | #endif | |
63 | static SIMPLE_DEV_PM_OPS(acpi_ac_pm, NULL, acpi_ac_resume); | |
64 | ||
0ab5bb64 | 65 | static int ac_sleep_before_get_state_ms; |
91ea5b1d | 66 | static int ac_check_pmic = 1; |
0ab5bb64 | 67 | |
98012849 GR |
68 | static struct acpi_driver acpi_ac_driver = { |
69 | .name = "ac", | |
70 | .class = ACPI_AC_CLASS, | |
71 | .ids = ac_device_ids, | |
72 | .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS, | |
73 | .ops = { | |
74 | .add = acpi_ac_add, | |
75 | .remove = acpi_ac_remove, | |
76 | .notify = acpi_ac_notify, | |
77 | }, | |
78 | .drv.pm = &acpi_ac_pm, | |
79 | }; | |
80 | ||
1da177e4 | 81 | struct acpi_ac { |
297d716f KK |
82 | struct power_supply *charger; |
83 | struct power_supply_desc charger_desc; | |
98012849 | 84 | struct acpi_device * device; |
27663c58 | 85 | unsigned long long state; |
4eee4f03 | 86 | struct notifier_block battery_nb; |
1da177e4 LT |
87 | }; |
88 | ||
297d716f | 89 | #define to_acpi_ac(x) power_supply_get_drvdata(x) |
d5b4a3d0 | 90 | |
1da177e4 LT |
91 | /* -------------------------------------------------------------------------- |
92 | AC Adapter Management | |
93 | -------------------------------------------------------------------------- */ | |
94 | ||
4be44fcd | 95 | static int acpi_ac_get_state(struct acpi_ac *ac) |
1da177e4 | 96 | { |
98012849 GR |
97 | acpi_status status = AE_OK; |
98 | ||
99 | if (!ac) | |
100 | return -EINVAL; | |
1da177e4 | 101 | |
98012849 | 102 | status = acpi_evaluate_integer(ac->device->handle, "_PSR", NULL, |
cc8ef527 | 103 | &ac->state); |
1da177e4 | 104 | if (ACPI_FAILURE(status)) { |
cc8ef527 ZR |
105 | ACPI_EXCEPTION((AE_INFO, status, |
106 | "Error reading AC Adapter state")); | |
1da177e4 | 107 | ac->state = ACPI_AC_STATUS_UNKNOWN; |
d550d98d | 108 | return -ENODEV; |
1da177e4 | 109 | } |
4be44fcd | 110 | |
d550d98d | 111 | return 0; |
1da177e4 LT |
112 | } |
113 | ||
3151dbb0 ZR |
114 | /* -------------------------------------------------------------------------- |
115 | sysfs I/F | |
116 | -------------------------------------------------------------------------- */ | |
117 | static int get_ac_property(struct power_supply *psy, | |
118 | enum power_supply_property psp, | |
119 | union power_supply_propval *val) | |
120 | { | |
121 | struct acpi_ac *ac = to_acpi_ac(psy); | |
122 | ||
123 | if (!ac) | |
124 | return -ENODEV; | |
125 | ||
126 | if (acpi_ac_get_state(ac)) | |
127 | return -ENODEV; | |
128 | ||
129 | switch (psp) { | |
130 | case POWER_SUPPLY_PROP_ONLINE: | |
131 | val->intval = ac->state; | |
132 | break; | |
133 | default: | |
134 | return -EINVAL; | |
135 | } | |
136 | return 0; | |
137 | } | |
138 | ||
139 | static enum power_supply_property ac_props[] = { | |
140 | POWER_SUPPLY_PROP_ONLINE, | |
141 | }; | |
142 | ||
1da177e4 LT |
143 | /* -------------------------------------------------------------------------- |
144 | Driver Model | |
145 | -------------------------------------------------------------------------- */ | |
146 | ||
98012849 | 147 | static void acpi_ac_notify(struct acpi_device *device, u32 event) |
1da177e4 | 148 | { |
98012849 | 149 | struct acpi_ac *ac = acpi_driver_data(device); |
1da177e4 LT |
150 | |
151 | if (!ac) | |
d550d98d | 152 | return; |
1da177e4 | 153 | |
1da177e4 | 154 | switch (event) { |
f163ff51 LB |
155 | default: |
156 | ACPI_DEBUG_PRINT((ACPI_DB_INFO, | |
157 | "Unsupported event [0x%x]\n", event)); | |
57d2dd4b | 158 | fallthrough; |
1da177e4 | 159 | case ACPI_AC_NOTIFY_STATUS: |
03d78252 CL |
160 | case ACPI_NOTIFY_BUS_CHECK: |
161 | case ACPI_NOTIFY_DEVICE_CHECK: | |
0ab5bb64 LT |
162 | /* |
163 | * A buggy BIOS may notify AC first and then sleep for | |
164 | * a specific time before doing actual operations in the | |
165 | * EC event handler (_Qxx). This will cause the AC state | |
166 | * reported by the ACPI event to be incorrect, so wait for a | |
167 | * specific time for the EC event handler to make progress. | |
168 | */ | |
169 | if (ac_sleep_before_get_state_ms > 0) | |
170 | msleep(ac_sleep_before_get_state_ms); | |
171 | ||
1da177e4 | 172 | acpi_ac_get_state(ac); |
98012849 GR |
173 | acpi_bus_generate_netlink_event(device->pnp.device_class, |
174 | dev_name(&device->dev), event, | |
175 | (u32) ac->state); | |
176 | acpi_notifier_call_chain(device, event, (u32) ac->state); | |
297d716f | 177 | kobject_uevent(&ac->charger->dev.kobj, KOBJ_CHANGE); |
1da177e4 LT |
178 | } |
179 | ||
d550d98d | 180 | return; |
1da177e4 LT |
181 | } |
182 | ||
4eee4f03 AM |
183 | static int acpi_ac_battery_notify(struct notifier_block *nb, |
184 | unsigned long action, void *data) | |
185 | { | |
186 | struct acpi_ac *ac = container_of(nb, struct acpi_ac, battery_nb); | |
187 | struct acpi_bus_event *event = (struct acpi_bus_event *)data; | |
188 | ||
189 | /* | |
190 | * On HP Pavilion dv6-6179er AC status notifications aren't triggered | |
191 | * when adapter is plugged/unplugged. However, battery status | |
192 | * notifcations are triggered when battery starts charging or | |
193 | * discharging. Re-reading AC status triggers lost AC notifications, | |
194 | * if AC status has changed. | |
195 | */ | |
196 | if (strcmp(event->device_class, ACPI_BATTERY_CLASS) == 0 && | |
197 | event->type == ACPI_BATTERY_NOTIFY_STATUS) | |
198 | acpi_ac_get_state(ac); | |
199 | ||
200 | return NOTIFY_OK; | |
201 | } | |
202 | ||
91ea5b1d | 203 | static int __init thinkpad_e530_quirk(const struct dmi_system_id *d) |
0ab5bb64 LT |
204 | { |
205 | ac_sleep_before_get_state_ms = 1000; | |
206 | return 0; | |
207 | } | |
208 | ||
91ea5b1d CC |
209 | static int __init ac_do_not_check_pmic_quirk(const struct dmi_system_id *d) |
210 | { | |
211 | ac_check_pmic = 0; | |
212 | return 0; | |
213 | } | |
214 | ||
04900fa3 | 215 | /* Please keep this list alphabetically sorted */ |
91ea5b1d | 216 | static const struct dmi_system_id ac_dmi_table[] __initconst = { |
0ab5bb64 | 217 | { |
04900fa3 HG |
218 | /* ECS EF20EA, AXP288 PMIC but uses separate fuel-gauge */ |
219 | .callback = ac_do_not_check_pmic_quirk, | |
220 | .matches = { | |
221 | DMI_MATCH(DMI_PRODUCT_NAME, "EF20EA"), | |
0ab5bb64 LT |
222 | }, |
223 | }, | |
91ea5b1d | 224 | { |
04900fa3 | 225 | /* Lenovo Ideapad Miix 320, AXP288 PMIC, separate fuel-gauge */ |
91ea5b1d CC |
226 | .callback = ac_do_not_check_pmic_quirk, |
227 | .matches = { | |
04900fa3 HG |
228 | DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), |
229 | DMI_MATCH(DMI_PRODUCT_NAME, "80XF"), | |
230 | DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo MIIX 320-10ICR"), | |
91ea5b1d CC |
231 | }, |
232 | }, | |
233 | { | |
04900fa3 HG |
234 | /* Lenovo Thinkpad e530, see comment in acpi_ac_notify() */ |
235 | .callback = thinkpad_e530_quirk, | |
91ea5b1d | 236 | .matches = { |
04900fa3 HG |
237 | DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), |
238 | DMI_MATCH(DMI_PRODUCT_NAME, "32597CG"), | |
91ea5b1d CC |
239 | }, |
240 | }, | |
0ab5bb64 LT |
241 | {}, |
242 | }; | |
243 | ||
98012849 | 244 | static int acpi_ac_add(struct acpi_device *device) |
1da177e4 | 245 | { |
297d716f | 246 | struct power_supply_config psy_cfg = {}; |
4be44fcd | 247 | int result = 0; |
4be44fcd | 248 | struct acpi_ac *ac = NULL; |
1da177e4 | 249 | |
1da177e4 | 250 | |
98012849 GR |
251 | if (!device) |
252 | return -EINVAL; | |
cc8ef527 | 253 | |
36bcbec7 | 254 | ac = kzalloc(sizeof(struct acpi_ac), GFP_KERNEL); |
1da177e4 | 255 | if (!ac) |
d550d98d | 256 | return -ENOMEM; |
1da177e4 | 257 | |
98012849 GR |
258 | ac->device = device; |
259 | strcpy(acpi_device_name(device), ACPI_AC_DEVICE_NAME); | |
260 | strcpy(acpi_device_class(device), ACPI_AC_CLASS); | |
261 | device->driver_data = ac; | |
1da177e4 LT |
262 | |
263 | result = acpi_ac_get_state(ac); | |
264 | if (result) | |
265 | goto end; | |
266 | ||
297d716f KK |
267 | psy_cfg.drv_data = ac; |
268 | ||
269 | ac->charger_desc.name = acpi_device_bid(device); | |
297d716f KK |
270 | ac->charger_desc.type = POWER_SUPPLY_TYPE_MAINS; |
271 | ac->charger_desc.properties = ac_props; | |
272 | ac->charger_desc.num_properties = ARRAY_SIZE(ac_props); | |
273 | ac->charger_desc.get_property = get_ac_property; | |
274 | ac->charger = power_supply_register(&ac->device->dev, | |
275 | &ac->charger_desc, &psy_cfg); | |
276 | if (IS_ERR(ac->charger)) { | |
277 | result = PTR_ERR(ac->charger); | |
f197ac13 | 278 | goto end; |
297d716f | 279 | } |
1da177e4 | 280 | |
4be44fcd | 281 | printk(KERN_INFO PREFIX "%s [%s] (%s)\n", |
98012849 | 282 | acpi_device_name(device), acpi_device_bid(device), |
4be44fcd | 283 | ac->state ? "on-line" : "off-line"); |
1da177e4 | 284 | |
4eee4f03 AM |
285 | ac->battery_nb.notifier_call = acpi_ac_battery_notify; |
286 | register_acpi_notifier(&ac->battery_nb); | |
ab0fd674 | 287 | end: |
e63f6e28 | 288 | if (result) { |
1da177e4 | 289 | kfree(ac); |
e63f6e28 | 290 | } |
1da177e4 | 291 | |
d550d98d | 292 | return result; |
1da177e4 LT |
293 | } |
294 | ||
90692404 | 295 | #ifdef CONFIG_PM_SLEEP |
ccda7069 | 296 | static int acpi_ac_resume(struct device *dev) |
5bfeca31 AS |
297 | { |
298 | struct acpi_ac *ac; | |
299 | unsigned old_state; | |
ccda7069 RW |
300 | |
301 | if (!dev) | |
302 | return -EINVAL; | |
303 | ||
98012849 | 304 | ac = acpi_driver_data(to_acpi_device(dev)); |
ccda7069 | 305 | if (!ac) |
5bfeca31 | 306 | return -EINVAL; |
ccda7069 | 307 | |
5bfeca31 AS |
308 | old_state = ac->state; |
309 | if (acpi_ac_get_state(ac)) | |
310 | return 0; | |
311 | if (old_state != ac->state) | |
297d716f | 312 | kobject_uevent(&ac->charger->dev.kobj, KOBJ_CHANGE); |
5bfeca31 AS |
313 | return 0; |
314 | } | |
06521c2e SK |
315 | #else |
316 | #define acpi_ac_resume NULL | |
90692404 | 317 | #endif |
5bfeca31 | 318 | |
98012849 | 319 | static int acpi_ac_remove(struct acpi_device *device) |
1da177e4 | 320 | { |
98012849 GR |
321 | struct acpi_ac *ac = NULL; |
322 | ||
1da177e4 | 323 | |
98012849 | 324 | if (!device || !acpi_driver_data(device)) |
d550d98d | 325 | return -EINVAL; |
1da177e4 | 326 | |
98012849 | 327 | ac = acpi_driver_data(device); |
1da177e4 | 328 | |
297d716f | 329 | power_supply_unregister(ac->charger); |
4eee4f03 | 330 | unregister_acpi_notifier(&ac->battery_nb); |
cc8ef527 | 331 | |
1da177e4 LT |
332 | kfree(ac); |
333 | ||
d550d98d | 334 | return 0; |
1da177e4 LT |
335 | } |
336 | ||
4be44fcd | 337 | static int __init acpi_ac_init(void) |
1da177e4 | 338 | { |
af3ec837 | 339 | unsigned int i; |
3f86b832 | 340 | int result; |
1da177e4 | 341 | |
4d8316d5 PM |
342 | if (acpi_disabled) |
343 | return -ENODEV; | |
1da177e4 | 344 | |
91ea5b1d CC |
345 | dmi_check_system(ac_dmi_table); |
346 | ||
347 | if (ac_check_pmic) { | |
348 | for (i = 0; i < ARRAY_SIZE(acpi_ac_blacklist); i++) | |
349 | if (acpi_dev_present(acpi_ac_blacklist[i].hid, "1", | |
350 | acpi_ac_blacklist[i].hrv)) { | |
351 | pr_info(PREFIX "AC: found native %s PMIC, not loading\n", | |
352 | acpi_ac_blacklist[i].hid); | |
353 | return -ENODEV; | |
354 | } | |
355 | } | |
af3ec837 | 356 | |
98012849 | 357 | result = acpi_bus_register_driver(&acpi_ac_driver); |
e63f6e28 | 358 | if (result < 0) { |
d550d98d | 359 | return -ENODEV; |
e63f6e28 | 360 | } |
1da177e4 | 361 | |
d550d98d | 362 | return 0; |
1da177e4 LT |
363 | } |
364 | ||
4be44fcd | 365 | static void __exit acpi_ac_exit(void) |
1da177e4 | 366 | { |
98012849 | 367 | acpi_bus_unregister_driver(&acpi_ac_driver); |
1da177e4 | 368 | } |
1da177e4 LT |
369 | module_init(acpi_ac_init); |
370 | module_exit(acpi_ac_exit); |