1 // SPDX-License-Identifier: GPL-2.0-or-later
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>
7 */
8
9 #define pr_fmt(fmt) "ACPI: AC: " fmt
10
11 #include <linux/kernel.h>
12 #include <linux/module.h>
13 #include <linux/slab.h>
14 #include <linux/init.h>
15 #include <linux/types.h>
16 #include <linux/dmi.h>
17 #include <linux/delay.h>
18 #include <linux/platform_device.h>
19 #include <linux/power_supply.h>
20 #include <linux/acpi.h>
21 #include <acpi/battery.h>
22
23 #define ACPI_AC_CLASS "ac_adapter"
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 MODULE_AUTHOR("Paul Diefenbaugh");
32 MODULE_DESCRIPTION("ACPI AC Adapter Driver");
33 MODULE_LICENSE("GPL");
34
35 static int acpi_ac_add(struct acpi_device *device);
36 static int acpi_ac_remove(struct acpi_device *device);
37 static void acpi_ac_notify(struct acpi_device *device, u32 event);
38
39 static const struct acpi_device_id ac_device_ids[] = {
40 {"ACPI0003", 0},
41 {"", 0},
42 };
43 MODULE_DEVICE_TABLE(acpi, ac_device_ids);
44
45 #ifdef CONFIG_PM_SLEEP
46 static int acpi_ac_resume(struct device *dev);
47 #endif
48 static SIMPLE_DEV_PM_OPS(acpi_ac_pm, NULL, acpi_ac_resume);
49
50 static int ac_sleep_before_get_state_ms;
51 static int ac_only;
52
53 static struct acpi_driver acpi_ac_driver = {
54 .name = "ac",
55 .class = ACPI_AC_CLASS,
56 .ids = ac_device_ids,
57 .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
58 .ops = {
59 .add = acpi_ac_add,
60 .remove = acpi_ac_remove,
61 .notify = acpi_ac_notify,
62 },
63 .drv.pm = &acpi_ac_pm,
64 };
65
66 struct acpi_ac {
67 struct power_supply *charger;
68 struct power_supply_desc charger_desc;
69 struct acpi_device *device;
70 unsigned long long state;
71 struct notifier_block battery_nb;
72 };
73
74 #define to_acpi_ac(x) power_supply_get_drvdata(x)
75
76 /* AC Adapter Management */
acpi_ac_get_state(struct acpi_ac * ac)77 static int acpi_ac_get_state(struct acpi_ac *ac)
78 {
79 acpi_status status = AE_OK;
80
81 if (!ac)
82 return -EINVAL;
83
84 if (ac_only) {
85 ac->state = 1;
86 return 0;
87 }
88
89 status = acpi_evaluate_integer(ac->device->handle, "_PSR", NULL,
90 &ac->state);
91 if (ACPI_FAILURE(status)) {
92 acpi_handle_info(ac->device->handle,
93 "Error reading AC Adapter state: %s\n",
94 acpi_format_exception(status));
95 ac->state = ACPI_AC_STATUS_UNKNOWN;
96 return -ENODEV;
97 }
98
99 return 0;
100 }
101
102 /* sysfs I/F */
get_ac_property(struct power_supply * psy,enum power_supply_property psp,union power_supply_propval * val)103 static int get_ac_property(struct power_supply *psy,
104 enum power_supply_property psp,
105 union power_supply_propval *val)
106 {
107 struct acpi_ac *ac = to_acpi_ac(psy);
108
109 if (!ac)
110 return -ENODEV;
111
112 if (acpi_ac_get_state(ac))
113 return -ENODEV;
114
115 switch (psp) {
116 case POWER_SUPPLY_PROP_ONLINE:
117 val->intval = ac->state;
118 break;
119 default:
120 return -EINVAL;
121 }
122
123 return 0;
124 }
125
126 static enum power_supply_property ac_props[] = {
127 POWER_SUPPLY_PROP_ONLINE,
128 };
129
130 /* Driver Model */
acpi_ac_notify(struct acpi_device * device,u32 event)131 static void acpi_ac_notify(struct acpi_device *device, u32 event)
132 {
133 struct acpi_ac *ac = acpi_driver_data(device);
134
135 if (!ac)
136 return;
137
138 switch (event) {
139 default:
140 acpi_handle_debug(device->handle, "Unsupported event [0x%x]\n",
141 event);
142 fallthrough;
143 case ACPI_AC_NOTIFY_STATUS:
144 case ACPI_NOTIFY_BUS_CHECK:
145 case ACPI_NOTIFY_DEVICE_CHECK:
146 /*
147 * A buggy BIOS may notify AC first and then sleep for
148 * a specific time before doing actual operations in the
149 * EC event handler (_Qxx). This will cause the AC state
150 * reported by the ACPI event to be incorrect, so wait for a
151 * specific time for the EC event handler to make progress.
152 */
153 if (ac_sleep_before_get_state_ms > 0)
154 msleep(ac_sleep_before_get_state_ms);
155
156 acpi_ac_get_state(ac);
157 acpi_bus_generate_netlink_event(device->pnp.device_class,
158 dev_name(&device->dev), event,
159 (u32) ac->state);
160 acpi_notifier_call_chain(device, event, (u32) ac->state);
161 kobject_uevent(&ac->charger->dev.kobj, KOBJ_CHANGE);
162 }
163 }
164
acpi_ac_battery_notify(struct notifier_block * nb,unsigned long action,void * data)165 static int acpi_ac_battery_notify(struct notifier_block *nb,
166 unsigned long action, void *data)
167 {
168 struct acpi_ac *ac = container_of(nb, struct acpi_ac, battery_nb);
169 struct acpi_bus_event *event = (struct acpi_bus_event *)data;
170
171 /*
172 * On HP Pavilion dv6-6179er AC status notifications aren't triggered
173 * when adapter is plugged/unplugged. However, battery status
174 * notifications are triggered when battery starts charging or
175 * discharging. Re-reading AC status triggers lost AC notifications,
176 * if AC status has changed.
177 */
178 if (strcmp(event->device_class, ACPI_BATTERY_CLASS) == 0 &&
179 event->type == ACPI_BATTERY_NOTIFY_STATUS)
180 acpi_ac_get_state(ac);
181
182 return NOTIFY_OK;
183 }
184
thinkpad_e530_quirk(const struct dmi_system_id * d)185 static int __init thinkpad_e530_quirk(const struct dmi_system_id *d)
186 {
187 ac_sleep_before_get_state_ms = 1000;
188 return 0;
189 }
190
ac_only_quirk(const struct dmi_system_id * d)191 static int __init ac_only_quirk(const struct dmi_system_id *d)
192 {
193 ac_only = 1;
194 return 0;
195 }
196
197 /* Please keep this list alphabetically sorted */
198 static const struct dmi_system_id ac_dmi_table[] __initconst = {
199 {
200 /* Kodlix GK45 returning incorrect state */
201 .callback = ac_only_quirk,
202 .matches = {
203 DMI_MATCH(DMI_PRODUCT_NAME, "GK45"),
204 },
205 },
206 {
207 /* Lenovo Thinkpad e530, see comment in acpi_ac_notify() */
208 .callback = thinkpad_e530_quirk,
209 .matches = {
210 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
211 DMI_MATCH(DMI_PRODUCT_NAME, "32597CG"),
212 },
213 },
214 {},
215 };
216
acpi_ac_add(struct acpi_device * device)217 static int acpi_ac_add(struct acpi_device *device)
218 {
219 struct power_supply_config psy_cfg = {};
220 int result = 0;
221 struct acpi_ac *ac = NULL;
222
223
224 if (!device)
225 return -EINVAL;
226
227 ac = kzalloc(sizeof(struct acpi_ac), GFP_KERNEL);
228 if (!ac)
229 return -ENOMEM;
230
231 ac->device = device;
232 strcpy(acpi_device_name(device), ACPI_AC_DEVICE_NAME);
233 strcpy(acpi_device_class(device), ACPI_AC_CLASS);
234 device->driver_data = ac;
235
236 result = acpi_ac_get_state(ac);
237 if (result)
238 goto end;
239
240 psy_cfg.drv_data = ac;
241
242 ac->charger_desc.name = acpi_device_bid(device);
243 ac->charger_desc.type = POWER_SUPPLY_TYPE_MAINS;
244 ac->charger_desc.properties = ac_props;
245 ac->charger_desc.num_properties = ARRAY_SIZE(ac_props);
246 ac->charger_desc.get_property = get_ac_property;
247 ac->charger = power_supply_register(&ac->device->dev,
248 &ac->charger_desc, &psy_cfg);
249 if (IS_ERR(ac->charger)) {
250 result = PTR_ERR(ac->charger);
251 goto end;
252 }
253
254 pr_info("%s [%s] (%s)\n", acpi_device_name(device),
255 acpi_device_bid(device), ac->state ? "on-line" : "off-line");
256
257 ac->battery_nb.notifier_call = acpi_ac_battery_notify;
258 register_acpi_notifier(&ac->battery_nb);
259 end:
260 if (result)
261 kfree(ac);
262
263 return result;
264 }
265
266 #ifdef CONFIG_PM_SLEEP
acpi_ac_resume(struct device * dev)267 static int acpi_ac_resume(struct device *dev)
268 {
269 struct acpi_ac *ac;
270 unsigned int old_state;
271
272 if (!dev)
273 return -EINVAL;
274
275 ac = acpi_driver_data(to_acpi_device(dev));
276 if (!ac)
277 return -EINVAL;
278
279 old_state = ac->state;
280 if (acpi_ac_get_state(ac))
281 return 0;
282 if (old_state != ac->state)
283 kobject_uevent(&ac->charger->dev.kobj, KOBJ_CHANGE);
284
285 return 0;
286 }
287 #else
288 #define acpi_ac_resume NULL
289 #endif
290
acpi_ac_remove(struct acpi_device * device)291 static int acpi_ac_remove(struct acpi_device *device)
292 {
293 struct acpi_ac *ac = NULL;
294
295 if (!device || !acpi_driver_data(device))
296 return -EINVAL;
297
298 ac = acpi_driver_data(device);
299
300 power_supply_unregister(ac->charger);
301 unregister_acpi_notifier(&ac->battery_nb);
302
303 kfree(ac);
304
305 return 0;
306 }
307
acpi_ac_init(void)308 static int __init acpi_ac_init(void)
309 {
310 int result;
311
312 if (acpi_disabled)
313 return -ENODEV;
314
315 if (acpi_quirk_skip_acpi_ac_and_battery())
316 return -ENODEV;
317
318 dmi_check_system(ac_dmi_table);
319
320 result = acpi_bus_register_driver(&acpi_ac_driver);
321 if (result < 0)
322 return -ENODEV;
323
324 return 0;
325 }
326
acpi_ac_exit(void)327 static void __exit acpi_ac_exit(void)
328 {
329 acpi_bus_unregister_driver(&acpi_ac_driver);
330 }
331 module_init(acpi_ac_init);
332 module_exit(acpi_ac_exit);
333