blob: 9b227d4dc9c9bbd43b7649b66b7ee311371f7eaf [file] [log] [blame]
David Shaohua Li4e10d122005-03-18 18:45:35 -05001/*
2 * Link physical devices with ACPI devices support
3 *
4 * Copyright (c) 2005 David Shaohua Li <shaohua.li@intel.com>
5 * Copyright (c) 2005 Intel Corp.
6 *
7 * This file is released under the GPLv2.
8 */
9#include <linux/init.h>
10#include <linux/list.h>
11#include <linux/device.h>
12#include <linux/rwsem.h>
13#include <linux/acpi.h>
14
15#define ACPI_GLUE_DEBUG 0
16#if ACPI_GLUE_DEBUG
17#define DBG(x...) printk(PREFIX x)
18#else
Dave Jones4ebf83c2007-07-09 11:33:14 -070019#define DBG(x...) do { } while(0)
David Shaohua Li4e10d122005-03-18 18:45:35 -050020#endif
21static LIST_HEAD(bus_type_list);
22static DECLARE_RWSEM(bus_type_sem);
23
24int register_acpi_bus_type(struct acpi_bus_type *type)
25{
26 if (acpi_disabled)
27 return -ENODEV;
28 if (type && type->bus && type->find_device) {
29 down_write(&bus_type_sem);
30 list_add_tail(&type->list, &bus_type_list);
31 up_write(&bus_type_sem);
Len Brown4be44fc2005-08-05 00:44:28 -040032 printk(KERN_INFO PREFIX "bus type %s registered\n",
33 type->bus->name);
David Shaohua Li4e10d122005-03-18 18:45:35 -050034 return 0;
35 }
36 return -ENODEV;
37}
38
David Shaohua Li4e10d122005-03-18 18:45:35 -050039int unregister_acpi_bus_type(struct acpi_bus_type *type)
40{
41 if (acpi_disabled)
42 return 0;
43 if (type) {
44 down_write(&bus_type_sem);
45 list_del_init(&type->list);
46 up_write(&bus_type_sem);
Len Brown4be44fc2005-08-05 00:44:28 -040047 printk(KERN_INFO PREFIX "ACPI bus type %s unregistered\n",
48 type->bus->name);
David Shaohua Li4e10d122005-03-18 18:45:35 -050049 return 0;
50 }
51 return -ENODEV;
52}
53
David Shaohua Li4e10d122005-03-18 18:45:35 -050054static struct acpi_bus_type *acpi_get_bus_type(struct bus_type *type)
55{
56 struct acpi_bus_type *tmp, *ret = NULL;
57
58 down_read(&bus_type_sem);
59 list_for_each_entry(tmp, &bus_type_list, list) {
60 if (tmp->bus == type) {
61 ret = tmp;
62 break;
63 }
64 }
65 up_read(&bus_type_sem);
66 return ret;
67}
68
69static int acpi_find_bridge_device(struct device *dev, acpi_handle * handle)
70{
71 struct acpi_bus_type *tmp;
72 int ret = -ENODEV;
73
74 down_read(&bus_type_sem);
75 list_for_each_entry(tmp, &bus_type_list, list) {
76 if (tmp->find_bridge && !tmp->find_bridge(dev, handle)) {
77 ret = 0;
78 break;
79 }
80 }
81 up_read(&bus_type_sem);
82 return ret;
83}
84
David Shaohua Li4e10d122005-03-18 18:45:35 -050085/* Get device's handler per its address under its parent */
86struct acpi_find_child {
87 acpi_handle handle;
88 acpi_integer address;
89};
90
91static acpi_status
92do_acpi_find_child(acpi_handle handle, u32 lvl, void *context, void **rv)
93{
94 acpi_status status;
95 struct acpi_device_info *info;
96 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
Jan Engelhardt50dd0962006-10-01 00:28:50 +020097 struct acpi_find_child *find = context;
David Shaohua Li4e10d122005-03-18 18:45:35 -050098
99 status = acpi_get_object_info(handle, &buffer);
100 if (ACPI_SUCCESS(status)) {
101 info = buffer.pointer;
102 if (info->address == find->address)
103 find->handle = handle;
Len Brown02438d82006-06-30 03:19:10 -0400104 kfree(buffer.pointer);
David Shaohua Li4e10d122005-03-18 18:45:35 -0500105 }
106 return AE_OK;
107}
108
109acpi_handle acpi_get_child(acpi_handle parent, acpi_integer address)
110{
111 struct acpi_find_child find = { NULL, address };
112
113 if (!parent)
114 return NULL;
115 acpi_walk_namespace(ACPI_TYPE_DEVICE, parent,
116 1, do_acpi_find_child, &find, NULL);
117 return find.handle;
118}
119
120EXPORT_SYMBOL(acpi_get_child);
121
122/* Link ACPI devices with physical devices */
123static void acpi_glue_data_handler(acpi_handle handle,
124 u32 function, void *context)
125{
126 /* we provide an empty handler */
127}
128
129/* Note: a success call will increase reference count by one */
130struct device *acpi_get_physical_device(acpi_handle handle)
131{
132 acpi_status status;
133 struct device *dev;
134
135 status = acpi_get_data(handle, acpi_glue_data_handler, (void **)&dev);
136 if (ACPI_SUCCESS(status))
137 return get_device(dev);
138 return NULL;
139}
140
141EXPORT_SYMBOL(acpi_get_physical_device);
142
143static int acpi_bind_one(struct device *dev, acpi_handle handle)
144{
David Brownell10716952008-02-22 21:54:24 -0800145 struct acpi_device *acpi_dev;
David Shaohua Li4e10d122005-03-18 18:45:35 -0500146 acpi_status status;
147
Benjamin Herrenschmidt465ae642006-11-11 17:18:42 +1100148 if (dev->archdata.acpi_handle) {
David Shaohua Li4e10d122005-03-18 18:45:35 -0500149 printk(KERN_WARNING PREFIX
Benjamin Herrenschmidt465ae642006-11-11 17:18:42 +1100150 "Drivers changed 'acpi_handle' for %s\n", dev->bus_id);
David Shaohua Li4e10d122005-03-18 18:45:35 -0500151 return -EINVAL;
152 }
153 get_device(dev);
154 status = acpi_attach_data(handle, acpi_glue_data_handler, dev);
155 if (ACPI_FAILURE(status)) {
156 put_device(dev);
157 return -EINVAL;
158 }
Benjamin Herrenschmidt465ae642006-11-11 17:18:42 +1100159 dev->archdata.acpi_handle = handle;
David Shaohua Li4e10d122005-03-18 18:45:35 -0500160
David Brownell10716952008-02-22 21:54:24 -0800161 status = acpi_bus_get_device(handle, &acpi_dev);
162 if (!ACPI_FAILURE(status)) {
163 int ret;
164
165 ret = sysfs_create_link(&dev->kobj, &acpi_dev->dev.kobj,
166 "firmware_node");
167 ret = sysfs_create_link(&acpi_dev->dev.kobj, &dev->kobj,
168 "physical_node");
169 }
170
David Shaohua Li4e10d122005-03-18 18:45:35 -0500171 return 0;
172}
173
174static int acpi_unbind_one(struct device *dev)
175{
Benjamin Herrenschmidt465ae642006-11-11 17:18:42 +1100176 if (!dev->archdata.acpi_handle)
David Shaohua Li4e10d122005-03-18 18:45:35 -0500177 return 0;
Benjamin Herrenschmidt465ae642006-11-11 17:18:42 +1100178 if (dev == acpi_get_physical_device(dev->archdata.acpi_handle)) {
David Brownell10716952008-02-22 21:54:24 -0800179 struct acpi_device *acpi_dev;
180
David Shaohua Li4e10d122005-03-18 18:45:35 -0500181 /* acpi_get_physical_device increase refcnt by one */
182 put_device(dev);
David Brownell10716952008-02-22 21:54:24 -0800183
184 if (!acpi_bus_get_device(dev->archdata.acpi_handle,
185 &acpi_dev)) {
186 sysfs_remove_link(&dev->kobj, "firmware_node");
187 sysfs_remove_link(&acpi_dev->dev.kobj, "physical_node");
188 }
189
Benjamin Herrenschmidt465ae642006-11-11 17:18:42 +1100190 acpi_detach_data(dev->archdata.acpi_handle,
191 acpi_glue_data_handler);
192 dev->archdata.acpi_handle = NULL;
David Shaohua Li4e10d122005-03-18 18:45:35 -0500193 /* acpi_bind_one increase refcnt by one */
194 put_device(dev);
195 } else {
196 printk(KERN_ERR PREFIX
Benjamin Herrenschmidt465ae642006-11-11 17:18:42 +1100197 "Oops, 'acpi_handle' corrupt for %s\n", dev->bus_id);
David Shaohua Li4e10d122005-03-18 18:45:35 -0500198 }
199 return 0;
200}
201
202static int acpi_platform_notify(struct device *dev)
203{
204 struct acpi_bus_type *type;
205 acpi_handle handle;
206 int ret = -EINVAL;
207
208 if (!dev->bus || !dev->parent) {
209 /* bridge devices genernally haven't bus or parent */
210 ret = acpi_find_bridge_device(dev, &handle);
211 goto end;
212 }
213 type = acpi_get_bus_type(dev->bus);
214 if (!type) {
David Shaohua Lief7b06c2005-04-18 22:59:23 -0400215 DBG("No ACPI bus support for %s\n", dev->bus_id);
David Shaohua Li4e10d122005-03-18 18:45:35 -0500216 ret = -EINVAL;
217 goto end;
218 }
219 if ((ret = type->find_device(dev, &handle)) != 0)
David Shaohua Lief7b06c2005-04-18 22:59:23 -0400220 DBG("Can't get handler for %s\n", dev->bus_id);
David Shaohua Li4e10d122005-03-18 18:45:35 -0500221 end:
222 if (!ret)
223 acpi_bind_one(dev, handle);
224
225#if ACPI_GLUE_DEBUG
226 if (!ret) {
227 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
228
Benjamin Herrenschmidt465ae642006-11-11 17:18:42 +1100229 acpi_get_name(dev->archdata.acpi_handle,
230 ACPI_FULL_PATHNAME, &buffer);
David Shaohua Li4e10d122005-03-18 18:45:35 -0500231 DBG("Device %s -> %s\n", dev->bus_id, (char *)buffer.pointer);
Len Brown02438d82006-06-30 03:19:10 -0400232 kfree(buffer.pointer);
David Shaohua Li4e10d122005-03-18 18:45:35 -0500233 } else
234 DBG("Device %s -> No ACPI support\n", dev->bus_id);
235#endif
236
237 return ret;
238}
239
240static int acpi_platform_notify_remove(struct device *dev)
241{
242 acpi_unbind_one(dev);
243 return 0;
244}
245
246static int __init init_acpi_device_notify(void)
247{
248 if (acpi_disabled)
249 return 0;
250 if (platform_notify || platform_notify_remove) {
251 printk(KERN_ERR PREFIX "Can't use platform_notify\n");
252 return 0;
253 }
254 platform_notify = acpi_platform_notify;
255 platform_notify_remove = acpi_platform_notify_remove;
256 return 0;
257}
258
259arch_initcall(init_acpi_device_notify);
David Brownella74388e2007-02-05 16:09:11 -0800260
261
262#if defined(CONFIG_RTC_DRV_CMOS) || defined(CONFIG_RTC_DRV_CMOS_MODULE)
263
David Brownellf5f72b42007-05-08 00:34:02 -0700264#ifdef CONFIG_PM
265static u32 rtc_handler(void *context)
266{
267 acpi_clear_event(ACPI_EVENT_RTC);
268 acpi_disable_event(ACPI_EVENT_RTC, 0);
269 return ACPI_INTERRUPT_HANDLED;
270}
271
272static inline void rtc_wake_setup(void)
273{
274 acpi_install_fixed_event_handler(ACPI_EVENT_RTC, rtc_handler, NULL);
Zhao Yakuie1094bf2008-05-14 11:32:59 +0800275 /*
276 * After the RTC handler is installed, the Fixed_RTC event should
277 * be disabled. Only when the RTC alarm is set will it be enabled.
278 */
279 acpi_clear_event(ACPI_EVENT_RTC);
280 acpi_disable_event(ACPI_EVENT_RTC, 0);
David Brownellf5f72b42007-05-08 00:34:02 -0700281}
282
283static void rtc_wake_on(struct device *dev)
284{
285 acpi_clear_event(ACPI_EVENT_RTC);
286 acpi_enable_event(ACPI_EVENT_RTC, 0);
287}
288
289static void rtc_wake_off(struct device *dev)
290{
291 acpi_disable_event(ACPI_EVENT_RTC, 0);
292}
293#else
294#define rtc_wake_setup() do{}while(0)
295#define rtc_wake_on NULL
296#define rtc_wake_off NULL
297#endif
298
David Brownella74388e2007-02-05 16:09:11 -0800299/* Every ACPI platform has a mc146818 compatible "cmos rtc". Here we find
300 * its device node and pass extra config data. This helps its driver use
301 * capabilities that the now-obsolete mc146818 didn't have, and informs it
302 * that this board's RTC is wakeup-capable (per ACPI spec).
303 */
304#include <linux/mc146818rtc.h>
305
306static struct cmos_rtc_board_info rtc_info;
307
308
David Brownella74388e2007-02-05 16:09:11 -0800309/* PNP devices are registered in a subsys_initcall();
310 * ACPI specifies the PNP IDs to use.
311 */
312#include <linux/pnp.h>
313
314static int __init pnp_match(struct device *dev, void *data)
315{
316 static const char *ids[] = { "PNP0b00", "PNP0b01", "PNP0b02", };
317 struct pnp_dev *pnp = to_pnp_dev(dev);
318 int i;
319
320 for (i = 0; i < ARRAY_SIZE(ids); i++) {
321 if (compare_pnp_id(pnp->id, ids[i]) != 0)
322 return 1;
323 }
324 return 0;
325}
326
327static struct device *__init get_rtc_dev(void)
328{
329 return bus_find_device(&pnp_bus_type, NULL, NULL, pnp_match);
330}
331
David Brownella74388e2007-02-05 16:09:11 -0800332static int __init acpi_rtc_init(void)
333{
334 struct device *dev = get_rtc_dev();
335
Vegard Nossum4389ed22008-06-20 15:39:09 +0200336 if (acpi_disabled)
337 return 0;
338
David Brownella74388e2007-02-05 16:09:11 -0800339 if (dev) {
David Brownellf5f72b42007-05-08 00:34:02 -0700340 rtc_wake_setup();
341 rtc_info.wake_on = rtc_wake_on;
342 rtc_info.wake_off = rtc_wake_off;
343
David Brownell19bfe372007-05-08 00:34:03 -0700344 /* workaround bug in some ACPI tables */
345 if (acpi_gbl_FADT.month_alarm && !acpi_gbl_FADT.day_alarm) {
346 DBG("bogus FADT month_alarm\n");
347 acpi_gbl_FADT.month_alarm = 0;
348 }
349
David Brownella74388e2007-02-05 16:09:11 -0800350 rtc_info.rtc_day_alarm = acpi_gbl_FADT.day_alarm;
351 rtc_info.rtc_mon_alarm = acpi_gbl_FADT.month_alarm;
352 rtc_info.rtc_century = acpi_gbl_FADT.century;
353
David Brownellf5f72b42007-05-08 00:34:02 -0700354 /* NOTE: S4_RTC_WAKE is NOT currently useful to Linux */
355 if (acpi_gbl_FADT.flags & ACPI_FADT_S4_RTC_WAKE)
David Brownell19bfe372007-05-08 00:34:03 -0700356 printk(PREFIX "RTC can wake from S4\n");
357
David Brownella74388e2007-02-05 16:09:11 -0800358
359 dev->platform_data = &rtc_info;
360
361 /* RTC always wakes from S1/S2/S3, and often S4/STD */
362 device_init_wakeup(dev, 1);
363
364 put_device(dev);
365 } else
David Brownell19bfe372007-05-08 00:34:03 -0700366 DBG("RTC unavailable?\n");
David Brownella74388e2007-02-05 16:09:11 -0800367 return 0;
368}
369/* do this between RTC subsys_initcall() and rtc_cmos driver_initcall() */
370fs_initcall(acpi_rtc_init);
371
372#endif