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 | ||
bc033c9b | 31 | 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 | 80 | int pnp_register_irq_resource(struct pnp_dev *dev, struct pnp_option *option, |
c227536b | 81 | pnp_irq_mask_t *map, unsigned char flags) |
1da177e4 | 82 | { |
c227536b | 83 | struct pnp_irq *data, *ptr; |
c1caf06c BH |
84 | #ifdef DEBUG |
85 | char buf[PNP_IRQ_NR]; /* hex-encoded, so this is overkill but safe */ | |
86 | #endif | |
07d4e9af | 87 | |
c227536b BH |
88 | data = kzalloc(sizeof(struct pnp_irq), GFP_KERNEL); |
89 | if (!data) | |
90 | return -ENOMEM; | |
91 | ||
92 | data->map = *map; | |
93 | data->flags = flags; | |
94 | ||
1da177e4 LT |
95 | ptr = option->irq; |
96 | while (ptr && ptr->next) | |
97 | ptr = ptr->next; | |
98 | if (ptr) | |
99 | ptr->next = data; | |
100 | else | |
101 | option->irq = data; | |
102 | ||
103 | #ifdef CONFIG_PCI | |
104 | { | |
105 | int i; | |
106 | ||
107 | for (i = 0; i < 16; i++) | |
7aefff51 | 108 | if (test_bit(i, data->map.bits)) |
c9c3e457 | 109 | pcibios_penalize_isa_irq(i, 0); |
1da177e4 LT |
110 | } |
111 | #endif | |
c1caf06c BH |
112 | |
113 | #ifdef DEBUG | |
7aefff51 | 114 | bitmap_scnprintf(buf, sizeof(buf), data->map.bits, PNP_IRQ_NR); |
c1caf06c BH |
115 | dev_dbg(&dev->dev, " irq bitmask %s flags %#x\n", buf, |
116 | data->flags); | |
117 | #endif | |
1da177e4 LT |
118 | return 0; |
119 | } | |
120 | ||
c1caf06c | 121 | int pnp_register_dma_resource(struct pnp_dev *dev, struct pnp_option *option, |
c227536b | 122 | unsigned char map, unsigned char flags) |
1da177e4 | 123 | { |
c227536b BH |
124 | struct pnp_dma *data, *ptr; |
125 | ||
126 | data = kzalloc(sizeof(struct pnp_dma), GFP_KERNEL); | |
127 | if (!data) | |
128 | return -ENOMEM; | |
129 | ||
130 | data->map = map; | |
131 | data->flags = flags; | |
07d4e9af | 132 | |
1da177e4 LT |
133 | ptr = option->dma; |
134 | while (ptr && ptr->next) | |
135 | ptr = ptr->next; | |
136 | if (ptr) | |
137 | ptr->next = data; | |
138 | else | |
139 | option->dma = data; | |
140 | ||
c1caf06c BH |
141 | dev_dbg(&dev->dev, " dma bitmask %#x flags %#x\n", data->map, |
142 | data->flags); | |
1da177e4 LT |
143 | return 0; |
144 | } | |
145 | ||
c1caf06c | 146 | int pnp_register_port_resource(struct pnp_dev *dev, struct pnp_option *option, |
c227536b BH |
147 | resource_size_t min, resource_size_t max, |
148 | resource_size_t align, resource_size_t size, | |
149 | unsigned char flags) | |
1da177e4 | 150 | { |
c227536b BH |
151 | struct pnp_port *data, *ptr; |
152 | ||
153 | data = kzalloc(sizeof(struct pnp_port), GFP_KERNEL); | |
154 | if (!data) | |
155 | return -ENOMEM; | |
156 | ||
157 | data->min = min; | |
158 | data->max = max; | |
159 | data->align = align; | |
160 | data->size = size; | |
161 | data->flags = flags; | |
07d4e9af | 162 | |
1da177e4 LT |
163 | ptr = option->port; |
164 | while (ptr && ptr->next) | |
165 | ptr = ptr->next; | |
166 | if (ptr) | |
167 | ptr->next = data; | |
168 | else | |
169 | option->port = data; | |
170 | ||
c1caf06c | 171 | dev_dbg(&dev->dev, " io " |
169aaffe BH |
172 | "min %#llx max %#llx align %lld size %lld flags %#x\n", |
173 | (unsigned long long) data->min, | |
174 | (unsigned long long) data->max, | |
175 | (unsigned long long) data->align, | |
176 | (unsigned long long) data->size, data->flags); | |
1da177e4 LT |
177 | return 0; |
178 | } | |
179 | ||
c1caf06c | 180 | int pnp_register_mem_resource(struct pnp_dev *dev, struct pnp_option *option, |
c227536b BH |
181 | resource_size_t min, resource_size_t max, |
182 | resource_size_t align, resource_size_t size, | |
183 | unsigned char flags) | |
1da177e4 | 184 | { |
c227536b BH |
185 | struct pnp_mem *data, *ptr; |
186 | ||
187 | data = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL); | |
188 | if (!data) | |
189 | return -ENOMEM; | |
190 | ||
191 | data->min = min; | |
192 | data->max = max; | |
193 | data->align = align; | |
194 | data->size = size; | |
195 | data->flags = flags; | |
07d4e9af | 196 | |
1da177e4 LT |
197 | ptr = option->mem; |
198 | while (ptr && ptr->next) | |
199 | ptr = ptr->next; | |
200 | if (ptr) | |
201 | ptr->next = data; | |
202 | else | |
203 | option->mem = data; | |
c1caf06c BH |
204 | |
205 | dev_dbg(&dev->dev, " mem " | |
169aaffe BH |
206 | "min %#llx max %#llx align %lld size %lld flags %#x\n", |
207 | (unsigned long long) data->min, | |
208 | (unsigned long long) data->max, | |
209 | (unsigned long long) data->align, | |
210 | (unsigned long long) data->size, data->flags); | |
1da177e4 LT |
211 | return 0; |
212 | } | |
213 | ||
214 | static void pnp_free_port(struct pnp_port *port) | |
215 | { | |
216 | struct pnp_port *next; | |
217 | ||
218 | while (port) { | |
219 | next = port->next; | |
220 | kfree(port); | |
221 | port = next; | |
222 | } | |
223 | } | |
224 | ||
225 | static void pnp_free_irq(struct pnp_irq *irq) | |
226 | { | |
227 | struct pnp_irq *next; | |
228 | ||
229 | while (irq) { | |
230 | next = irq->next; | |
231 | kfree(irq); | |
232 | irq = next; | |
233 | } | |
234 | } | |
235 | ||
236 | static void pnp_free_dma(struct pnp_dma *dma) | |
237 | { | |
238 | struct pnp_dma *next; | |
239 | ||
240 | while (dma) { | |
241 | next = dma->next; | |
242 | kfree(dma); | |
243 | dma = next; | |
244 | } | |
245 | } | |
246 | ||
247 | static void pnp_free_mem(struct pnp_mem *mem) | |
248 | { | |
249 | struct pnp_mem *next; | |
250 | ||
251 | while (mem) { | |
252 | next = mem->next; | |
253 | kfree(mem); | |
254 | mem = next; | |
255 | } | |
256 | } | |
257 | ||
258 | void pnp_free_option(struct pnp_option *option) | |
259 | { | |
260 | struct pnp_option *next; | |
261 | ||
262 | while (option) { | |
263 | next = option->next; | |
264 | pnp_free_port(option->port); | |
265 | pnp_free_irq(option->irq); | |
266 | pnp_free_dma(option->dma); | |
267 | pnp_free_mem(option->mem); | |
268 | kfree(option); | |
269 | option = next; | |
270 | } | |
271 | } | |
272 | ||
1da177e4 LT |
273 | /* |
274 | * resource validity checking | |
275 | */ | |
276 | ||
277 | #define length(start, end) (*(end) - *(start) + 1) | |
278 | ||
279 | /* Two ranges conflict if one doesn't end before the other starts */ | |
280 | #define ranged_conflict(starta, enda, startb, endb) \ | |
281 | !((*(enda) < *(startb)) || (*(endb) < *(starta))) | |
282 | ||
283 | #define cannot_compare(flags) \ | |
aee3ad81 | 284 | ((flags) & IORESOURCE_DISABLED) |
1da177e4 | 285 | |
f5d94ff0 | 286 | int pnp_check_port(struct pnp_dev *dev, struct resource *res) |
1da177e4 | 287 | { |
ecfa935a | 288 | int i; |
1da177e4 | 289 | struct pnp_dev *tdev; |
f5d94ff0 | 290 | struct resource *tres; |
b60ba834 | 291 | resource_size_t *port, *end, *tport, *tend; |
07d4e9af | 292 | |
30c016a0 BH |
293 | port = &res->start; |
294 | end = &res->end; | |
1da177e4 LT |
295 | |
296 | /* if the resource doesn't exist, don't complain about it */ | |
30c016a0 | 297 | if (cannot_compare(res->flags)) |
1da177e4 LT |
298 | return 1; |
299 | ||
300 | /* check if the resource is already in use, skip if the | |
301 | * device is active because it itself may be in use */ | |
9dd78466 BH |
302 | if (!dev->active) { |
303 | if (__check_region(&ioport_resource, *port, length(port, end))) | |
1da177e4 LT |
304 | return 0; |
305 | } | |
306 | ||
307 | /* check if the resource is reserved */ | |
ecfa935a BH |
308 | for (i = 0; i < 8; i++) { |
309 | int rport = pnp_reserve_io[i << 1]; | |
310 | int rend = pnp_reserve_io[(i << 1) + 1] + rport - 1; | |
9dd78466 | 311 | if (ranged_conflict(port, end, &rport, &rend)) |
1da177e4 LT |
312 | return 0; |
313 | } | |
314 | ||
315 | /* check for internal conflicts */ | |
95ab3669 BH |
316 | for (i = 0; (tres = pnp_get_resource(dev, IORESOURCE_IO, i)); i++) { |
317 | if (tres != res && tres->flags & IORESOURCE_IO) { | |
30c016a0 BH |
318 | tport = &tres->start; |
319 | tend = &tres->end; | |
9dd78466 | 320 | if (ranged_conflict(port, end, tport, tend)) |
1da177e4 LT |
321 | return 0; |
322 | } | |
323 | } | |
324 | ||
325 | /* check for conflicts with other pnp devices */ | |
326 | pnp_for_each_dev(tdev) { | |
327 | if (tdev == dev) | |
328 | continue; | |
95ab3669 BH |
329 | for (i = 0; |
330 | (tres = pnp_get_resource(tdev, IORESOURCE_IO, i)); | |
331 | i++) { | |
332 | if (tres->flags & IORESOURCE_IO) { | |
30c016a0 | 333 | if (cannot_compare(tres->flags)) |
1da177e4 | 334 | continue; |
30c016a0 BH |
335 | tport = &tres->start; |
336 | tend = &tres->end; | |
9dd78466 | 337 | if (ranged_conflict(port, end, tport, tend)) |
1da177e4 LT |
338 | return 0; |
339 | } | |
340 | } | |
341 | } | |
342 | ||
343 | return 1; | |
344 | } | |
345 | ||
f5d94ff0 | 346 | int pnp_check_mem(struct pnp_dev *dev, struct resource *res) |
1da177e4 | 347 | { |
ecfa935a | 348 | int i; |
1da177e4 | 349 | struct pnp_dev *tdev; |
f5d94ff0 | 350 | struct resource *tres; |
b60ba834 | 351 | resource_size_t *addr, *end, *taddr, *tend; |
07d4e9af | 352 | |
30c016a0 BH |
353 | addr = &res->start; |
354 | end = &res->end; | |
1da177e4 LT |
355 | |
356 | /* if the resource doesn't exist, don't complain about it */ | |
30c016a0 | 357 | if (cannot_compare(res->flags)) |
1da177e4 LT |
358 | return 1; |
359 | ||
360 | /* check if the resource is already in use, skip if the | |
361 | * device is active because it itself may be in use */ | |
9dd78466 BH |
362 | if (!dev->active) { |
363 | if (check_mem_region(*addr, length(addr, end))) | |
1da177e4 LT |
364 | return 0; |
365 | } | |
366 | ||
367 | /* check if the resource is reserved */ | |
ecfa935a BH |
368 | for (i = 0; i < 8; i++) { |
369 | int raddr = pnp_reserve_mem[i << 1]; | |
370 | int rend = pnp_reserve_mem[(i << 1) + 1] + raddr - 1; | |
9dd78466 | 371 | if (ranged_conflict(addr, end, &raddr, &rend)) |
1da177e4 LT |
372 | return 0; |
373 | } | |
374 | ||
375 | /* check for internal conflicts */ | |
95ab3669 BH |
376 | for (i = 0; (tres = pnp_get_resource(dev, IORESOURCE_MEM, i)); i++) { |
377 | if (tres != res && tres->flags & IORESOURCE_MEM) { | |
30c016a0 BH |
378 | taddr = &tres->start; |
379 | tend = &tres->end; | |
9dd78466 | 380 | if (ranged_conflict(addr, end, taddr, tend)) |
1da177e4 LT |
381 | return 0; |
382 | } | |
383 | } | |
384 | ||
385 | /* check for conflicts with other pnp devices */ | |
386 | pnp_for_each_dev(tdev) { | |
387 | if (tdev == dev) | |
388 | continue; | |
95ab3669 BH |
389 | for (i = 0; |
390 | (tres = pnp_get_resource(tdev, IORESOURCE_MEM, i)); | |
391 | i++) { | |
392 | if (tres->flags & IORESOURCE_MEM) { | |
30c016a0 | 393 | if (cannot_compare(tres->flags)) |
1da177e4 | 394 | continue; |
30c016a0 BH |
395 | taddr = &tres->start; |
396 | tend = &tres->end; | |
9dd78466 | 397 | if (ranged_conflict(addr, end, taddr, tend)) |
1da177e4 LT |
398 | return 0; |
399 | } | |
400 | } | |
401 | } | |
402 | ||
403 | return 1; | |
404 | } | |
405 | ||
7d12e780 | 406 | static irqreturn_t pnp_test_handler(int irq, void *dev_id) |
1da177e4 LT |
407 | { |
408 | return IRQ_HANDLED; | |
409 | } | |
410 | ||
f5d94ff0 | 411 | int pnp_check_irq(struct pnp_dev *dev, struct resource *res) |
1da177e4 | 412 | { |
ecfa935a | 413 | int i; |
1da177e4 | 414 | struct pnp_dev *tdev; |
f5d94ff0 | 415 | struct resource *tres; |
30c016a0 BH |
416 | resource_size_t *irq; |
417 | ||
30c016a0 | 418 | irq = &res->start; |
1da177e4 LT |
419 | |
420 | /* if the resource doesn't exist, don't complain about it */ | |
30c016a0 | 421 | if (cannot_compare(res->flags)) |
1da177e4 LT |
422 | return 1; |
423 | ||
424 | /* check if the resource is valid */ | |
425 | if (*irq < 0 || *irq > 15) | |
426 | return 0; | |
427 | ||
428 | /* check if the resource is reserved */ | |
ecfa935a BH |
429 | for (i = 0; i < 16; i++) { |
430 | if (pnp_reserve_irq[i] == *irq) | |
1da177e4 LT |
431 | return 0; |
432 | } | |
433 | ||
434 | /* check for internal conflicts */ | |
95ab3669 BH |
435 | for (i = 0; (tres = pnp_get_resource(dev, IORESOURCE_IRQ, i)); i++) { |
436 | if (tres != res && tres->flags & IORESOURCE_IRQ) { | |
30c016a0 | 437 | if (tres->start == *irq) |
1da177e4 LT |
438 | return 0; |
439 | } | |
440 | } | |
441 | ||
442 | #ifdef CONFIG_PCI | |
443 | /* check if the resource is being used by a pci device */ | |
444 | { | |
445 | struct pci_dev *pci = NULL; | |
446 | for_each_pci_dev(pci) { | |
8ea50a3f JL |
447 | if (pci->irq == *irq) { |
448 | pci_dev_put(pci); | |
1da177e4 | 449 | return 0; |
8ea50a3f | 450 | } |
1da177e4 LT |
451 | } |
452 | } | |
453 | #endif | |
454 | ||
455 | /* check if the resource is already in use, skip if the | |
456 | * device is active because it itself may be in use */ | |
9dd78466 | 457 | if (!dev->active) { |
0cadaf45 | 458 | if (request_irq(*irq, pnp_test_handler, |
9dd78466 | 459 | IRQF_DISABLED | IRQF_PROBE_SHARED, "pnp", NULL)) |
1da177e4 LT |
460 | return 0; |
461 | free_irq(*irq, NULL); | |
462 | } | |
463 | ||
464 | /* check for conflicts with other pnp devices */ | |
465 | pnp_for_each_dev(tdev) { | |
466 | if (tdev == dev) | |
467 | continue; | |
95ab3669 BH |
468 | for (i = 0; |
469 | (tres = pnp_get_resource(tdev, IORESOURCE_IRQ, i)); | |
470 | i++) { | |
471 | if (tres->flags & IORESOURCE_IRQ) { | |
30c016a0 | 472 | if (cannot_compare(tres->flags)) |
1da177e4 | 473 | continue; |
30c016a0 | 474 | if (tres->start == *irq) |
1da177e4 LT |
475 | return 0; |
476 | } | |
477 | } | |
478 | } | |
479 | ||
480 | return 1; | |
481 | } | |
482 | ||
f5d94ff0 | 483 | int pnp_check_dma(struct pnp_dev *dev, struct resource *res) |
1da177e4 LT |
484 | { |
485 | #ifndef CONFIG_IA64 | |
ecfa935a | 486 | int i; |
1da177e4 | 487 | struct pnp_dev *tdev; |
f5d94ff0 | 488 | struct resource *tres; |
30c016a0 BH |
489 | resource_size_t *dma; |
490 | ||
30c016a0 | 491 | dma = &res->start; |
1da177e4 LT |
492 | |
493 | /* if the resource doesn't exist, don't complain about it */ | |
30c016a0 | 494 | if (cannot_compare(res->flags)) |
1da177e4 LT |
495 | return 1; |
496 | ||
497 | /* check if the resource is valid */ | |
498 | if (*dma < 0 || *dma == 4 || *dma > 7) | |
499 | return 0; | |
500 | ||
501 | /* check if the resource is reserved */ | |
ecfa935a BH |
502 | for (i = 0; i < 8; i++) { |
503 | if (pnp_reserve_dma[i] == *dma) | |
1da177e4 LT |
504 | return 0; |
505 | } | |
506 | ||
507 | /* check for internal conflicts */ | |
95ab3669 BH |
508 | for (i = 0; (tres = pnp_get_resource(dev, IORESOURCE_DMA, i)); i++) { |
509 | if (tres != res && tres->flags & IORESOURCE_DMA) { | |
30c016a0 | 510 | if (tres->start == *dma) |
1da177e4 LT |
511 | return 0; |
512 | } | |
513 | } | |
514 | ||
515 | /* check if the resource is already in use, skip if the | |
516 | * device is active because it itself may be in use */ | |
9dd78466 | 517 | if (!dev->active) { |
1da177e4 LT |
518 | if (request_dma(*dma, "pnp")) |
519 | return 0; | |
520 | free_dma(*dma); | |
521 | } | |
522 | ||
523 | /* check for conflicts with other pnp devices */ | |
524 | pnp_for_each_dev(tdev) { | |
525 | if (tdev == dev) | |
526 | continue; | |
95ab3669 BH |
527 | for (i = 0; |
528 | (tres = pnp_get_resource(tdev, IORESOURCE_DMA, i)); | |
529 | i++) { | |
530 | if (tres->flags & IORESOURCE_DMA) { | |
30c016a0 | 531 | if (cannot_compare(tres->flags)) |
1da177e4 | 532 | continue; |
30c016a0 | 533 | if (tres->start == *dma) |
1da177e4 LT |
534 | return 0; |
535 | } | |
536 | } | |
537 | } | |
538 | ||
539 | return 1; | |
540 | #else | |
07d4e9af | 541 | /* IA64 does not have legacy DMA */ |
1da177e4 LT |
542 | return 0; |
543 | #endif | |
544 | } | |
545 | ||
940e98db BH |
546 | int pnp_resource_type(struct resource *res) |
547 | { | |
548 | return res->flags & (IORESOURCE_IO | IORESOURCE_MEM | | |
549 | IORESOURCE_IRQ | IORESOURCE_DMA); | |
550 | } | |
551 | ||
0a977f15 BH |
552 | struct resource *pnp_get_resource(struct pnp_dev *dev, |
553 | unsigned int type, unsigned int num) | |
554 | { | |
555 | struct pnp_resource *pnp_res; | |
aee3ad81 | 556 | struct resource *res; |
0a977f15 | 557 | |
aee3ad81 BH |
558 | list_for_each_entry(pnp_res, &dev->resources, list) { |
559 | res = &pnp_res->res; | |
560 | if (pnp_resource_type(res) == type && num-- == 0) | |
561 | return res; | |
562 | } | |
0a977f15 BH |
563 | return NULL; |
564 | } | |
b90eca0a BH |
565 | EXPORT_SYMBOL(pnp_get_resource); |
566 | ||
aee3ad81 | 567 | static struct pnp_resource *pnp_new_resource(struct pnp_dev *dev) |
a50b6d7b BH |
568 | { |
569 | struct pnp_resource *pnp_res; | |
a50b6d7b | 570 | |
aee3ad81 BH |
571 | pnp_res = kzalloc(sizeof(struct pnp_resource), GFP_KERNEL); |
572 | if (!pnp_res) | |
573 | return NULL; | |
574 | ||
575 | list_add_tail(&pnp_res->list, &dev->resources); | |
576 | return pnp_res; | |
a50b6d7b BH |
577 | } |
578 | ||
dbddd038 BH |
579 | struct pnp_resource *pnp_add_irq_resource(struct pnp_dev *dev, int irq, |
580 | int flags) | |
581 | { | |
582 | struct pnp_resource *pnp_res; | |
583 | struct resource *res; | |
dbddd038 | 584 | |
aee3ad81 | 585 | pnp_res = pnp_new_resource(dev); |
dbddd038 | 586 | if (!pnp_res) { |
25d39c39 | 587 | dev_err(&dev->dev, "can't add resource for IRQ %d\n", irq); |
dbddd038 BH |
588 | return NULL; |
589 | } | |
590 | ||
591 | res = &pnp_res->res; | |
592 | res->flags = IORESOURCE_IRQ | flags; | |
593 | res->start = irq; | |
594 | res->end = irq; | |
595 | ||
596 | dev_dbg(&dev->dev, " add irq %d flags %#x\n", irq, flags); | |
597 | return pnp_res; | |
598 | } | |
599 | ||
dc16f5f2 BH |
600 | struct pnp_resource *pnp_add_dma_resource(struct pnp_dev *dev, int dma, |
601 | int flags) | |
602 | { | |
603 | struct pnp_resource *pnp_res; | |
604 | struct resource *res; | |
dc16f5f2 | 605 | |
aee3ad81 | 606 | pnp_res = pnp_new_resource(dev); |
dc16f5f2 | 607 | if (!pnp_res) { |
25d39c39 | 608 | dev_err(&dev->dev, "can't add resource for DMA %d\n", dma); |
dc16f5f2 BH |
609 | return NULL; |
610 | } | |
611 | ||
612 | res = &pnp_res->res; | |
613 | res->flags = IORESOURCE_DMA | flags; | |
614 | res->start = dma; | |
615 | res->end = dma; | |
616 | ||
617 | dev_dbg(&dev->dev, " add dma %d flags %#x\n", dma, flags); | |
618 | return pnp_res; | |
619 | } | |
620 | ||
cc8c2e30 BH |
621 | struct pnp_resource *pnp_add_io_resource(struct pnp_dev *dev, |
622 | resource_size_t start, | |
623 | resource_size_t end, int flags) | |
624 | { | |
625 | struct pnp_resource *pnp_res; | |
626 | struct resource *res; | |
cc8c2e30 | 627 | |
aee3ad81 | 628 | pnp_res = pnp_new_resource(dev); |
cc8c2e30 | 629 | if (!pnp_res) { |
25d39c39 BH |
630 | dev_err(&dev->dev, "can't add resource for IO %#llx-%#llx\n", |
631 | (unsigned long long) start, | |
632 | (unsigned long long) end); | |
cc8c2e30 BH |
633 | return NULL; |
634 | } | |
635 | ||
636 | res = &pnp_res->res; | |
637 | res->flags = IORESOURCE_IO | flags; | |
638 | res->start = start; | |
639 | res->end = end; | |
640 | ||
641 | dev_dbg(&dev->dev, " add io %#llx-%#llx flags %#x\n", | |
642 | (unsigned long long) start, (unsigned long long) end, flags); | |
643 | return pnp_res; | |
644 | } | |
645 | ||
d6180f36 BH |
646 | struct pnp_resource *pnp_add_mem_resource(struct pnp_dev *dev, |
647 | resource_size_t start, | |
648 | resource_size_t end, int flags) | |
649 | { | |
650 | struct pnp_resource *pnp_res; | |
651 | struct resource *res; | |
d6180f36 | 652 | |
aee3ad81 | 653 | pnp_res = pnp_new_resource(dev); |
d6180f36 | 654 | if (!pnp_res) { |
25d39c39 BH |
655 | dev_err(&dev->dev, "can't add resource for MEM %#llx-%#llx\n", |
656 | (unsigned long long) start, | |
657 | (unsigned long long) end); | |
d6180f36 BH |
658 | return NULL; |
659 | } | |
660 | ||
661 | res = &pnp_res->res; | |
662 | res->flags = IORESOURCE_MEM | flags; | |
663 | res->start = start; | |
664 | res->end = end; | |
665 | ||
666 | dev_dbg(&dev->dev, " add mem %#llx-%#llx flags %#x\n", | |
667 | (unsigned long long) start, (unsigned long long) end, flags); | |
668 | return pnp_res; | |
669 | } | |
670 | ||
57fd51a8 BH |
671 | static int pnp_possible_option(struct pnp_option *option, int type, |
672 | resource_size_t start, resource_size_t size) | |
673 | { | |
674 | struct pnp_option *tmp; | |
675 | struct pnp_port *port; | |
676 | struct pnp_mem *mem; | |
677 | struct pnp_irq *irq; | |
678 | struct pnp_dma *dma; | |
679 | ||
680 | if (!option) | |
681 | return 0; | |
682 | ||
683 | for (tmp = option; tmp; tmp = tmp->next) { | |
684 | switch (type) { | |
685 | case IORESOURCE_IO: | |
686 | for (port = tmp->port; port; port = port->next) { | |
687 | if (port->min == start && port->size == size) | |
688 | return 1; | |
689 | } | |
690 | break; | |
691 | case IORESOURCE_MEM: | |
692 | for (mem = tmp->mem; mem; mem = mem->next) { | |
693 | if (mem->min == start && mem->size == size) | |
694 | return 1; | |
695 | } | |
696 | break; | |
697 | case IORESOURCE_IRQ: | |
698 | for (irq = tmp->irq; irq; irq = irq->next) { | |
699 | if (start < PNP_IRQ_NR && | |
7aefff51 | 700 | test_bit(start, irq->map.bits)) |
57fd51a8 BH |
701 | return 1; |
702 | } | |
703 | break; | |
704 | case IORESOURCE_DMA: | |
705 | for (dma = tmp->dma; dma; dma = dma->next) { | |
706 | if (dma->map & (1 << start)) | |
707 | return 1; | |
708 | } | |
709 | break; | |
710 | } | |
711 | } | |
712 | ||
713 | return 0; | |
714 | } | |
715 | ||
716 | /* | |
717 | * Determine whether the specified resource is a possible configuration | |
718 | * for this device. | |
719 | */ | |
720 | int pnp_possible_config(struct pnp_dev *dev, int type, resource_size_t start, | |
721 | resource_size_t size) | |
722 | { | |
723 | if (pnp_possible_option(dev->independent, type, start, size)) | |
724 | return 1; | |
725 | ||
726 | if (pnp_possible_option(dev->dependent, type, start, size)) | |
727 | return 1; | |
728 | ||
729 | return 0; | |
730 | } | |
731 | EXPORT_SYMBOL(pnp_possible_config); | |
732 | ||
1da177e4 | 733 | /* format is: pnp_reserve_irq=irq1[,irq2] .... */ |
1da177e4 LT |
734 | static int __init pnp_setup_reserve_irq(char *str) |
735 | { | |
736 | int i; | |
737 | ||
738 | for (i = 0; i < 16; i++) | |
9dd78466 | 739 | if (get_option(&str, &pnp_reserve_irq[i]) != 2) |
1da177e4 LT |
740 | break; |
741 | return 1; | |
742 | } | |
743 | ||
744 | __setup("pnp_reserve_irq=", pnp_setup_reserve_irq); | |
745 | ||
746 | /* format is: pnp_reserve_dma=dma1[,dma2] .... */ | |
1da177e4 LT |
747 | static int __init pnp_setup_reserve_dma(char *str) |
748 | { | |
749 | int i; | |
750 | ||
751 | for (i = 0; i < 8; i++) | |
9dd78466 | 752 | if (get_option(&str, &pnp_reserve_dma[i]) != 2) |
1da177e4 LT |
753 | break; |
754 | return 1; | |
755 | } | |
756 | ||
757 | __setup("pnp_reserve_dma=", pnp_setup_reserve_dma); | |
758 | ||
759 | /* format is: pnp_reserve_io=io1,size1[,io2,size2] .... */ | |
1da177e4 LT |
760 | static int __init pnp_setup_reserve_io(char *str) |
761 | { | |
762 | int i; | |
763 | ||
764 | for (i = 0; i < 16; i++) | |
9dd78466 | 765 | if (get_option(&str, &pnp_reserve_io[i]) != 2) |
1da177e4 LT |
766 | break; |
767 | return 1; | |
768 | } | |
769 | ||
770 | __setup("pnp_reserve_io=", pnp_setup_reserve_io); | |
771 | ||
772 | /* format is: pnp_reserve_mem=mem1,size1[,mem2,size2] .... */ | |
1da177e4 LT |
773 | static int __init pnp_setup_reserve_mem(char *str) |
774 | { | |
775 | int i; | |
776 | ||
777 | for (i = 0; i < 16; i++) | |
9dd78466 | 778 | if (get_option(&str, &pnp_reserve_mem[i]) != 2) |
1da177e4 LT |
779 | break; |
780 | return 1; | |
781 | } | |
782 | ||
783 | __setup("pnp_reserve_mem=", pnp_setup_reserve_mem); |