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; |
b60ba834 | 246 | resource_size_t *port, *end, *tport, *tend; |
07d4e9af | 247 | |
1da177e4 LT |
248 | port = &dev->res.port_resource[idx].start; |
249 | end = &dev->res.port_resource[idx].end; | |
250 | ||
251 | /* if the resource doesn't exist, don't complain about it */ | |
252 | if (cannot_compare(dev->res.port_resource[idx].flags)) | |
253 | return 1; | |
254 | ||
255 | /* check if the resource is already in use, skip if the | |
256 | * device is active because it itself may be in use */ | |
9dd78466 BH |
257 | if (!dev->active) { |
258 | if (__check_region(&ioport_resource, *port, length(port, end))) | |
1da177e4 LT |
259 | return 0; |
260 | } | |
261 | ||
262 | /* check if the resource is reserved */ | |
ecfa935a BH |
263 | for (i = 0; i < 8; i++) { |
264 | int rport = pnp_reserve_io[i << 1]; | |
265 | int rend = pnp_reserve_io[(i << 1) + 1] + rport - 1; | |
9dd78466 | 266 | if (ranged_conflict(port, end, &rport, &rend)) |
1da177e4 LT |
267 | return 0; |
268 | } | |
269 | ||
270 | /* check for internal conflicts */ | |
ecfa935a BH |
271 | for (i = 0; i < PNP_MAX_PORT && i != idx; i++) { |
272 | if (dev->res.port_resource[i].flags & IORESOURCE_IO) { | |
273 | tport = &dev->res.port_resource[i].start; | |
274 | tend = &dev->res.port_resource[i].end; | |
9dd78466 | 275 | if (ranged_conflict(port, end, tport, tend)) |
1da177e4 LT |
276 | return 0; |
277 | } | |
278 | } | |
279 | ||
280 | /* check for conflicts with other pnp devices */ | |
281 | pnp_for_each_dev(tdev) { | |
282 | if (tdev == dev) | |
283 | continue; | |
ecfa935a BH |
284 | for (i = 0; i < PNP_MAX_PORT; i++) { |
285 | if (tdev->res.port_resource[i].flags & IORESOURCE_IO) { | |
9dd78466 | 286 | if (cannot_compare |
ecfa935a | 287 | (tdev->res.port_resource[i].flags)) |
1da177e4 | 288 | continue; |
ecfa935a BH |
289 | tport = &tdev->res.port_resource[i].start; |
290 | tend = &tdev->res.port_resource[i].end; | |
9dd78466 | 291 | if (ranged_conflict(port, end, tport, tend)) |
1da177e4 LT |
292 | return 0; |
293 | } | |
294 | } | |
295 | } | |
296 | ||
297 | return 1; | |
298 | } | |
299 | ||
9dd78466 | 300 | int pnp_check_mem(struct pnp_dev *dev, int idx) |
1da177e4 | 301 | { |
ecfa935a | 302 | int i; |
1da177e4 | 303 | struct pnp_dev *tdev; |
b60ba834 | 304 | resource_size_t *addr, *end, *taddr, *tend; |
07d4e9af | 305 | |
1da177e4 LT |
306 | addr = &dev->res.mem_resource[idx].start; |
307 | end = &dev->res.mem_resource[idx].end; | |
308 | ||
309 | /* if the resource doesn't exist, don't complain about it */ | |
310 | if (cannot_compare(dev->res.mem_resource[idx].flags)) | |
311 | return 1; | |
312 | ||
313 | /* check if the resource is already in use, skip if the | |
314 | * device is active because it itself may be in use */ | |
9dd78466 BH |
315 | if (!dev->active) { |
316 | if (check_mem_region(*addr, length(addr, end))) | |
1da177e4 LT |
317 | return 0; |
318 | } | |
319 | ||
320 | /* check if the resource is reserved */ | |
ecfa935a BH |
321 | for (i = 0; i < 8; i++) { |
322 | int raddr = pnp_reserve_mem[i << 1]; | |
323 | int rend = pnp_reserve_mem[(i << 1) + 1] + raddr - 1; | |
9dd78466 | 324 | if (ranged_conflict(addr, end, &raddr, &rend)) |
1da177e4 LT |
325 | return 0; |
326 | } | |
327 | ||
328 | /* check for internal conflicts */ | |
ecfa935a BH |
329 | for (i = 0; i < PNP_MAX_MEM && i != idx; i++) { |
330 | if (dev->res.mem_resource[i].flags & IORESOURCE_MEM) { | |
331 | taddr = &dev->res.mem_resource[i].start; | |
332 | tend = &dev->res.mem_resource[i].end; | |
9dd78466 | 333 | if (ranged_conflict(addr, end, taddr, tend)) |
1da177e4 LT |
334 | return 0; |
335 | } | |
336 | } | |
337 | ||
338 | /* check for conflicts with other pnp devices */ | |
339 | pnp_for_each_dev(tdev) { | |
340 | if (tdev == dev) | |
341 | continue; | |
ecfa935a BH |
342 | for (i = 0; i < PNP_MAX_MEM; i++) { |
343 | if (tdev->res.mem_resource[i].flags & IORESOURCE_MEM) { | |
9dd78466 | 344 | if (cannot_compare |
ecfa935a | 345 | (tdev->res.mem_resource[i].flags)) |
1da177e4 | 346 | continue; |
ecfa935a BH |
347 | taddr = &tdev->res.mem_resource[i].start; |
348 | tend = &tdev->res.mem_resource[i].end; | |
9dd78466 | 349 | if (ranged_conflict(addr, end, taddr, tend)) |
1da177e4 LT |
350 | return 0; |
351 | } | |
352 | } | |
353 | } | |
354 | ||
355 | return 1; | |
356 | } | |
357 | ||
7d12e780 | 358 | static irqreturn_t pnp_test_handler(int irq, void *dev_id) |
1da177e4 LT |
359 | { |
360 | return IRQ_HANDLED; | |
361 | } | |
362 | ||
9dd78466 | 363 | int pnp_check_irq(struct pnp_dev *dev, int idx) |
1da177e4 | 364 | { |
ecfa935a | 365 | int i; |
1da177e4 | 366 | struct pnp_dev *tdev; |
9dd78466 | 367 | resource_size_t *irq = &dev->res.irq_resource[idx].start; |
1da177e4 LT |
368 | |
369 | /* if the resource doesn't exist, don't complain about it */ | |
370 | if (cannot_compare(dev->res.irq_resource[idx].flags)) | |
371 | return 1; | |
372 | ||
373 | /* check if the resource is valid */ | |
374 | if (*irq < 0 || *irq > 15) | |
375 | return 0; | |
376 | ||
377 | /* check if the resource is reserved */ | |
ecfa935a BH |
378 | for (i = 0; i < 16; i++) { |
379 | if (pnp_reserve_irq[i] == *irq) | |
1da177e4 LT |
380 | return 0; |
381 | } | |
382 | ||
383 | /* check for internal conflicts */ | |
ecfa935a BH |
384 | for (i = 0; i < PNP_MAX_IRQ && i != idx; i++) { |
385 | if (dev->res.irq_resource[i].flags & IORESOURCE_IRQ) { | |
386 | if (dev->res.irq_resource[i].start == *irq) | |
1da177e4 LT |
387 | return 0; |
388 | } | |
389 | } | |
390 | ||
391 | #ifdef CONFIG_PCI | |
392 | /* check if the resource is being used by a pci device */ | |
393 | { | |
394 | struct pci_dev *pci = NULL; | |
395 | for_each_pci_dev(pci) { | |
8ea50a3f JL |
396 | if (pci->irq == *irq) { |
397 | pci_dev_put(pci); | |
1da177e4 | 398 | return 0; |
8ea50a3f | 399 | } |
1da177e4 LT |
400 | } |
401 | } | |
402 | #endif | |
403 | ||
404 | /* check if the resource is already in use, skip if the | |
405 | * device is active because it itself may be in use */ | |
9dd78466 | 406 | if (!dev->active) { |
0cadaf45 | 407 | if (request_irq(*irq, pnp_test_handler, |
9dd78466 | 408 | IRQF_DISABLED | IRQF_PROBE_SHARED, "pnp", NULL)) |
1da177e4 LT |
409 | return 0; |
410 | free_irq(*irq, NULL); | |
411 | } | |
412 | ||
413 | /* check for conflicts with other pnp devices */ | |
414 | pnp_for_each_dev(tdev) { | |
415 | if (tdev == dev) | |
416 | continue; | |
ecfa935a BH |
417 | for (i = 0; i < PNP_MAX_IRQ; i++) { |
418 | if (tdev->res.irq_resource[i].flags & IORESOURCE_IRQ) { | |
9dd78466 | 419 | if (cannot_compare |
ecfa935a | 420 | (tdev->res.irq_resource[i].flags)) |
1da177e4 | 421 | continue; |
ecfa935a | 422 | if ((tdev->res.irq_resource[i].start == *irq)) |
1da177e4 LT |
423 | return 0; |
424 | } | |
425 | } | |
426 | } | |
427 | ||
428 | return 1; | |
429 | } | |
430 | ||
9dd78466 | 431 | int pnp_check_dma(struct pnp_dev *dev, int idx) |
1da177e4 LT |
432 | { |
433 | #ifndef CONFIG_IA64 | |
ecfa935a | 434 | int i; |
1da177e4 | 435 | struct pnp_dev *tdev; |
9dd78466 | 436 | resource_size_t *dma = &dev->res.dma_resource[idx].start; |
1da177e4 LT |
437 | |
438 | /* if the resource doesn't exist, don't complain about it */ | |
439 | if (cannot_compare(dev->res.dma_resource[idx].flags)) | |
440 | return 1; | |
441 | ||
442 | /* check if the resource is valid */ | |
443 | if (*dma < 0 || *dma == 4 || *dma > 7) | |
444 | return 0; | |
445 | ||
446 | /* check if the resource is reserved */ | |
ecfa935a BH |
447 | for (i = 0; i < 8; i++) { |
448 | if (pnp_reserve_dma[i] == *dma) | |
1da177e4 LT |
449 | return 0; |
450 | } | |
451 | ||
452 | /* check for internal conflicts */ | |
ecfa935a BH |
453 | for (i = 0; i < PNP_MAX_DMA && i != idx; i++) { |
454 | if (dev->res.dma_resource[i].flags & IORESOURCE_DMA) { | |
455 | if (dev->res.dma_resource[i].start == *dma) | |
1da177e4 LT |
456 | return 0; |
457 | } | |
458 | } | |
459 | ||
460 | /* check if the resource is already in use, skip if the | |
461 | * device is active because it itself may be in use */ | |
9dd78466 | 462 | if (!dev->active) { |
1da177e4 LT |
463 | if (request_dma(*dma, "pnp")) |
464 | return 0; | |
465 | free_dma(*dma); | |
466 | } | |
467 | ||
468 | /* check for conflicts with other pnp devices */ | |
469 | pnp_for_each_dev(tdev) { | |
470 | if (tdev == dev) | |
471 | continue; | |
ecfa935a BH |
472 | for (i = 0; i < PNP_MAX_DMA; i++) { |
473 | if (tdev->res.dma_resource[i].flags & IORESOURCE_DMA) { | |
9dd78466 | 474 | if (cannot_compare |
ecfa935a | 475 | (tdev->res.dma_resource[i].flags)) |
1da177e4 | 476 | continue; |
ecfa935a | 477 | if ((tdev->res.dma_resource[i].start == *dma)) |
1da177e4 LT |
478 | return 0; |
479 | } | |
480 | } | |
481 | } | |
482 | ||
483 | return 1; | |
484 | #else | |
07d4e9af | 485 | /* IA64 does not have legacy DMA */ |
1da177e4 LT |
486 | return 0; |
487 | #endif | |
488 | } | |
489 | ||
b90eca0a BH |
490 | struct resource *pnp_get_resource(struct pnp_dev *dev, |
491 | unsigned int type, unsigned int num) | |
492 | { | |
493 | struct pnp_resource_table *res = &dev->res; | |
494 | ||
495 | switch (type) { | |
496 | case IORESOURCE_IO: | |
497 | if (num >= PNP_MAX_PORT) | |
498 | return NULL; | |
499 | return &res->port_resource[num]; | |
500 | case IORESOURCE_MEM: | |
501 | if (num >= PNP_MAX_MEM) | |
502 | return NULL; | |
503 | return &res->mem_resource[num]; | |
504 | case IORESOURCE_IRQ: | |
505 | if (num >= PNP_MAX_IRQ) | |
506 | return NULL; | |
507 | return &res->irq_resource[num]; | |
508 | case IORESOURCE_DMA: | |
509 | if (num >= PNP_MAX_DMA) | |
510 | return NULL; | |
511 | return &res->dma_resource[num]; | |
512 | } | |
513 | return NULL; | |
514 | } | |
515 | EXPORT_SYMBOL(pnp_get_resource); | |
516 | ||
1da177e4 | 517 | /* format is: pnp_reserve_irq=irq1[,irq2] .... */ |
1da177e4 LT |
518 | static int __init pnp_setup_reserve_irq(char *str) |
519 | { | |
520 | int i; | |
521 | ||
522 | for (i = 0; i < 16; i++) | |
9dd78466 | 523 | if (get_option(&str, &pnp_reserve_irq[i]) != 2) |
1da177e4 LT |
524 | break; |
525 | return 1; | |
526 | } | |
527 | ||
528 | __setup("pnp_reserve_irq=", pnp_setup_reserve_irq); | |
529 | ||
530 | /* format is: pnp_reserve_dma=dma1[,dma2] .... */ | |
1da177e4 LT |
531 | static int __init pnp_setup_reserve_dma(char *str) |
532 | { | |
533 | int i; | |
534 | ||
535 | for (i = 0; i < 8; i++) | |
9dd78466 | 536 | if (get_option(&str, &pnp_reserve_dma[i]) != 2) |
1da177e4 LT |
537 | break; |
538 | return 1; | |
539 | } | |
540 | ||
541 | __setup("pnp_reserve_dma=", pnp_setup_reserve_dma); | |
542 | ||
543 | /* format is: pnp_reserve_io=io1,size1[,io2,size2] .... */ | |
1da177e4 LT |
544 | static int __init pnp_setup_reserve_io(char *str) |
545 | { | |
546 | int i; | |
547 | ||
548 | for (i = 0; i < 16; i++) | |
9dd78466 | 549 | if (get_option(&str, &pnp_reserve_io[i]) != 2) |
1da177e4 LT |
550 | break; |
551 | return 1; | |
552 | } | |
553 | ||
554 | __setup("pnp_reserve_io=", pnp_setup_reserve_io); | |
555 | ||
556 | /* format is: pnp_reserve_mem=mem1,size1[,mem2,size2] .... */ | |
1da177e4 LT |
557 | static int __init pnp_setup_reserve_mem(char *str) |
558 | { | |
559 | int i; | |
560 | ||
561 | for (i = 0; i < 16; i++) | |
9dd78466 | 562 | if (get_option(&str, &pnp_reserve_mem[i]) != 2) |
1da177e4 LT |
563 | break; |
564 | return 1; | |
565 | } | |
566 | ||
567 | __setup("pnp_reserve_mem=", pnp_setup_reserve_mem); |