]> git.openfabrics.org - ~shefty/rdma-dev.git/blob - drivers/pnp/pnpacpi/core.c
pnpacpi: fix incorrect TEST_ALPHA() test
[~shefty/rdma-dev.git] / drivers / pnp / pnpacpi / core.c
1 /*
2  * pnpacpi -- PnP ACPI driver
3  *
4  * Copyright (c) 2004 Matthieu Castet <castet.matthieu@free.fr>
5  * Copyright (c) 2004 Li Shaohua <shaohua.li@intel.com>
6  *
7  * This program is free software; you can redistribute it and/or modify it
8  * under the terms of the GNU General Public License as published by the
9  * Free Software Foundation; either version 2, or (at your option) any
10  * later version.
11  *
12  * This program is distributed in the hope that it will be useful, but
13  * WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
20  */
21
22 #include <linux/export.h>
23 #include <linux/acpi.h>
24 #include <linux/pnp.h>
25 #include <linux/slab.h>
26 #include <linux/mod_devicetable.h>
27 #include <acpi/acpi_bus.h>
28
29 #include "../base.h"
30 #include "pnpacpi.h"
31
32 static int num;
33
34 /* We need only to blacklist devices that have already an acpi driver that
35  * can't use pnp layer. We don't need to blacklist device that are directly
36  * used by the kernel (PCI root, ...), as it is harmless and there were
37  * already present in pnpbios. But there is an exception for devices that
38  * have irqs (PIC, Timer) because we call acpi_register_gsi.
39  * Finally, only devices that have a CRS method need to be in this list.
40  */
41 static struct acpi_device_id excluded_id_list[] __initdata = {
42         {"PNP0C09", 0},         /* EC */
43         {"PNP0C0F", 0},         /* Link device */
44         {"PNP0000", 0},         /* PIC */
45         {"PNP0100", 0},         /* Timer */
46         {"", 0},
47 };
48
49 static inline int __init is_exclusive_device(struct acpi_device *dev)
50 {
51         return (!acpi_match_device_ids(dev, excluded_id_list));
52 }
53
54 /*
55  * Compatible Device IDs
56  */
57 #define TEST_HEX(c) \
58         if (!(('0' <= (c) && (c) <= '9') || ('A' <= (c) && (c) <= 'F'))) \
59                 return 0
60 #define TEST_ALPHA(c) \
61         if (!('A' <= (c) && (c) <= 'Z')) \
62                 return 0
63 static int __init ispnpidacpi(const char *id)
64 {
65         TEST_ALPHA(id[0]);
66         TEST_ALPHA(id[1]);
67         TEST_ALPHA(id[2]);
68         TEST_HEX(id[3]);
69         TEST_HEX(id[4]);
70         TEST_HEX(id[5]);
71         TEST_HEX(id[6]);
72         if (id[7] != '\0')
73                 return 0;
74         return 1;
75 }
76
77 static int pnpacpi_get_resources(struct pnp_dev *dev)
78 {
79         pnp_dbg(&dev->dev, "get resources\n");
80         return pnpacpi_parse_allocated_resource(dev);
81 }
82
83 static int pnpacpi_set_resources(struct pnp_dev *dev)
84 {
85         struct acpi_device *acpi_dev;
86         acpi_handle handle;
87         struct acpi_buffer buffer;
88         int ret;
89
90         pnp_dbg(&dev->dev, "set resources\n");
91
92         handle = DEVICE_ACPI_HANDLE(&dev->dev);
93         if (!handle || ACPI_FAILURE(acpi_bus_get_device(handle, &acpi_dev))) {
94                 dev_dbg(&dev->dev, "ACPI device not found in %s!\n", __func__);
95                 return -ENODEV;
96         }
97
98         if (WARN_ON_ONCE(acpi_dev != dev->data))
99                 dev->data = acpi_dev;
100
101         ret = pnpacpi_build_resource_template(dev, &buffer);
102         if (ret)
103                 return ret;
104         ret = pnpacpi_encode_resources(dev, &buffer);
105         if (ret) {
106                 kfree(buffer.pointer);
107                 return ret;
108         }
109         if (ACPI_FAILURE(acpi_set_current_resources(handle, &buffer)))
110                 ret = -EINVAL;
111         else if (acpi_bus_power_manageable(handle))
112                 ret = acpi_bus_set_power(handle, ACPI_STATE_D0);
113         kfree(buffer.pointer);
114         return ret;
115 }
116
117 static int pnpacpi_disable_resources(struct pnp_dev *dev)
118 {
119         struct acpi_device *acpi_dev;
120         acpi_handle handle;
121         int ret;
122
123         dev_dbg(&dev->dev, "disable resources\n");
124
125         handle = DEVICE_ACPI_HANDLE(&dev->dev);
126         if (!handle || ACPI_FAILURE(acpi_bus_get_device(handle, &acpi_dev))) {
127                 dev_dbg(&dev->dev, "ACPI device not found in %s!\n", __func__);
128                 return 0;
129         }
130
131         /* acpi_unregister_gsi(pnp_irq(dev, 0)); */
132         ret = 0;
133         if (acpi_bus_power_manageable(handle))
134                 acpi_bus_set_power(handle, ACPI_STATE_D3);
135                 /* continue even if acpi_bus_set_power() fails */
136         if (ACPI_FAILURE(acpi_evaluate_object(handle, "_DIS", NULL, NULL)))
137                 ret = -ENODEV;
138         return ret;
139 }
140
141 #ifdef CONFIG_ACPI_SLEEP
142 static bool pnpacpi_can_wakeup(struct pnp_dev *dev)
143 {
144         struct acpi_device *acpi_dev;
145         acpi_handle handle;
146
147         handle = DEVICE_ACPI_HANDLE(&dev->dev);
148         if (!handle || ACPI_FAILURE(acpi_bus_get_device(handle, &acpi_dev))) {
149                 dev_dbg(&dev->dev, "ACPI device not found in %s!\n", __func__);
150                 return false;
151         }
152
153         return acpi_bus_can_wakeup(handle);
154 }
155
156 static int pnpacpi_suspend(struct pnp_dev *dev, pm_message_t state)
157 {
158         struct acpi_device *acpi_dev;
159         acpi_handle handle;
160         int error = 0;
161
162         handle = DEVICE_ACPI_HANDLE(&dev->dev);
163         if (!handle || ACPI_FAILURE(acpi_bus_get_device(handle, &acpi_dev))) {
164                 dev_dbg(&dev->dev, "ACPI device not found in %s!\n", __func__);
165                 return 0;
166         }
167
168         if (device_can_wakeup(&dev->dev)) {
169                 error = acpi_pm_device_sleep_wake(&dev->dev,
170                                 device_may_wakeup(&dev->dev));
171                 if (error)
172                         return error;
173         }
174
175         if (acpi_bus_power_manageable(handle)) {
176                 int power_state = acpi_pm_device_sleep_state(&dev->dev, NULL,
177                                                              ACPI_STATE_D3);
178                 if (power_state < 0)
179                         power_state = (state.event == PM_EVENT_ON) ?
180                                         ACPI_STATE_D0 : ACPI_STATE_D3;
181
182                 /*
183                  * acpi_bus_set_power() often fails (keyboard port can't be
184                  * powered-down?), and in any case, our return value is ignored
185                  * by pnp_bus_suspend().  Hence we don't revert the wakeup
186                  * setting if the set_power fails.
187                  */
188                 error = acpi_bus_set_power(handle, power_state);
189         }
190
191         return error;
192 }
193
194 static int pnpacpi_resume(struct pnp_dev *dev)
195 {
196         struct acpi_device *acpi_dev;
197         acpi_handle handle = DEVICE_ACPI_HANDLE(&dev->dev);
198         int error = 0;
199
200         if (!handle || ACPI_FAILURE(acpi_bus_get_device(handle, &acpi_dev))) {
201                 dev_dbg(&dev->dev, "ACPI device not found in %s!\n", __func__);
202                 return -ENODEV;
203         }
204
205         if (device_may_wakeup(&dev->dev))
206                 acpi_pm_device_sleep_wake(&dev->dev, false);
207
208         if (acpi_bus_power_manageable(handle))
209                 error = acpi_bus_set_power(handle, ACPI_STATE_D0);
210
211         return error;
212 }
213 #endif
214
215 struct pnp_protocol pnpacpi_protocol = {
216         .name    = "Plug and Play ACPI",
217         .get     = pnpacpi_get_resources,
218         .set     = pnpacpi_set_resources,
219         .disable = pnpacpi_disable_resources,
220 #ifdef CONFIG_ACPI_SLEEP
221         .can_wakeup = pnpacpi_can_wakeup,
222         .suspend = pnpacpi_suspend,
223         .resume = pnpacpi_resume,
224 #endif
225 };
226 EXPORT_SYMBOL(pnpacpi_protocol);
227
228 static char *__init pnpacpi_get_id(struct acpi_device *device)
229 {
230         struct acpi_hardware_id *id;
231
232         list_for_each_entry(id, &device->pnp.ids, list) {
233                 if (ispnpidacpi(id->id))
234                         return id->id;
235         }
236
237         return NULL;
238 }
239
240 static int __init pnpacpi_add_device(struct acpi_device *device)
241 {
242         acpi_handle temp = NULL;
243         acpi_status status;
244         struct pnp_dev *dev;
245         char *pnpid;
246         struct acpi_hardware_id *id;
247
248         /*
249          * If a PnPacpi device is not present , the device
250          * driver should not be loaded.
251          */
252         status = acpi_get_handle(device->handle, "_CRS", &temp);
253         if (ACPI_FAILURE(status))
254                 return 0;
255
256         pnpid = pnpacpi_get_id(device);
257         if (!pnpid)
258                 return 0;
259
260         if (is_exclusive_device(device) || !device->status.present)
261                 return 0;
262
263         dev = pnp_alloc_dev(&pnpacpi_protocol, num, pnpid);
264         if (!dev)
265                 return -ENOMEM;
266
267         dev->data = device;
268         /* .enabled means the device can decode the resources */
269         dev->active = device->status.enabled;
270         status = acpi_get_handle(device->handle, "_SRS", &temp);
271         if (ACPI_SUCCESS(status))
272                 dev->capabilities |= PNP_CONFIGURABLE;
273         dev->capabilities |= PNP_READ;
274         if (device->flags.dynamic_status && (dev->capabilities & PNP_CONFIGURABLE))
275                 dev->capabilities |= PNP_WRITE;
276         if (device->flags.removable)
277                 dev->capabilities |= PNP_REMOVABLE;
278         status = acpi_get_handle(device->handle, "_DIS", &temp);
279         if (ACPI_SUCCESS(status))
280                 dev->capabilities |= PNP_DISABLE;
281
282         if (strlen(acpi_device_name(device)))
283                 strncpy(dev->name, acpi_device_name(device), sizeof(dev->name));
284         else
285                 strncpy(dev->name, acpi_device_bid(device), sizeof(dev->name));
286
287         if (dev->active)
288                 pnpacpi_parse_allocated_resource(dev);
289
290         if (dev->capabilities & PNP_CONFIGURABLE)
291                 pnpacpi_parse_resource_option_data(dev);
292
293         list_for_each_entry(id, &device->pnp.ids, list) {
294                 if (!strcmp(id->id, pnpid))
295                         continue;
296                 if (!ispnpidacpi(id->id))
297                         continue;
298                 pnp_add_id(dev, id->id);
299         }
300
301         /* clear out the damaged flags */
302         if (!dev->active)
303                 pnp_init_resources(dev);
304         pnp_add_device(dev);
305         num++;
306
307         return AE_OK;
308 }
309
310 static acpi_status __init pnpacpi_add_device_handler(acpi_handle handle,
311                                                      u32 lvl, void *context,
312                                                      void **rv)
313 {
314         struct acpi_device *device;
315
316         if (!acpi_bus_get_device(handle, &device))
317                 pnpacpi_add_device(device);
318         else
319                 return AE_CTRL_DEPTH;
320         return AE_OK;
321 }
322
323 static int __init acpi_pnp_match(struct device *dev, void *_pnp)
324 {
325         struct acpi_device *acpi = to_acpi_device(dev);
326         struct pnp_dev *pnp = _pnp;
327
328         /* true means it matched */
329         return !acpi->physical_node_count
330             && compare_pnp_id(pnp->id, acpi_device_hid(acpi));
331 }
332
333 static int __init acpi_pnp_find_device(struct device *dev, acpi_handle * handle)
334 {
335         struct device *adev;
336         struct acpi_device *acpi;
337
338         adev = bus_find_device(&acpi_bus_type, NULL,
339                                to_pnp_dev(dev), acpi_pnp_match);
340         if (!adev)
341                 return -ENODEV;
342
343         acpi = to_acpi_device(adev);
344         *handle = acpi->handle;
345         put_device(adev);
346         return 0;
347 }
348
349 /* complete initialization of a PNPACPI device includes having
350  * pnpdev->dev.archdata.acpi_handle point to its ACPI sibling.
351  */
352 static struct acpi_bus_type __initdata acpi_pnp_bus = {
353         .bus         = &pnp_bus_type,
354         .find_device = acpi_pnp_find_device,
355 };
356
357 int pnpacpi_disabled __initdata;
358 static int __init pnpacpi_init(void)
359 {
360         if (acpi_disabled || pnpacpi_disabled) {
361                 printk(KERN_INFO "pnp: PnP ACPI: disabled\n");
362                 return 0;
363         }
364         printk(KERN_INFO "pnp: PnP ACPI init\n");
365         pnp_register_protocol(&pnpacpi_protocol);
366         register_acpi_bus_type(&acpi_pnp_bus);
367         acpi_get_devices(NULL, pnpacpi_add_device_handler, NULL, NULL);
368         printk(KERN_INFO "pnp: PnP ACPI: found %d devices\n", num);
369         unregister_acpi_bus_type(&acpi_pnp_bus);
370         pnp_platform_devices = 1;
371         return 0;
372 }
373
374 fs_initcall(pnpacpi_init);
375
376 static int __init pnpacpi_setup(char *str)
377 {
378         if (str == NULL)
379                 return 1;
380         if (!strncmp(str, "off", 3))
381                 pnpacpi_disabled = 1;
382         return 1;
383 }
384
385 __setup("pnpacpi=", pnpacpi_setup);