xref: /openbmc/linux/drivers/acpi/ac.c (revision 6aa7de05)
1 /*
2  *  acpi_ac.c - ACPI AC Adapter Driver ($Revision: 27 $)
3  *
4  *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
5  *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
6  *
7  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
8  *
9  *  This program is free software; you can redistribute it and/or modify
10  *  it under the terms of the GNU General Public License as published by
11  *  the Free Software Foundation; either version 2 of the License, or (at
12  *  your option) any later version.
13  *
14  *  This program is distributed in the hope that it will be useful, but
15  *  WITHOUT ANY WARRANTY; without even the implied warranty of
16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  *  General Public License for more details.
18  *
19  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
20  */
21 
22 #include <linux/kernel.h>
23 #include <linux/module.h>
24 #include <linux/slab.h>
25 #include <linux/init.h>
26 #include <linux/types.h>
27 #include <linux/dmi.h>
28 #include <linux/delay.h>
29 #ifdef CONFIG_ACPI_PROCFS_POWER
30 #include <linux/proc_fs.h>
31 #include <linux/seq_file.h>
32 #endif
33 #include <linux/platform_device.h>
34 #include <linux/power_supply.h>
35 #include <linux/acpi.h>
36 #include "battery.h"
37 
38 #define PREFIX "ACPI: "
39 
40 #define ACPI_AC_CLASS			"ac_adapter"
41 #define ACPI_AC_DEVICE_NAME		"AC Adapter"
42 #define ACPI_AC_FILE_STATE		"state"
43 #define ACPI_AC_NOTIFY_STATUS		0x80
44 #define ACPI_AC_STATUS_OFFLINE		0x00
45 #define ACPI_AC_STATUS_ONLINE		0x01
46 #define ACPI_AC_STATUS_UNKNOWN		0xFF
47 
48 #define _COMPONENT		ACPI_AC_COMPONENT
49 ACPI_MODULE_NAME("ac");
50 
51 MODULE_AUTHOR("Paul Diefenbaugh");
52 MODULE_DESCRIPTION("ACPI AC Adapter Driver");
53 MODULE_LICENSE("GPL");
54 
55 
56 static int acpi_ac_add(struct acpi_device *device);
57 static int acpi_ac_remove(struct acpi_device *device);
58 static void acpi_ac_notify(struct acpi_device *device, u32 event);
59 
60 struct acpi_ac_bl {
61 	const char *hid;
62 	int hrv;
63 };
64 
65 static const struct acpi_device_id ac_device_ids[] = {
66 	{"ACPI0003", 0},
67 	{"", 0},
68 };
69 MODULE_DEVICE_TABLE(acpi, ac_device_ids);
70 
71 /* Lists of PMIC ACPI HIDs with an (often better) native charger driver */
72 static const struct acpi_ac_bl acpi_ac_blacklist[] = {
73 	{ "INT33F4", -1 }, /* X-Powers AXP288 PMIC */
74 	{ "INT34D3",  3 }, /* Intel Cherrytrail Whiskey Cove PMIC */
75 };
76 
77 #ifdef CONFIG_PM_SLEEP
78 static int acpi_ac_resume(struct device *dev);
79 #endif
80 static SIMPLE_DEV_PM_OPS(acpi_ac_pm, NULL, acpi_ac_resume);
81 
82 #ifdef CONFIG_ACPI_PROCFS_POWER
83 extern struct proc_dir_entry *acpi_lock_ac_dir(void);
84 extern void *acpi_unlock_ac_dir(struct proc_dir_entry *acpi_ac_dir);
85 static int acpi_ac_open_fs(struct inode *inode, struct file *file);
86 #endif
87 
88 
89 static int ac_sleep_before_get_state_ms;
90 
91 static struct acpi_driver acpi_ac_driver = {
92 	.name = "ac",
93 	.class = ACPI_AC_CLASS,
94 	.ids = ac_device_ids,
95 	.flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
96 	.ops = {
97 		.add = acpi_ac_add,
98 		.remove = acpi_ac_remove,
99 		.notify = acpi_ac_notify,
100 		},
101 	.drv.pm = &acpi_ac_pm,
102 };
103 
104 struct acpi_ac {
105 	struct power_supply *charger;
106 	struct power_supply_desc charger_desc;
107 	struct acpi_device * device;
108 	unsigned long long state;
109 	struct notifier_block battery_nb;
110 };
111 
112 #define to_acpi_ac(x) power_supply_get_drvdata(x)
113 
114 #ifdef CONFIG_ACPI_PROCFS_POWER
115 static const struct file_operations acpi_ac_fops = {
116 	.owner = THIS_MODULE,
117 	.open = acpi_ac_open_fs,
118 	.read = seq_read,
119 	.llseek = seq_lseek,
120 	.release = single_release,
121 };
122 #endif
123 
124 /* --------------------------------------------------------------------------
125                                AC Adapter Management
126    -------------------------------------------------------------------------- */
127 
128 static int acpi_ac_get_state(struct acpi_ac *ac)
129 {
130 	acpi_status status = AE_OK;
131 
132 	if (!ac)
133 		return -EINVAL;
134 
135 	status = acpi_evaluate_integer(ac->device->handle, "_PSR", NULL,
136 				       &ac->state);
137 	if (ACPI_FAILURE(status)) {
138 		ACPI_EXCEPTION((AE_INFO, status,
139 				"Error reading AC Adapter state"));
140 		ac->state = ACPI_AC_STATUS_UNKNOWN;
141 		return -ENODEV;
142 	}
143 
144 	return 0;
145 }
146 
147 /* --------------------------------------------------------------------------
148                             sysfs I/F
149    -------------------------------------------------------------------------- */
150 static int get_ac_property(struct power_supply *psy,
151 			   enum power_supply_property psp,
152 			   union power_supply_propval *val)
153 {
154 	struct acpi_ac *ac = to_acpi_ac(psy);
155 
156 	if (!ac)
157 		return -ENODEV;
158 
159 	if (acpi_ac_get_state(ac))
160 		return -ENODEV;
161 
162 	switch (psp) {
163 	case POWER_SUPPLY_PROP_ONLINE:
164 		val->intval = ac->state;
165 		break;
166 	default:
167 		return -EINVAL;
168 	}
169 	return 0;
170 }
171 
172 static enum power_supply_property ac_props[] = {
173 	POWER_SUPPLY_PROP_ONLINE,
174 };
175 
176 #ifdef CONFIG_ACPI_PROCFS_POWER
177 /* --------------------------------------------------------------------------
178                               FS Interface (/proc)
179    -------------------------------------------------------------------------- */
180 
181 static struct proc_dir_entry *acpi_ac_dir;
182 
183 static int acpi_ac_seq_show(struct seq_file *seq, void *offset)
184 {
185 	struct acpi_ac *ac = seq->private;
186 
187 
188 	if (!ac)
189 		return 0;
190 
191 	if (acpi_ac_get_state(ac)) {
192 		seq_puts(seq, "ERROR: Unable to read AC Adapter state\n");
193 		return 0;
194 	}
195 
196 	seq_puts(seq, "state:                   ");
197 	switch (ac->state) {
198 	case ACPI_AC_STATUS_OFFLINE:
199 		seq_puts(seq, "off-line\n");
200 		break;
201 	case ACPI_AC_STATUS_ONLINE:
202 		seq_puts(seq, "on-line\n");
203 		break;
204 	default:
205 		seq_puts(seq, "unknown\n");
206 		break;
207 	}
208 
209 	return 0;
210 }
211 
212 static int acpi_ac_open_fs(struct inode *inode, struct file *file)
213 {
214 	return single_open(file, acpi_ac_seq_show, PDE_DATA(inode));
215 }
216 
217 static int acpi_ac_add_fs(struct acpi_ac *ac)
218 {
219 	struct proc_dir_entry *entry = NULL;
220 
221 	printk(KERN_WARNING PREFIX "Deprecated procfs I/F for AC is loaded,"
222 			" please retry with CONFIG_ACPI_PROCFS_POWER cleared\n");
223 	if (!acpi_device_dir(ac->device)) {
224 		acpi_device_dir(ac->device) =
225 			proc_mkdir(acpi_device_bid(ac->device), acpi_ac_dir);
226 		if (!acpi_device_dir(ac->device))
227 			return -ENODEV;
228 	}
229 
230 	/* 'state' [R] */
231 	entry = proc_create_data(ACPI_AC_FILE_STATE,
232 				 S_IRUGO, acpi_device_dir(ac->device),
233 				 &acpi_ac_fops, ac);
234 	if (!entry)
235 		return -ENODEV;
236 	return 0;
237 }
238 
239 static int acpi_ac_remove_fs(struct acpi_ac *ac)
240 {
241 
242 	if (acpi_device_dir(ac->device)) {
243 		remove_proc_entry(ACPI_AC_FILE_STATE,
244 				  acpi_device_dir(ac->device));
245 		remove_proc_entry(acpi_device_bid(ac->device), acpi_ac_dir);
246 		acpi_device_dir(ac->device) = NULL;
247 	}
248 
249 	return 0;
250 }
251 #endif
252 
253 /* --------------------------------------------------------------------------
254                                    Driver Model
255    -------------------------------------------------------------------------- */
256 
257 static void acpi_ac_notify(struct acpi_device *device, u32 event)
258 {
259 	struct acpi_ac *ac = acpi_driver_data(device);
260 
261 	if (!ac)
262 		return;
263 
264 	switch (event) {
265 	default:
266 		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
267 				  "Unsupported event [0x%x]\n", event));
268 	case ACPI_AC_NOTIFY_STATUS:
269 	case ACPI_NOTIFY_BUS_CHECK:
270 	case ACPI_NOTIFY_DEVICE_CHECK:
271 		/*
272 		 * A buggy BIOS may notify AC first and then sleep for
273 		 * a specific time before doing actual operations in the
274 		 * EC event handler (_Qxx). This will cause the AC state
275 		 * reported by the ACPI event to be incorrect, so wait for a
276 		 * specific time for the EC event handler to make progress.
277 		 */
278 		if (ac_sleep_before_get_state_ms > 0)
279 			msleep(ac_sleep_before_get_state_ms);
280 
281 		acpi_ac_get_state(ac);
282 		acpi_bus_generate_netlink_event(device->pnp.device_class,
283 						  dev_name(&device->dev), event,
284 						  (u32) ac->state);
285 		acpi_notifier_call_chain(device, event, (u32) ac->state);
286 		kobject_uevent(&ac->charger->dev.kobj, KOBJ_CHANGE);
287 	}
288 
289 	return;
290 }
291 
292 static int acpi_ac_battery_notify(struct notifier_block *nb,
293 				  unsigned long action, void *data)
294 {
295 	struct acpi_ac *ac = container_of(nb, struct acpi_ac, battery_nb);
296 	struct acpi_bus_event *event = (struct acpi_bus_event *)data;
297 
298 	/*
299 	 * On HP Pavilion dv6-6179er AC status notifications aren't triggered
300 	 * when adapter is plugged/unplugged. However, battery status
301 	 * notifcations are triggered when battery starts charging or
302 	 * discharging. Re-reading AC status triggers lost AC notifications,
303 	 * if AC status has changed.
304 	 */
305 	if (strcmp(event->device_class, ACPI_BATTERY_CLASS) == 0 &&
306 	    event->type == ACPI_BATTERY_NOTIFY_STATUS)
307 		acpi_ac_get_state(ac);
308 
309 	return NOTIFY_OK;
310 }
311 
312 static int thinkpad_e530_quirk(const struct dmi_system_id *d)
313 {
314 	ac_sleep_before_get_state_ms = 1000;
315 	return 0;
316 }
317 
318 static const struct dmi_system_id ac_dmi_table[] = {
319 	{
320 	.callback = thinkpad_e530_quirk,
321 	.ident = "thinkpad e530",
322 	.matches = {
323 		DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
324 		DMI_MATCH(DMI_PRODUCT_NAME, "32597CG"),
325 		},
326 	},
327 	{},
328 };
329 
330 static int acpi_ac_add(struct acpi_device *device)
331 {
332 	struct power_supply_config psy_cfg = {};
333 	int result = 0;
334 	struct acpi_ac *ac = NULL;
335 
336 
337 	if (!device)
338 		return -EINVAL;
339 
340 	ac = kzalloc(sizeof(struct acpi_ac), GFP_KERNEL);
341 	if (!ac)
342 		return -ENOMEM;
343 
344 	ac->device = device;
345 	strcpy(acpi_device_name(device), ACPI_AC_DEVICE_NAME);
346 	strcpy(acpi_device_class(device), ACPI_AC_CLASS);
347 	device->driver_data = ac;
348 
349 	result = acpi_ac_get_state(ac);
350 	if (result)
351 		goto end;
352 
353 	psy_cfg.drv_data = ac;
354 
355 	ac->charger_desc.name = acpi_device_bid(device);
356 #ifdef CONFIG_ACPI_PROCFS_POWER
357 	result = acpi_ac_add_fs(ac);
358 	if (result)
359 		goto end;
360 #endif
361 	ac->charger_desc.type = POWER_SUPPLY_TYPE_MAINS;
362 	ac->charger_desc.properties = ac_props;
363 	ac->charger_desc.num_properties = ARRAY_SIZE(ac_props);
364 	ac->charger_desc.get_property = get_ac_property;
365 	ac->charger = power_supply_register(&ac->device->dev,
366 					    &ac->charger_desc, &psy_cfg);
367 	if (IS_ERR(ac->charger)) {
368 		result = PTR_ERR(ac->charger);
369 		goto end;
370 	}
371 
372 	printk(KERN_INFO PREFIX "%s [%s] (%s)\n",
373 	       acpi_device_name(device), acpi_device_bid(device),
374 	       ac->state ? "on-line" : "off-line");
375 
376 	ac->battery_nb.notifier_call = acpi_ac_battery_notify;
377 	register_acpi_notifier(&ac->battery_nb);
378 end:
379 	if (result) {
380 #ifdef CONFIG_ACPI_PROCFS_POWER
381 		acpi_ac_remove_fs(ac);
382 #endif
383 		kfree(ac);
384 	}
385 
386 	dmi_check_system(ac_dmi_table);
387 	return result;
388 }
389 
390 #ifdef CONFIG_PM_SLEEP
391 static int acpi_ac_resume(struct device *dev)
392 {
393 	struct acpi_ac *ac;
394 	unsigned old_state;
395 
396 	if (!dev)
397 		return -EINVAL;
398 
399 	ac = acpi_driver_data(to_acpi_device(dev));
400 	if (!ac)
401 		return -EINVAL;
402 
403 	old_state = ac->state;
404 	if (acpi_ac_get_state(ac))
405 		return 0;
406 	if (old_state != ac->state)
407 		kobject_uevent(&ac->charger->dev.kobj, KOBJ_CHANGE);
408 	return 0;
409 }
410 #else
411 #define acpi_ac_resume NULL
412 #endif
413 
414 static int acpi_ac_remove(struct acpi_device *device)
415 {
416 	struct acpi_ac *ac = NULL;
417 
418 
419 	if (!device || !acpi_driver_data(device))
420 		return -EINVAL;
421 
422 	ac = acpi_driver_data(device);
423 
424 	power_supply_unregister(ac->charger);
425 	unregister_acpi_notifier(&ac->battery_nb);
426 
427 #ifdef CONFIG_ACPI_PROCFS_POWER
428 	acpi_ac_remove_fs(ac);
429 #endif
430 
431 	kfree(ac);
432 
433 	return 0;
434 }
435 
436 static int __init acpi_ac_init(void)
437 {
438 	unsigned int i;
439 	int result;
440 
441 	if (acpi_disabled)
442 		return -ENODEV;
443 
444 	for (i = 0; i < ARRAY_SIZE(acpi_ac_blacklist); i++)
445 		if (acpi_dev_present(acpi_ac_blacklist[i].hid, "1",
446 				     acpi_ac_blacklist[i].hrv)) {
447 			pr_info(PREFIX "AC: found native %s PMIC, not loading\n",
448 				acpi_ac_blacklist[i].hid);
449 			return -ENODEV;
450 		}
451 
452 #ifdef CONFIG_ACPI_PROCFS_POWER
453 	acpi_ac_dir = acpi_lock_ac_dir();
454 	if (!acpi_ac_dir)
455 		return -ENODEV;
456 #endif
457 
458 
459 	result = acpi_bus_register_driver(&acpi_ac_driver);
460 	if (result < 0) {
461 #ifdef CONFIG_ACPI_PROCFS_POWER
462 		acpi_unlock_ac_dir(acpi_ac_dir);
463 #endif
464 		return -ENODEV;
465 	}
466 
467 	return 0;
468 }
469 
470 static void __exit acpi_ac_exit(void)
471 {
472 	acpi_bus_unregister_driver(&acpi_ac_driver);
473 #ifdef CONFIG_ACPI_PROCFS_POWER
474 	acpi_unlock_ac_dir(acpi_ac_dir);
475 #endif
476 }
477 module_init(acpi_ac_init);
478 module_exit(acpi_ac_exit);
479