Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * resource.c - Contains functions for registering and analyzing resource information | |
3 | * | |
c1017a4c | 4 | * based on isapnp.c resource management (c) Jaroslav Kysela <perex@perex.cz> |
1da177e4 | 5 | * Copyright 2003 Adam Belay <ambx1@neo.rr.com> |
1da177e4 LT |
6 | */ |
7 | ||
1da177e4 LT |
8 | #include <linux/module.h> |
9 | #include <linux/errno.h> | |
10 | #include <linux/interrupt.h> | |
11 | #include <linux/kernel.h> | |
12 | #include <asm/io.h> | |
13 | #include <asm/dma.h> | |
14 | #include <asm/irq.h> | |
15 | #include <linux/pci.h> | |
16 | #include <linux/ioport.h> | |
17 | #include <linux/init.h> | |
18 | ||
19 | #include <linux/pnp.h> | |
20 | #include "base.h" | |
21 | ||
07d4e9af BH |
22 | static int pnp_reserve_irq[16] = {[0 ... 15] = -1 }; /* reserve (don't use) some IRQ */ |
23 | static int pnp_reserve_dma[8] = {[0 ... 7] = -1 }; /* reserve (don't use) some DMA */ | |
24 | static int pnp_reserve_io[16] = {[0 ... 15] = -1 }; /* reserve (don't use) some I/O region */ | |
25 | static int pnp_reserve_mem[16] = {[0 ... 15] = -1 }; /* reserve (don't use) some memory region */ | |
1da177e4 LT |
26 | |
27 | /* | |
28 | * option registration | |
29 | */ | |
30 | ||
9dd78466 | 31 | static struct pnp_option *pnp_build_option(int priority) |
1da177e4 LT |
32 | { |
33 | struct pnp_option *option = pnp_alloc(sizeof(struct pnp_option)); | |
34 | ||
1da177e4 LT |
35 | if (!option) |
36 | return NULL; | |
37 | ||
38 | option->priority = priority & 0xff; | |
39 | /* make sure the priority is valid */ | |
40 | if (option->priority > PNP_RES_PRIORITY_FUNCTIONAL) | |
41 | option->priority = PNP_RES_PRIORITY_INVALID; | |
42 | ||
43 | return option; | |
44 | } | |
45 | ||
9dd78466 | 46 | struct pnp_option *pnp_register_independent_option(struct pnp_dev *dev) |
1da177e4 LT |
47 | { |
48 | struct pnp_option *option; | |
07d4e9af | 49 | |
1da177e4 LT |
50 | option = pnp_build_option(PNP_RES_PRIORITY_PREFERRED); |
51 | ||
52 | /* this should never happen but if it does we'll try to continue */ | |
53 | if (dev->independent) | |
a05d0781 | 54 | dev_err(&dev->dev, "independent resource already registered\n"); |
1da177e4 | 55 | dev->independent = option; |
c1caf06c BH |
56 | |
57 | dev_dbg(&dev->dev, "new independent option\n"); | |
1da177e4 LT |
58 | return option; |
59 | } | |
60 | ||
9dd78466 BH |
61 | struct pnp_option *pnp_register_dependent_option(struct pnp_dev *dev, |
62 | int priority) | |
1da177e4 LT |
63 | { |
64 | struct pnp_option *option; | |
07d4e9af | 65 | |
1da177e4 LT |
66 | option = pnp_build_option(priority); |
67 | ||
68 | if (dev->dependent) { | |
69 | struct pnp_option *parent = dev->dependent; | |
70 | while (parent->next) | |
71 | parent = parent->next; | |
72 | parent->next = option; | |
73 | } else | |
74 | dev->dependent = option; | |
c1caf06c BH |
75 | |
76 | dev_dbg(&dev->dev, "new dependent option (priority %#x)\n", priority); | |
1da177e4 LT |
77 | return option; |
78 | } | |
79 | ||
c1caf06c BH |
80 | int pnp_register_irq_resource(struct pnp_dev *dev, struct pnp_option *option, |
81 | struct pnp_irq *data) | |
1da177e4 LT |
82 | { |
83 | struct pnp_irq *ptr; | |
c1caf06c BH |
84 | #ifdef DEBUG |
85 | char buf[PNP_IRQ_NR]; /* hex-encoded, so this is overkill but safe */ | |
86 | #endif | |
07d4e9af | 87 | |
1da177e4 LT |
88 | ptr = option->irq; |
89 | while (ptr && ptr->next) | |
90 | ptr = ptr->next; | |
91 | if (ptr) | |
92 | ptr->next = data; | |
93 | else | |
94 | option->irq = data; | |
95 | ||
96 | #ifdef CONFIG_PCI | |
97 | { | |
98 | int i; | |
99 | ||
100 | for (i = 0; i < 16; i++) | |
101 | if (test_bit(i, data->map)) | |
c9c3e457 | 102 | pcibios_penalize_isa_irq(i, 0); |
1da177e4 LT |
103 | } |
104 | #endif | |
c1caf06c BH |
105 | |
106 | #ifdef DEBUG | |
107 | bitmap_scnprintf(buf, sizeof(buf), data->map, PNP_IRQ_NR); | |
108 | dev_dbg(&dev->dev, " irq bitmask %s flags %#x\n", buf, | |
109 | data->flags); | |
110 | #endif | |
1da177e4 LT |
111 | return 0; |
112 | } | |
113 | ||
c1caf06c BH |
114 | int pnp_register_dma_resource(struct pnp_dev *dev, struct pnp_option *option, |
115 | struct pnp_dma *data) | |
1da177e4 LT |
116 | { |
117 | struct pnp_dma *ptr; | |
07d4e9af | 118 | |
1da177e4 LT |
119 | ptr = option->dma; |
120 | while (ptr && ptr->next) | |
121 | ptr = ptr->next; | |
122 | if (ptr) | |
123 | ptr->next = data; | |
124 | else | |
125 | option->dma = data; | |
126 | ||
c1caf06c BH |
127 | dev_dbg(&dev->dev, " dma bitmask %#x flags %#x\n", data->map, |
128 | data->flags); | |
1da177e4 LT |
129 | return 0; |
130 | } | |
131 | ||
c1caf06c BH |
132 | int pnp_register_port_resource(struct pnp_dev *dev, struct pnp_option *option, |
133 | struct pnp_port *data) | |
1da177e4 LT |
134 | { |
135 | struct pnp_port *ptr; | |
07d4e9af | 136 | |
1da177e4 LT |
137 | ptr = option->port; |
138 | while (ptr && ptr->next) | |
139 | ptr = ptr->next; | |
140 | if (ptr) | |
141 | ptr->next = data; | |
142 | else | |
143 | option->port = data; | |
144 | ||
c1caf06c BH |
145 | dev_dbg(&dev->dev, " io " |
146 | "min %#x max %#x align %d size %d flags %#x\n", | |
147 | data->min, data->max, data->align, data->size, data->flags); | |
1da177e4 LT |
148 | return 0; |
149 | } | |
150 | ||
c1caf06c BH |
151 | int pnp_register_mem_resource(struct pnp_dev *dev, struct pnp_option *option, |
152 | struct pnp_mem *data) | |
1da177e4 LT |
153 | { |
154 | struct pnp_mem *ptr; | |
07d4e9af | 155 | |
1da177e4 LT |
156 | ptr = option->mem; |
157 | while (ptr && ptr->next) | |
158 | ptr = ptr->next; | |
159 | if (ptr) | |
160 | ptr->next = data; | |
161 | else | |
162 | option->mem = data; | |
c1caf06c BH |
163 | |
164 | dev_dbg(&dev->dev, " mem " | |
165 | "min %#x max %#x align %d size %d flags %#x\n", | |
166 | data->min, data->max, data->align, data->size, data->flags); | |
1da177e4 LT |
167 | return 0; |
168 | } | |
169 | ||
170 | static void pnp_free_port(struct pnp_port *port) | |
171 | { | |
172 | struct pnp_port *next; | |
173 | ||
174 | while (port) { | |
175 | next = port->next; | |
176 | kfree(port); | |
177 | port = next; | |
178 | } | |
179 | } | |
180 | ||
181 | static void pnp_free_irq(struct pnp_irq *irq) | |
182 | { | |
183 | struct pnp_irq *next; | |
184 | ||
185 | while (irq) { | |
186 | next = irq->next; | |
187 | kfree(irq); | |
188 | irq = next; | |
189 | } | |
190 | } | |
191 | ||
192 | static void pnp_free_dma(struct pnp_dma *dma) | |
193 | { | |
194 | struct pnp_dma *next; | |
195 | ||
196 | while (dma) { | |
197 | next = dma->next; | |
198 | kfree(dma); | |
199 | dma = next; | |
200 | } | |
201 | } | |
202 | ||
203 | static void pnp_free_mem(struct pnp_mem *mem) | |
204 | { | |
205 | struct pnp_mem *next; | |
206 | ||
207 | while (mem) { | |
208 | next = mem->next; | |
209 | kfree(mem); | |
210 | mem = next; | |
211 | } | |
212 | } | |
213 | ||
214 | void pnp_free_option(struct pnp_option *option) | |
215 | { | |
216 | struct pnp_option *next; | |
217 | ||
218 | while (option) { | |
219 | next = option->next; | |
220 | pnp_free_port(option->port); | |
221 | pnp_free_irq(option->irq); | |
222 | pnp_free_dma(option->dma); | |
223 | pnp_free_mem(option->mem); | |
224 | kfree(option); | |
225 | option = next; | |
226 | } | |
227 | } | |
228 | ||
1da177e4 LT |
229 | /* |
230 | * resource validity checking | |
231 | */ | |
232 | ||
233 | #define length(start, end) (*(end) - *(start) + 1) | |
234 | ||
235 | /* Two ranges conflict if one doesn't end before the other starts */ | |
236 | #define ranged_conflict(starta, enda, startb, endb) \ | |
237 | !((*(enda) < *(startb)) || (*(endb) < *(starta))) | |
238 | ||
239 | #define cannot_compare(flags) \ | |
240 | ((flags) & (IORESOURCE_UNSET | IORESOURCE_DISABLED)) | |
241 | ||
9dd78466 | 242 | int pnp_check_port(struct pnp_dev *dev, int idx) |
1da177e4 | 243 | { |
ecfa935a | 244 | int i; |
1da177e4 | 245 | struct pnp_dev *tdev; |
30c016a0 | 246 | struct resource *res, *tres; |
b60ba834 | 247 | resource_size_t *port, *end, *tport, *tend; |
07d4e9af | 248 | |
30c016a0 BH |
249 | res = &dev->res.port_resource[idx]; |
250 | port = &res->start; | |
251 | end = &res->end; | |
1da177e4 LT |
252 | |
253 | /* if the resource doesn't exist, don't complain about it */ | |
30c016a0 | 254 | if (cannot_compare(res->flags)) |
1da177e4 LT |
255 | return 1; |
256 | ||
257 | /* check if the resource is already in use, skip if the | |
258 | * device is active because it itself may be in use */ | |
9dd78466 BH |
259 | if (!dev->active) { |
260 | if (__check_region(&ioport_resource, *port, length(port, end))) | |
1da177e4 LT |
261 | return 0; |
262 | } | |
263 | ||
264 | /* check if the resource is reserved */ | |
ecfa935a BH |
265 | for (i = 0; i < 8; i++) { |
266 | int rport = pnp_reserve_io[i << 1]; | |
267 | int rend = pnp_reserve_io[(i << 1) + 1] + rport - 1; | |
9dd78466 | 268 | if (ranged_conflict(port, end, &rport, &rend)) |
1da177e4 LT |
269 | return 0; |
270 | } | |
271 | ||
272 | /* check for internal conflicts */ | |
ecfa935a | 273 | for (i = 0; i < PNP_MAX_PORT && i != idx; i++) { |
30c016a0 BH |
274 | tres = &dev->res.port_resource[i]; |
275 | if (tres->flags & IORESOURCE_IO) { | |
276 | tport = &tres->start; | |
277 | tend = &tres->end; | |
9dd78466 | 278 | if (ranged_conflict(port, end, tport, tend)) |
1da177e4 LT |
279 | return 0; |
280 | } | |
281 | } | |
282 | ||
283 | /* check for conflicts with other pnp devices */ | |
284 | pnp_for_each_dev(tdev) { | |
285 | if (tdev == dev) | |
286 | continue; | |
ecfa935a | 287 | for (i = 0; i < PNP_MAX_PORT; i++) { |
30c016a0 BH |
288 | tres = &tdev->res.port_resource[i]; |
289 | if (tres->flags & IORESOURCE_IO) { | |
290 | if (cannot_compare(tres->flags)) | |
1da177e4 | 291 | continue; |
30c016a0 BH |
292 | tport = &tres->start; |
293 | tend = &tres->end; | |
9dd78466 | 294 | if (ranged_conflict(port, end, tport, tend)) |
1da177e4 LT |
295 | return 0; |
296 | } | |
297 | } | |
298 | } | |
299 | ||
300 | return 1; | |
301 | } | |
302 | ||
9dd78466 | 303 | int pnp_check_mem(struct pnp_dev *dev, int idx) |
1da177e4 | 304 | { |
ecfa935a | 305 | int i; |
1da177e4 | 306 | struct pnp_dev *tdev; |
30c016a0 | 307 | struct resource *res, *tres; |
b60ba834 | 308 | resource_size_t *addr, *end, *taddr, *tend; |
07d4e9af | 309 | |
30c016a0 BH |
310 | res = &dev->res.mem_resource[idx]; |
311 | addr = &res->start; | |
312 | end = &res->end; | |
1da177e4 LT |
313 | |
314 | /* if the resource doesn't exist, don't complain about it */ | |
30c016a0 | 315 | if (cannot_compare(res->flags)) |
1da177e4 LT |
316 | return 1; |
317 | ||
318 | /* check if the resource is already in use, skip if the | |
319 | * device is active because it itself may be in use */ | |
9dd78466 BH |
320 | if (!dev->active) { |
321 | if (check_mem_region(*addr, length(addr, end))) | |
1da177e4 LT |
322 | return 0; |
323 | } | |
324 | ||
325 | /* check if the resource is reserved */ | |
ecfa935a BH |
326 | for (i = 0; i < 8; i++) { |
327 | int raddr = pnp_reserve_mem[i << 1]; | |
328 | int rend = pnp_reserve_mem[(i << 1) + 1] + raddr - 1; | |
9dd78466 | 329 | if (ranged_conflict(addr, end, &raddr, &rend)) |
1da177e4 LT |
330 | return 0; |
331 | } | |
332 | ||
333 | /* check for internal conflicts */ | |
ecfa935a | 334 | for (i = 0; i < PNP_MAX_MEM && i != idx; i++) { |
30c016a0 BH |
335 | tres = &dev->res.mem_resource[i]; |
336 | if (tres->flags & IORESOURCE_MEM) { | |
337 | taddr = &tres->start; | |
338 | tend = &tres->end; | |
9dd78466 | 339 | if (ranged_conflict(addr, end, taddr, tend)) |
1da177e4 LT |
340 | return 0; |
341 | } | |
342 | } | |
343 | ||
344 | /* check for conflicts with other pnp devices */ | |
345 | pnp_for_each_dev(tdev) { | |
346 | if (tdev == dev) | |
347 | continue; | |
ecfa935a | 348 | for (i = 0; i < PNP_MAX_MEM; i++) { |
30c016a0 BH |
349 | tres = &tdev->res.mem_resource[i]; |
350 | if (tres->flags & IORESOURCE_MEM) { | |
351 | if (cannot_compare(tres->flags)) | |
1da177e4 | 352 | continue; |
30c016a0 BH |
353 | taddr = &tres->start; |
354 | tend = &tres->end; | |
9dd78466 | 355 | if (ranged_conflict(addr, end, taddr, tend)) |
1da177e4 LT |
356 | return 0; |
357 | } | |
358 | } | |
359 | } | |
360 | ||
361 | return 1; | |
362 | } | |
363 | ||
7d12e780 | 364 | static irqreturn_t pnp_test_handler(int irq, void *dev_id) |
1da177e4 LT |
365 | { |
366 | return IRQ_HANDLED; | |
367 | } | |
368 | ||
9dd78466 | 369 | int pnp_check_irq(struct pnp_dev *dev, int idx) |
1da177e4 | 370 | { |
ecfa935a | 371 | int i; |
1da177e4 | 372 | struct pnp_dev *tdev; |
30c016a0 BH |
373 | struct resource *res, *tres; |
374 | resource_size_t *irq; | |
375 | ||
376 | res = &dev->res.irq_resource[idx]; | |
377 | irq = &res->start; | |
1da177e4 LT |
378 | |
379 | /* if the resource doesn't exist, don't complain about it */ | |
30c016a0 | 380 | if (cannot_compare(res->flags)) |
1da177e4 LT |
381 | return 1; |
382 | ||
383 | /* check if the resource is valid */ | |
384 | if (*irq < 0 || *irq > 15) | |
385 | return 0; | |
386 | ||
387 | /* check if the resource is reserved */ | |
ecfa935a BH |
388 | for (i = 0; i < 16; i++) { |
389 | if (pnp_reserve_irq[i] == *irq) | |
1da177e4 LT |
390 | return 0; |
391 | } | |
392 | ||
393 | /* check for internal conflicts */ | |
ecfa935a | 394 | for (i = 0; i < PNP_MAX_IRQ && i != idx; i++) { |
30c016a0 BH |
395 | tres = &dev->res.irq_resource[i]; |
396 | if (tres->flags & IORESOURCE_IRQ) { | |
397 | if (tres->start == *irq) | |
1da177e4 LT |
398 | return 0; |
399 | } | |
400 | } | |
401 | ||
402 | #ifdef CONFIG_PCI | |
403 | /* check if the resource is being used by a pci device */ | |
404 | { | |
405 | struct pci_dev *pci = NULL; | |
406 | for_each_pci_dev(pci) { | |
8ea50a3f JL |
407 | if (pci->irq == *irq) { |
408 | pci_dev_put(pci); | |
1da177e4 | 409 | return 0; |
8ea50a3f | 410 | } |
1da177e4 LT |
411 | } |
412 | } | |
413 | #endif | |
414 | ||
415 | /* check if the resource is already in use, skip if the | |
416 | * device is active because it itself may be in use */ | |
9dd78466 | 417 | if (!dev->active) { |
0cadaf45 | 418 | if (request_irq(*irq, pnp_test_handler, |
9dd78466 | 419 | IRQF_DISABLED | IRQF_PROBE_SHARED, "pnp", NULL)) |
1da177e4 LT |
420 | return 0; |
421 | free_irq(*irq, NULL); | |
422 | } | |
423 | ||
424 | /* check for conflicts with other pnp devices */ | |
425 | pnp_for_each_dev(tdev) { | |
426 | if (tdev == dev) | |
427 | continue; | |
ecfa935a | 428 | for (i = 0; i < PNP_MAX_IRQ; i++) { |
30c016a0 BH |
429 | tres = &tdev->res.irq_resource[i]; |
430 | if (tres->flags & IORESOURCE_IRQ) { | |
431 | if (cannot_compare(tres->flags)) | |
1da177e4 | 432 | continue; |
30c016a0 | 433 | if (tres->start == *irq) |
1da177e4 LT |
434 | return 0; |
435 | } | |
436 | } | |
437 | } | |
438 | ||
439 | return 1; | |
440 | } | |
441 | ||
9dd78466 | 442 | int pnp_check_dma(struct pnp_dev *dev, int idx) |
1da177e4 LT |
443 | { |
444 | #ifndef CONFIG_IA64 | |
ecfa935a | 445 | int i; |
1da177e4 | 446 | struct pnp_dev *tdev; |
30c016a0 BH |
447 | struct resource *res, *tres; |
448 | resource_size_t *dma; | |
449 | ||
450 | res = &dev->res.dma_resource[idx]; | |
451 | dma = &res->start; | |
1da177e4 LT |
452 | |
453 | /* if the resource doesn't exist, don't complain about it */ | |
30c016a0 | 454 | if (cannot_compare(res->flags)) |
1da177e4 LT |
455 | return 1; |
456 | ||
457 | /* check if the resource is valid */ | |
458 | if (*dma < 0 || *dma == 4 || *dma > 7) | |
459 | return 0; | |
460 | ||
461 | /* check if the resource is reserved */ | |
ecfa935a BH |
462 | for (i = 0; i < 8; i++) { |
463 | if (pnp_reserve_dma[i] == *dma) | |
1da177e4 LT |
464 | return 0; |
465 | } | |
466 | ||
467 | /* check for internal conflicts */ | |
ecfa935a | 468 | for (i = 0; i < PNP_MAX_DMA && i != idx; i++) { |
30c016a0 BH |
469 | tres = &dev->res.dma_resource[i]; |
470 | if (tres->flags & IORESOURCE_DMA) { | |
471 | if (tres->start == *dma) | |
1da177e4 LT |
472 | return 0; |
473 | } | |
474 | } | |
475 | ||
476 | /* check if the resource is already in use, skip if the | |
477 | * device is active because it itself may be in use */ | |
9dd78466 | 478 | if (!dev->active) { |
1da177e4 LT |
479 | if (request_dma(*dma, "pnp")) |
480 | return 0; | |
481 | free_dma(*dma); | |
482 | } | |
483 | ||
484 | /* check for conflicts with other pnp devices */ | |
485 | pnp_for_each_dev(tdev) { | |
486 | if (tdev == dev) | |
487 | continue; | |
ecfa935a | 488 | for (i = 0; i < PNP_MAX_DMA; i++) { |
30c016a0 BH |
489 | tres = &tdev->res.dma_resource[i]; |
490 | if (tres->flags & IORESOURCE_DMA) { | |
491 | if (cannot_compare(tres->flags)) | |
1da177e4 | 492 | continue; |
30c016a0 | 493 | if (tres->start == *dma) |
1da177e4 LT |
494 | return 0; |
495 | } | |
496 | } | |
497 | } | |
498 | ||
499 | return 1; | |
500 | #else | |
07d4e9af | 501 | /* IA64 does not have legacy DMA */ |
1da177e4 LT |
502 | return 0; |
503 | #endif | |
504 | } | |
505 | ||
b90eca0a BH |
506 | struct resource *pnp_get_resource(struct pnp_dev *dev, |
507 | unsigned int type, unsigned int num) | |
508 | { | |
509 | struct pnp_resource_table *res = &dev->res; | |
510 | ||
511 | switch (type) { | |
512 | case IORESOURCE_IO: | |
513 | if (num >= PNP_MAX_PORT) | |
514 | return NULL; | |
515 | return &res->port_resource[num]; | |
516 | case IORESOURCE_MEM: | |
517 | if (num >= PNP_MAX_MEM) | |
518 | return NULL; | |
519 | return &res->mem_resource[num]; | |
520 | case IORESOURCE_IRQ: | |
521 | if (num >= PNP_MAX_IRQ) | |
522 | return NULL; | |
523 | return &res->irq_resource[num]; | |
524 | case IORESOURCE_DMA: | |
525 | if (num >= PNP_MAX_DMA) | |
526 | return NULL; | |
527 | return &res->dma_resource[num]; | |
528 | } | |
529 | return NULL; | |
530 | } | |
531 | EXPORT_SYMBOL(pnp_get_resource); | |
532 | ||
1da177e4 | 533 | /* format is: pnp_reserve_irq=irq1[,irq2] .... */ |
1da177e4 LT |
534 | static int __init pnp_setup_reserve_irq(char *str) |
535 | { | |
536 | int i; | |
537 | ||
538 | for (i = 0; i < 16; i++) | |
9dd78466 | 539 | if (get_option(&str, &pnp_reserve_irq[i]) != 2) |
1da177e4 LT |
540 | break; |
541 | return 1; | |
542 | } | |
543 | ||
544 | __setup("pnp_reserve_irq=", pnp_setup_reserve_irq); | |
545 | ||
546 | /* format is: pnp_reserve_dma=dma1[,dma2] .... */ | |
1da177e4 LT |
547 | static int __init pnp_setup_reserve_dma(char *str) |
548 | { | |
549 | int i; | |
550 | ||
551 | for (i = 0; i < 8; i++) | |
9dd78466 | 552 | if (get_option(&str, &pnp_reserve_dma[i]) != 2) |
1da177e4 LT |
553 | break; |
554 | return 1; | |
555 | } | |
556 | ||
557 | __setup("pnp_reserve_dma=", pnp_setup_reserve_dma); | |
558 | ||
559 | /* format is: pnp_reserve_io=io1,size1[,io2,size2] .... */ | |
1da177e4 LT |
560 | static int __init pnp_setup_reserve_io(char *str) |
561 | { | |
562 | int i; | |
563 | ||
564 | for (i = 0; i < 16; i++) | |
9dd78466 | 565 | if (get_option(&str, &pnp_reserve_io[i]) != 2) |
1da177e4 LT |
566 | break; |
567 | return 1; | |
568 | } | |
569 | ||
570 | __setup("pnp_reserve_io=", pnp_setup_reserve_io); | |
571 | ||
572 | /* format is: pnp_reserve_mem=mem1,size1[,mem2,size2] .... */ | |
1da177e4 LT |
573 | static int __init pnp_setup_reserve_mem(char *str) |
574 | { | |
575 | int i; | |
576 | ||
577 | for (i = 0; i < 16; i++) | |
9dd78466 | 578 | if (get_option(&str, &pnp_reserve_mem[i]) != 2) |
1da177e4 LT |
579 | break; |
580 | return 1; | |
581 | } | |
582 | ||
583 | __setup("pnp_reserve_mem=", pnp_setup_reserve_mem); |