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