x86/amd-iommu: Add per IOMMU reference counting
[linux/fpc-iii.git] / drivers / pnp / resource.c
blobba97654278862ea5824c9645bcaa740dfcfe3061
1 /*
2 * resource.c - Contains functions for registering and analyzing resource information
4 * based on isapnp.c resource management (c) Jaroslav Kysela <perex@perex.cz>
5 * Copyright 2003 Adam Belay <ambx1@neo.rr.com>
6 * Copyright (C) 2008 Hewlett-Packard Development Company, L.P.
7 * Bjorn Helgaas <bjorn.helgaas@hp.com>
8 */
10 #include <linux/module.h>
11 #include <linux/errno.h>
12 #include <linux/interrupt.h>
13 #include <linux/kernel.h>
14 #include <asm/io.h>
15 #include <asm/dma.h>
16 #include <asm/irq.h>
17 #include <linux/pci.h>
18 #include <linux/ioport.h>
19 #include <linux/init.h>
21 #include <linux/pnp.h>
22 #include "base.h"
24 static int pnp_reserve_irq[16] = {[0 ... 15] = -1 }; /* reserve (don't use) some IRQ */
25 static int pnp_reserve_dma[8] = {[0 ... 7] = -1 }; /* reserve (don't use) some DMA */
26 static int pnp_reserve_io[16] = {[0 ... 15] = -1 }; /* reserve (don't use) some I/O region */
27 static int pnp_reserve_mem[16] = {[0 ... 15] = -1 }; /* reserve (don't use) some memory region */
30 * option registration
33 struct pnp_option *pnp_build_option(struct pnp_dev *dev, unsigned long type,
34 unsigned int option_flags)
36 struct pnp_option *option;
38 option = kzalloc(sizeof(struct pnp_option), GFP_KERNEL);
39 if (!option)
40 return NULL;
42 option->flags = option_flags;
43 option->type = type;
45 list_add_tail(&option->list, &dev->options);
46 return option;
49 int pnp_register_irq_resource(struct pnp_dev *dev, unsigned int option_flags,
50 pnp_irq_mask_t *map, unsigned char flags)
52 struct pnp_option *option;
53 struct pnp_irq *irq;
55 option = pnp_build_option(dev, IORESOURCE_IRQ, option_flags);
56 if (!option)
57 return -ENOMEM;
59 irq = &option->u.irq;
60 irq->map = *map;
61 irq->flags = flags;
63 #ifdef CONFIG_PCI
65 int i;
67 for (i = 0; i < 16; i++)
68 if (test_bit(i, irq->map.bits))
69 pcibios_penalize_isa_irq(i, 0);
71 #endif
73 dbg_pnp_show_option(dev, option);
74 return 0;
77 int pnp_register_dma_resource(struct pnp_dev *dev, unsigned int option_flags,
78 unsigned char map, unsigned char flags)
80 struct pnp_option *option;
81 struct pnp_dma *dma;
83 option = pnp_build_option(dev, IORESOURCE_DMA, option_flags);
84 if (!option)
85 return -ENOMEM;
87 dma = &option->u.dma;
88 dma->map = map;
89 dma->flags = flags;
91 dbg_pnp_show_option(dev, option);
92 return 0;
95 int pnp_register_port_resource(struct pnp_dev *dev, unsigned int option_flags,
96 resource_size_t min, resource_size_t max,
97 resource_size_t align, resource_size_t size,
98 unsigned char flags)
100 struct pnp_option *option;
101 struct pnp_port *port;
103 option = pnp_build_option(dev, IORESOURCE_IO, option_flags);
104 if (!option)
105 return -ENOMEM;
107 port = &option->u.port;
108 port->min = min;
109 port->max = max;
110 port->align = align;
111 port->size = size;
112 port->flags = flags;
114 dbg_pnp_show_option(dev, option);
115 return 0;
118 int pnp_register_mem_resource(struct pnp_dev *dev, unsigned int option_flags,
119 resource_size_t min, resource_size_t max,
120 resource_size_t align, resource_size_t size,
121 unsigned char flags)
123 struct pnp_option *option;
124 struct pnp_mem *mem;
126 option = pnp_build_option(dev, IORESOURCE_MEM, option_flags);
127 if (!option)
128 return -ENOMEM;
130 mem = &option->u.mem;
131 mem->min = min;
132 mem->max = max;
133 mem->align = align;
134 mem->size = size;
135 mem->flags = flags;
137 dbg_pnp_show_option(dev, option);
138 return 0;
141 void pnp_free_options(struct pnp_dev *dev)
143 struct pnp_option *option, *tmp;
145 list_for_each_entry_safe(option, tmp, &dev->options, list) {
146 list_del(&option->list);
147 kfree(option);
152 * resource validity checking
155 #define length(start, end) (*(end) - *(start) + 1)
157 /* Two ranges conflict if one doesn't end before the other starts */
158 #define ranged_conflict(starta, enda, startb, endb) \
159 !((*(enda) < *(startb)) || (*(endb) < *(starta)))
161 #define cannot_compare(flags) \
162 ((flags) & IORESOURCE_DISABLED)
164 int pnp_check_port(struct pnp_dev *dev, struct resource *res)
166 int i;
167 struct pnp_dev *tdev;
168 struct resource *tres;
169 resource_size_t *port, *end, *tport, *tend;
171 port = &res->start;
172 end = &res->end;
174 /* if the resource doesn't exist, don't complain about it */
175 if (cannot_compare(res->flags))
176 return 1;
178 /* check if the resource is already in use, skip if the
179 * device is active because it itself may be in use */
180 if (!dev->active) {
181 if (__check_region(&ioport_resource, *port, length(port, end)))
182 return 0;
185 /* check if the resource is reserved */
186 for (i = 0; i < 8; i++) {
187 int rport = pnp_reserve_io[i << 1];
188 int rend = pnp_reserve_io[(i << 1) + 1] + rport - 1;
189 if (ranged_conflict(port, end, &rport, &rend))
190 return 0;
193 /* check for internal conflicts */
194 for (i = 0; (tres = pnp_get_resource(dev, IORESOURCE_IO, i)); i++) {
195 if (tres != res && tres->flags & IORESOURCE_IO) {
196 tport = &tres->start;
197 tend = &tres->end;
198 if (ranged_conflict(port, end, tport, tend))
199 return 0;
203 /* check for conflicts with other pnp devices */
204 pnp_for_each_dev(tdev) {
205 if (tdev == dev)
206 continue;
207 for (i = 0;
208 (tres = pnp_get_resource(tdev, IORESOURCE_IO, i));
209 i++) {
210 if (tres->flags & IORESOURCE_IO) {
211 if (cannot_compare(tres->flags))
212 continue;
213 tport = &tres->start;
214 tend = &tres->end;
215 if (ranged_conflict(port, end, tport, tend))
216 return 0;
221 return 1;
224 int pnp_check_mem(struct pnp_dev *dev, struct resource *res)
226 int i;
227 struct pnp_dev *tdev;
228 struct resource *tres;
229 resource_size_t *addr, *end, *taddr, *tend;
231 addr = &res->start;
232 end = &res->end;
234 /* if the resource doesn't exist, don't complain about it */
235 if (cannot_compare(res->flags))
236 return 1;
238 /* check if the resource is already in use, skip if the
239 * device is active because it itself may be in use */
240 if (!dev->active) {
241 if (check_mem_region(*addr, length(addr, end)))
242 return 0;
245 /* check if the resource is reserved */
246 for (i = 0; i < 8; i++) {
247 int raddr = pnp_reserve_mem[i << 1];
248 int rend = pnp_reserve_mem[(i << 1) + 1] + raddr - 1;
249 if (ranged_conflict(addr, end, &raddr, &rend))
250 return 0;
253 /* check for internal conflicts */
254 for (i = 0; (tres = pnp_get_resource(dev, IORESOURCE_MEM, i)); i++) {
255 if (tres != res && tres->flags & IORESOURCE_MEM) {
256 taddr = &tres->start;
257 tend = &tres->end;
258 if (ranged_conflict(addr, end, taddr, tend))
259 return 0;
263 /* check for conflicts with other pnp devices */
264 pnp_for_each_dev(tdev) {
265 if (tdev == dev)
266 continue;
267 for (i = 0;
268 (tres = pnp_get_resource(tdev, IORESOURCE_MEM, i));
269 i++) {
270 if (tres->flags & IORESOURCE_MEM) {
271 if (cannot_compare(tres->flags))
272 continue;
273 taddr = &tres->start;
274 tend = &tres->end;
275 if (ranged_conflict(addr, end, taddr, tend))
276 return 0;
281 return 1;
284 static irqreturn_t pnp_test_handler(int irq, void *dev_id)
286 return IRQ_HANDLED;
289 #ifdef CONFIG_PCI
290 static int pci_dev_uses_irq(struct pnp_dev *pnp, struct pci_dev *pci,
291 unsigned int irq)
293 u32 class;
294 u8 progif;
296 if (pci->irq == irq) {
297 pnp_dbg(&pnp->dev, " device %s using irq %d\n",
298 pci_name(pci), irq);
299 return 1;
303 * See pci_setup_device() and ata_pci_sff_activate_host() for
304 * similar IDE legacy detection.
306 pci_read_config_dword(pci, PCI_CLASS_REVISION, &class);
307 class >>= 8; /* discard revision ID */
308 progif = class & 0xff;
309 class >>= 8;
311 if (class == PCI_CLASS_STORAGE_IDE) {
313 * Unless both channels are native-PCI mode only,
314 * treat the compatibility IRQs as busy.
316 if ((progif & 0x5) != 0x5)
317 if (pci_get_legacy_ide_irq(pci, 0) == irq ||
318 pci_get_legacy_ide_irq(pci, 1) == irq) {
319 pnp_dbg(&pnp->dev, " legacy IDE device %s "
320 "using irq %d\n", pci_name(pci), irq);
321 return 1;
325 return 0;
327 #endif
329 static int pci_uses_irq(struct pnp_dev *pnp, unsigned int irq)
331 #ifdef CONFIG_PCI
332 struct pci_dev *pci = NULL;
334 for_each_pci_dev(pci) {
335 if (pci_dev_uses_irq(pnp, pci, irq)) {
336 pci_dev_put(pci);
337 return 1;
340 #endif
341 return 0;
344 int pnp_check_irq(struct pnp_dev *dev, struct resource *res)
346 int i;
347 struct pnp_dev *tdev;
348 struct resource *tres;
349 resource_size_t *irq;
351 irq = &res->start;
353 /* if the resource doesn't exist, don't complain about it */
354 if (cannot_compare(res->flags))
355 return 1;
357 /* check if the resource is valid */
358 if (*irq < 0 || *irq > 15)
359 return 0;
361 /* check if the resource is reserved */
362 for (i = 0; i < 16; i++) {
363 if (pnp_reserve_irq[i] == *irq)
364 return 0;
367 /* check for internal conflicts */
368 for (i = 0; (tres = pnp_get_resource(dev, IORESOURCE_IRQ, i)); i++) {
369 if (tres != res && tres->flags & IORESOURCE_IRQ) {
370 if (tres->start == *irq)
371 return 0;
375 /* check if the resource is being used by a pci device */
376 if (pci_uses_irq(dev, *irq))
377 return 0;
379 /* check if the resource is already in use, skip if the
380 * device is active because it itself may be in use */
381 if (!dev->active) {
382 if (request_irq(*irq, pnp_test_handler,
383 IRQF_DISABLED | IRQF_PROBE_SHARED, "pnp", NULL))
384 return 0;
385 free_irq(*irq, NULL);
388 /* check for conflicts with other pnp devices */
389 pnp_for_each_dev(tdev) {
390 if (tdev == dev)
391 continue;
392 for (i = 0;
393 (tres = pnp_get_resource(tdev, IORESOURCE_IRQ, i));
394 i++) {
395 if (tres->flags & IORESOURCE_IRQ) {
396 if (cannot_compare(tres->flags))
397 continue;
398 if (tres->start == *irq)
399 return 0;
404 return 1;
407 int pnp_check_dma(struct pnp_dev *dev, struct resource *res)
409 #ifndef CONFIG_IA64
410 int i;
411 struct pnp_dev *tdev;
412 struct resource *tres;
413 resource_size_t *dma;
415 dma = &res->start;
417 /* if the resource doesn't exist, don't complain about it */
418 if (cannot_compare(res->flags))
419 return 1;
421 /* check if the resource is valid */
422 if (*dma < 0 || *dma == 4 || *dma > 7)
423 return 0;
425 /* check if the resource is reserved */
426 for (i = 0; i < 8; i++) {
427 if (pnp_reserve_dma[i] == *dma)
428 return 0;
431 /* check for internal conflicts */
432 for (i = 0; (tres = pnp_get_resource(dev, IORESOURCE_DMA, i)); i++) {
433 if (tres != res && tres->flags & IORESOURCE_DMA) {
434 if (tres->start == *dma)
435 return 0;
439 /* check if the resource is already in use, skip if the
440 * device is active because it itself may be in use */
441 if (!dev->active) {
442 if (request_dma(*dma, "pnp"))
443 return 0;
444 free_dma(*dma);
447 /* check for conflicts with other pnp devices */
448 pnp_for_each_dev(tdev) {
449 if (tdev == dev)
450 continue;
451 for (i = 0;
452 (tres = pnp_get_resource(tdev, IORESOURCE_DMA, i));
453 i++) {
454 if (tres->flags & IORESOURCE_DMA) {
455 if (cannot_compare(tres->flags))
456 continue;
457 if (tres->start == *dma)
458 return 0;
463 return 1;
464 #else
465 /* IA64 does not have legacy DMA */
466 return 0;
467 #endif
470 unsigned long pnp_resource_type(struct resource *res)
472 return res->flags & (IORESOURCE_IO | IORESOURCE_MEM |
473 IORESOURCE_IRQ | IORESOURCE_DMA);
476 struct resource *pnp_get_resource(struct pnp_dev *dev,
477 unsigned long type, unsigned int num)
479 struct pnp_resource *pnp_res;
480 struct resource *res;
482 list_for_each_entry(pnp_res, &dev->resources, list) {
483 res = &pnp_res->res;
484 if (pnp_resource_type(res) == type && num-- == 0)
485 return res;
487 return NULL;
489 EXPORT_SYMBOL(pnp_get_resource);
491 static struct pnp_resource *pnp_new_resource(struct pnp_dev *dev)
493 struct pnp_resource *pnp_res;
495 pnp_res = kzalloc(sizeof(struct pnp_resource), GFP_KERNEL);
496 if (!pnp_res)
497 return NULL;
499 list_add_tail(&pnp_res->list, &dev->resources);
500 return pnp_res;
503 struct pnp_resource *pnp_add_irq_resource(struct pnp_dev *dev, int irq,
504 int flags)
506 struct pnp_resource *pnp_res;
507 struct resource *res;
509 pnp_res = pnp_new_resource(dev);
510 if (!pnp_res) {
511 dev_err(&dev->dev, "can't add resource for IRQ %d\n", irq);
512 return NULL;
515 res = &pnp_res->res;
516 res->flags = IORESOURCE_IRQ | flags;
517 res->start = irq;
518 res->end = irq;
520 pnp_dbg(&dev->dev, " add irq %d flags %#x\n", irq, flags);
521 return pnp_res;
524 struct pnp_resource *pnp_add_dma_resource(struct pnp_dev *dev, int dma,
525 int flags)
527 struct pnp_resource *pnp_res;
528 struct resource *res;
530 pnp_res = pnp_new_resource(dev);
531 if (!pnp_res) {
532 dev_err(&dev->dev, "can't add resource for DMA %d\n", dma);
533 return NULL;
536 res = &pnp_res->res;
537 res->flags = IORESOURCE_DMA | flags;
538 res->start = dma;
539 res->end = dma;
541 pnp_dbg(&dev->dev, " add dma %d flags %#x\n", dma, flags);
542 return pnp_res;
545 struct pnp_resource *pnp_add_io_resource(struct pnp_dev *dev,
546 resource_size_t start,
547 resource_size_t end, int flags)
549 struct pnp_resource *pnp_res;
550 struct resource *res;
552 pnp_res = pnp_new_resource(dev);
553 if (!pnp_res) {
554 dev_err(&dev->dev, "can't add resource for IO %#llx-%#llx\n",
555 (unsigned long long) start,
556 (unsigned long long) end);
557 return NULL;
560 res = &pnp_res->res;
561 res->flags = IORESOURCE_IO | flags;
562 res->start = start;
563 res->end = end;
565 pnp_dbg(&dev->dev, " add io %#llx-%#llx flags %#x\n",
566 (unsigned long long) start, (unsigned long long) end, flags);
567 return pnp_res;
570 struct pnp_resource *pnp_add_mem_resource(struct pnp_dev *dev,
571 resource_size_t start,
572 resource_size_t end, int flags)
574 struct pnp_resource *pnp_res;
575 struct resource *res;
577 pnp_res = pnp_new_resource(dev);
578 if (!pnp_res) {
579 dev_err(&dev->dev, "can't add resource for MEM %#llx-%#llx\n",
580 (unsigned long long) start,
581 (unsigned long long) end);
582 return NULL;
585 res = &pnp_res->res;
586 res->flags = IORESOURCE_MEM | flags;
587 res->start = start;
588 res->end = end;
590 pnp_dbg(&dev->dev, " add mem %#llx-%#llx flags %#x\n",
591 (unsigned long long) start, (unsigned long long) end, flags);
592 return pnp_res;
596 * Determine whether the specified resource is a possible configuration
597 * for this device.
599 int pnp_possible_config(struct pnp_dev *dev, int type, resource_size_t start,
600 resource_size_t size)
602 struct pnp_option *option;
603 struct pnp_port *port;
604 struct pnp_mem *mem;
605 struct pnp_irq *irq;
606 struct pnp_dma *dma;
608 list_for_each_entry(option, &dev->options, list) {
609 if (option->type != type)
610 continue;
612 switch (option->type) {
613 case IORESOURCE_IO:
614 port = &option->u.port;
615 if (port->min == start && port->size == size)
616 return 1;
617 break;
618 case IORESOURCE_MEM:
619 mem = &option->u.mem;
620 if (mem->min == start && mem->size == size)
621 return 1;
622 break;
623 case IORESOURCE_IRQ:
624 irq = &option->u.irq;
625 if (start < PNP_IRQ_NR &&
626 test_bit(start, irq->map.bits))
627 return 1;
628 break;
629 case IORESOURCE_DMA:
630 dma = &option->u.dma;
631 if (dma->map & (1 << start))
632 return 1;
633 break;
637 return 0;
639 EXPORT_SYMBOL(pnp_possible_config);
641 int pnp_range_reserved(resource_size_t start, resource_size_t end)
643 struct pnp_dev *dev;
644 struct pnp_resource *pnp_res;
645 resource_size_t *dev_start, *dev_end;
647 pnp_for_each_dev(dev) {
648 list_for_each_entry(pnp_res, &dev->resources, list) {
649 dev_start = &pnp_res->res.start;
650 dev_end = &pnp_res->res.end;
651 if (ranged_conflict(&start, &end, dev_start, dev_end))
652 return 1;
655 return 0;
657 EXPORT_SYMBOL(pnp_range_reserved);
659 /* format is: pnp_reserve_irq=irq1[,irq2] .... */
660 static int __init pnp_setup_reserve_irq(char *str)
662 int i;
664 for (i = 0; i < 16; i++)
665 if (get_option(&str, &pnp_reserve_irq[i]) != 2)
666 break;
667 return 1;
670 __setup("pnp_reserve_irq=", pnp_setup_reserve_irq);
672 /* format is: pnp_reserve_dma=dma1[,dma2] .... */
673 static int __init pnp_setup_reserve_dma(char *str)
675 int i;
677 for (i = 0; i < 8; i++)
678 if (get_option(&str, &pnp_reserve_dma[i]) != 2)
679 break;
680 return 1;
683 __setup("pnp_reserve_dma=", pnp_setup_reserve_dma);
685 /* format is: pnp_reserve_io=io1,size1[,io2,size2] .... */
686 static int __init pnp_setup_reserve_io(char *str)
688 int i;
690 for (i = 0; i < 16; i++)
691 if (get_option(&str, &pnp_reserve_io[i]) != 2)
692 break;
693 return 1;
696 __setup("pnp_reserve_io=", pnp_setup_reserve_io);
698 /* format is: pnp_reserve_mem=mem1,size1[,mem2,size2] .... */
699 static int __init pnp_setup_reserve_mem(char *str)
701 int i;
703 for (i = 0; i < 16; i++)
704 if (get_option(&str, &pnp_reserve_mem[i]) != 2)
705 break;
706 return 1;
709 __setup("pnp_reserve_mem=", pnp_setup_reserve_mem);