1 /* 2 * resource.c - Contains functions for registering and analyzing resource information 3 * 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 */ 9 10 #include <linux/module.h> 11 #include <linux/slab.h> 12 #include <linux/errno.h> 13 #include <linux/interrupt.h> 14 #include <linux/kernel.h> 15 #include <asm/io.h> 16 #include <asm/dma.h> 17 #include <asm/irq.h> 18 #include <linux/pci.h> 19 #include <linux/ioport.h> 20 #include <linux/init.h> 21 22 #include <linux/pnp.h> 23 #include "base.h" 24 25 static int pnp_reserve_irq[16] = {[0 ... 15] = -1 }; /* reserve (don't use) some IRQ */ 26 static int pnp_reserve_dma[8] = {[0 ... 7] = -1 }; /* reserve (don't use) some DMA */ 27 static int pnp_reserve_io[16] = {[0 ... 15] = -1 }; /* reserve (don't use) some I/O region */ 28 static int pnp_reserve_mem[16] = {[0 ... 15] = -1 }; /* reserve (don't use) some memory region */ 29 30 /* 31 * option registration 32 */ 33 34 static struct pnp_option *pnp_build_option(struct pnp_dev *dev, unsigned long type, 35 unsigned int option_flags) 36 { 37 struct pnp_option *option; 38 39 option = kzalloc(sizeof(struct pnp_option), GFP_KERNEL); 40 if (!option) 41 return NULL; 42 43 option->flags = option_flags; 44 option->type = type; 45 46 list_add_tail(&option->list, &dev->options); 47 return option; 48 } 49 50 int pnp_register_irq_resource(struct pnp_dev *dev, unsigned int option_flags, 51 pnp_irq_mask_t *map, unsigned char flags) 52 { 53 struct pnp_option *option; 54 struct pnp_irq *irq; 55 56 option = pnp_build_option(dev, IORESOURCE_IRQ, option_flags); 57 if (!option) 58 return -ENOMEM; 59 60 irq = &option->u.irq; 61 irq->map = *map; 62 irq->flags = flags; 63 64 #ifdef CONFIG_PCI 65 { 66 int i; 67 68 for (i = 0; i < 16; i++) 69 if (test_bit(i, irq->map.bits)) 70 pcibios_penalize_isa_irq(i, 0); 71 } 72 #endif 73 74 dbg_pnp_show_option(dev, option); 75 return 0; 76 } 77 78 int pnp_register_dma_resource(struct pnp_dev *dev, unsigned int option_flags, 79 unsigned char map, unsigned char flags) 80 { 81 struct pnp_option *option; 82 struct pnp_dma *dma; 83 84 option = pnp_build_option(dev, IORESOURCE_DMA, option_flags); 85 if (!option) 86 return -ENOMEM; 87 88 dma = &option->u.dma; 89 dma->map = map; 90 dma->flags = flags; 91 92 dbg_pnp_show_option(dev, option); 93 return 0; 94 } 95 96 int pnp_register_port_resource(struct pnp_dev *dev, unsigned int option_flags, 97 resource_size_t min, resource_size_t max, 98 resource_size_t align, resource_size_t size, 99 unsigned char flags) 100 { 101 struct pnp_option *option; 102 struct pnp_port *port; 103 104 option = pnp_build_option(dev, IORESOURCE_IO, option_flags); 105 if (!option) 106 return -ENOMEM; 107 108 port = &option->u.port; 109 port->min = min; 110 port->max = max; 111 port->align = align; 112 port->size = size; 113 port->flags = flags; 114 115 dbg_pnp_show_option(dev, option); 116 return 0; 117 } 118 119 int pnp_register_mem_resource(struct pnp_dev *dev, unsigned int option_flags, 120 resource_size_t min, resource_size_t max, 121 resource_size_t align, resource_size_t size, 122 unsigned char flags) 123 { 124 struct pnp_option *option; 125 struct pnp_mem *mem; 126 127 option = pnp_build_option(dev, IORESOURCE_MEM, option_flags); 128 if (!option) 129 return -ENOMEM; 130 131 mem = &option->u.mem; 132 mem->min = min; 133 mem->max = max; 134 mem->align = align; 135 mem->size = size; 136 mem->flags = flags; 137 138 dbg_pnp_show_option(dev, option); 139 return 0; 140 } 141 142 void pnp_free_options(struct pnp_dev *dev) 143 { 144 struct pnp_option *option, *tmp; 145 146 list_for_each_entry_safe(option, tmp, &dev->options, list) { 147 list_del(&option->list); 148 kfree(option); 149 } 150 } 151 152 /* 153 * resource validity checking 154 */ 155 156 #define length(start, end) (*(end) - *(start) + 1) 157 158 /* Two ranges conflict if one doesn't end before the other starts */ 159 #define ranged_conflict(starta, enda, startb, endb) \ 160 !((*(enda) < *(startb)) || (*(endb) < *(starta))) 161 162 #define cannot_compare(flags) \ 163 ((flags) & IORESOURCE_DISABLED) 164 165 int pnp_check_port(struct pnp_dev *dev, struct resource *res) 166 { 167 int i; 168 struct pnp_dev *tdev; 169 struct resource *tres; 170 resource_size_t *port, *end, *tport, *tend; 171 172 port = &res->start; 173 end = &res->end; 174 175 /* if the resource doesn't exist, don't complain about it */ 176 if (cannot_compare(res->flags)) 177 return 1; 178 179 /* check if the resource is already in use, skip if the 180 * device is active because it itself may be in use */ 181 if (!dev->active) { 182 if (!request_region(*port, length(port, end), "pnp")) 183 return 0; 184 release_region(*port, length(port, end)); 185 } 186 187 /* check if the resource is reserved */ 188 for (i = 0; i < 8; i++) { 189 int rport = pnp_reserve_io[i << 1]; 190 int rend = pnp_reserve_io[(i << 1) + 1] + rport - 1; 191 if (ranged_conflict(port, end, &rport, &rend)) 192 return 0; 193 } 194 195 /* check for internal conflicts */ 196 for (i = 0; (tres = pnp_get_resource(dev, IORESOURCE_IO, i)); i++) { 197 if (tres != res && tres->flags & IORESOURCE_IO) { 198 tport = &tres->start; 199 tend = &tres->end; 200 if (ranged_conflict(port, end, tport, tend)) 201 return 0; 202 } 203 } 204 205 /* check for conflicts with other pnp devices */ 206 pnp_for_each_dev(tdev) { 207 if (tdev == dev) 208 continue; 209 for (i = 0; 210 (tres = pnp_get_resource(tdev, IORESOURCE_IO, i)); 211 i++) { 212 if (tres->flags & IORESOURCE_IO) { 213 if (cannot_compare(tres->flags)) 214 continue; 215 if (tres->flags & IORESOURCE_WINDOW) 216 continue; 217 tport = &tres->start; 218 tend = &tres->end; 219 if (ranged_conflict(port, end, tport, tend)) 220 return 0; 221 } 222 } 223 } 224 225 return 1; 226 } 227 228 int pnp_check_mem(struct pnp_dev *dev, struct resource *res) 229 { 230 int i; 231 struct pnp_dev *tdev; 232 struct resource *tres; 233 resource_size_t *addr, *end, *taddr, *tend; 234 235 addr = &res->start; 236 end = &res->end; 237 238 /* if the resource doesn't exist, don't complain about it */ 239 if (cannot_compare(res->flags)) 240 return 1; 241 242 /* check if the resource is already in use, skip if the 243 * device is active because it itself may be in use */ 244 if (!dev->active) { 245 if (!request_mem_region(*addr, length(addr, end), "pnp")) 246 return 0; 247 release_mem_region(*addr, length(addr, end)); 248 } 249 250 /* check if the resource is reserved */ 251 for (i = 0; i < 8; i++) { 252 int raddr = pnp_reserve_mem[i << 1]; 253 int rend = pnp_reserve_mem[(i << 1) + 1] + raddr - 1; 254 if (ranged_conflict(addr, end, &raddr, &rend)) 255 return 0; 256 } 257 258 /* check for internal conflicts */ 259 for (i = 0; (tres = pnp_get_resource(dev, IORESOURCE_MEM, i)); i++) { 260 if (tres != res && tres->flags & IORESOURCE_MEM) { 261 taddr = &tres->start; 262 tend = &tres->end; 263 if (ranged_conflict(addr, end, taddr, tend)) 264 return 0; 265 } 266 } 267 268 /* check for conflicts with other pnp devices */ 269 pnp_for_each_dev(tdev) { 270 if (tdev == dev) 271 continue; 272 for (i = 0; 273 (tres = pnp_get_resource(tdev, IORESOURCE_MEM, i)); 274 i++) { 275 if (tres->flags & IORESOURCE_MEM) { 276 if (cannot_compare(tres->flags)) 277 continue; 278 if (tres->flags & IORESOURCE_WINDOW) 279 continue; 280 taddr = &tres->start; 281 tend = &tres->end; 282 if (ranged_conflict(addr, end, taddr, tend)) 283 return 0; 284 } 285 } 286 } 287 288 return 1; 289 } 290 291 static irqreturn_t pnp_test_handler(int irq, void *dev_id) 292 { 293 return IRQ_HANDLED; 294 } 295 296 #ifdef CONFIG_PCI 297 static int pci_dev_uses_irq(struct pnp_dev *pnp, struct pci_dev *pci, 298 unsigned int irq) 299 { 300 u32 class; 301 u8 progif; 302 303 if (pci->irq == irq) { 304 pnp_dbg(&pnp->dev, " device %s using irq %d\n", 305 pci_name(pci), irq); 306 return 1; 307 } 308 309 /* 310 * See pci_setup_device() and ata_pci_sff_activate_host() for 311 * similar IDE legacy detection. 312 */ 313 pci_read_config_dword(pci, PCI_CLASS_REVISION, &class); 314 class >>= 8; /* discard revision ID */ 315 progif = class & 0xff; 316 class >>= 8; 317 318 if (class == PCI_CLASS_STORAGE_IDE) { 319 /* 320 * Unless both channels are native-PCI mode only, 321 * treat the compatibility IRQs as busy. 322 */ 323 if ((progif & 0x5) != 0x5) 324 if (pci_get_legacy_ide_irq(pci, 0) == irq || 325 pci_get_legacy_ide_irq(pci, 1) == irq) { 326 pnp_dbg(&pnp->dev, " legacy IDE device %s " 327 "using irq %d\n", pci_name(pci), irq); 328 return 1; 329 } 330 } 331 332 return 0; 333 } 334 #endif 335 336 static int pci_uses_irq(struct pnp_dev *pnp, unsigned int irq) 337 { 338 #ifdef CONFIG_PCI 339 struct pci_dev *pci = NULL; 340 341 for_each_pci_dev(pci) { 342 if (pci_dev_uses_irq(pnp, pci, irq)) { 343 pci_dev_put(pci); 344 return 1; 345 } 346 } 347 #endif 348 return 0; 349 } 350 351 int pnp_check_irq(struct pnp_dev *dev, struct resource *res) 352 { 353 int i; 354 struct pnp_dev *tdev; 355 struct resource *tres; 356 resource_size_t *irq; 357 358 irq = &res->start; 359 360 /* if the resource doesn't exist, don't complain about it */ 361 if (cannot_compare(res->flags)) 362 return 1; 363 364 /* check if the resource is valid */ 365 if (*irq > 15) 366 return 0; 367 368 /* check if the resource is reserved */ 369 for (i = 0; i < 16; i++) { 370 if (pnp_reserve_irq[i] == *irq) 371 return 0; 372 } 373 374 /* check for internal conflicts */ 375 for (i = 0; (tres = pnp_get_resource(dev, IORESOURCE_IRQ, i)); i++) { 376 if (tres != res && tres->flags & IORESOURCE_IRQ) { 377 if (tres->start == *irq) 378 return 0; 379 } 380 } 381 382 /* check if the resource is being used by a pci device */ 383 if (pci_uses_irq(dev, *irq)) 384 return 0; 385 386 /* check if the resource is already in use, skip if the 387 * device is active because it itself may be in use */ 388 if (!dev->active) { 389 if (request_irq(*irq, pnp_test_handler, 390 IRQF_PROBE_SHARED, "pnp", NULL)) 391 return 0; 392 free_irq(*irq, NULL); 393 } 394 395 /* check for conflicts with other pnp devices */ 396 pnp_for_each_dev(tdev) { 397 if (tdev == dev) 398 continue; 399 for (i = 0; 400 (tres = pnp_get_resource(tdev, IORESOURCE_IRQ, i)); 401 i++) { 402 if (tres->flags & IORESOURCE_IRQ) { 403 if (cannot_compare(tres->flags)) 404 continue; 405 if (tres->start == *irq) 406 return 0; 407 } 408 } 409 } 410 411 return 1; 412 } 413 414 #ifdef CONFIG_ISA_DMA_API 415 int pnp_check_dma(struct pnp_dev *dev, struct resource *res) 416 { 417 int i; 418 struct pnp_dev *tdev; 419 struct resource *tres; 420 resource_size_t *dma; 421 422 dma = &res->start; 423 424 /* if the resource doesn't exist, don't complain about it */ 425 if (cannot_compare(res->flags)) 426 return 1; 427 428 /* check if the resource is valid */ 429 if (*dma == 4 || *dma > 7) 430 return 0; 431 432 /* check if the resource is reserved */ 433 for (i = 0; i < 8; i++) { 434 if (pnp_reserve_dma[i] == *dma) 435 return 0; 436 } 437 438 /* check for internal conflicts */ 439 for (i = 0; (tres = pnp_get_resource(dev, IORESOURCE_DMA, i)); i++) { 440 if (tres != res && tres->flags & IORESOURCE_DMA) { 441 if (tres->start == *dma) 442 return 0; 443 } 444 } 445 446 /* check if the resource is already in use, skip if the 447 * device is active because it itself may be in use */ 448 if (!dev->active) { 449 if (request_dma(*dma, "pnp")) 450 return 0; 451 free_dma(*dma); 452 } 453 454 /* check for conflicts with other pnp devices */ 455 pnp_for_each_dev(tdev) { 456 if (tdev == dev) 457 continue; 458 for (i = 0; 459 (tres = pnp_get_resource(tdev, IORESOURCE_DMA, i)); 460 i++) { 461 if (tres->flags & IORESOURCE_DMA) { 462 if (cannot_compare(tres->flags)) 463 continue; 464 if (tres->start == *dma) 465 return 0; 466 } 467 } 468 } 469 470 return 1; 471 } 472 #endif /* CONFIG_ISA_DMA_API */ 473 474 unsigned long pnp_resource_type(struct resource *res) 475 { 476 return res->flags & (IORESOURCE_IO | IORESOURCE_MEM | 477 IORESOURCE_IRQ | IORESOURCE_DMA | 478 IORESOURCE_BUS); 479 } 480 481 struct resource *pnp_get_resource(struct pnp_dev *dev, 482 unsigned long type, unsigned int num) 483 { 484 struct pnp_resource *pnp_res; 485 struct resource *res; 486 487 list_for_each_entry(pnp_res, &dev->resources, list) { 488 res = &pnp_res->res; 489 if (pnp_resource_type(res) == type && num-- == 0) 490 return res; 491 } 492 return NULL; 493 } 494 EXPORT_SYMBOL(pnp_get_resource); 495 496 static struct pnp_resource *pnp_new_resource(struct pnp_dev *dev) 497 { 498 struct pnp_resource *pnp_res; 499 500 pnp_res = kzalloc(sizeof(struct pnp_resource), GFP_KERNEL); 501 if (!pnp_res) 502 return NULL; 503 504 list_add_tail(&pnp_res->list, &dev->resources); 505 return pnp_res; 506 } 507 508 struct pnp_resource *pnp_add_resource(struct pnp_dev *dev, 509 struct resource *res) 510 { 511 struct pnp_resource *pnp_res; 512 513 pnp_res = pnp_new_resource(dev); 514 if (!pnp_res) { 515 dev_err(&dev->dev, "can't add resource %pR\n", res); 516 return NULL; 517 } 518 519 pnp_res->res = *res; 520 pnp_res->res.name = dev->name; 521 dev_dbg(&dev->dev, "%pR\n", res); 522 return pnp_res; 523 } 524 525 struct pnp_resource *pnp_add_irq_resource(struct pnp_dev *dev, int irq, 526 int flags) 527 { 528 struct pnp_resource *pnp_res; 529 struct resource *res; 530 531 pnp_res = pnp_new_resource(dev); 532 if (!pnp_res) { 533 dev_err(&dev->dev, "can't add resource for IRQ %d\n", irq); 534 return NULL; 535 } 536 537 res = &pnp_res->res; 538 res->flags = IORESOURCE_IRQ | flags; 539 res->start = irq; 540 res->end = irq; 541 542 dev_printk(KERN_DEBUG, &dev->dev, "%pR\n", res); 543 return pnp_res; 544 } 545 546 struct pnp_resource *pnp_add_dma_resource(struct pnp_dev *dev, int dma, 547 int flags) 548 { 549 struct pnp_resource *pnp_res; 550 struct resource *res; 551 552 pnp_res = pnp_new_resource(dev); 553 if (!pnp_res) { 554 dev_err(&dev->dev, "can't add resource for DMA %d\n", dma); 555 return NULL; 556 } 557 558 res = &pnp_res->res; 559 res->flags = IORESOURCE_DMA | flags; 560 res->start = dma; 561 res->end = dma; 562 563 dev_printk(KERN_DEBUG, &dev->dev, "%pR\n", res); 564 return pnp_res; 565 } 566 567 struct pnp_resource *pnp_add_io_resource(struct pnp_dev *dev, 568 resource_size_t start, 569 resource_size_t end, int flags) 570 { 571 struct pnp_resource *pnp_res; 572 struct resource *res; 573 574 pnp_res = pnp_new_resource(dev); 575 if (!pnp_res) { 576 dev_err(&dev->dev, "can't add resource for IO %#llx-%#llx\n", 577 (unsigned long long) start, 578 (unsigned long long) end); 579 return NULL; 580 } 581 582 res = &pnp_res->res; 583 res->flags = IORESOURCE_IO | flags; 584 res->start = start; 585 res->end = end; 586 587 dev_printk(KERN_DEBUG, &dev->dev, "%pR\n", res); 588 return pnp_res; 589 } 590 591 struct pnp_resource *pnp_add_mem_resource(struct pnp_dev *dev, 592 resource_size_t start, 593 resource_size_t end, int flags) 594 { 595 struct pnp_resource *pnp_res; 596 struct resource *res; 597 598 pnp_res = pnp_new_resource(dev); 599 if (!pnp_res) { 600 dev_err(&dev->dev, "can't add resource for MEM %#llx-%#llx\n", 601 (unsigned long long) start, 602 (unsigned long long) end); 603 return NULL; 604 } 605 606 res = &pnp_res->res; 607 res->flags = IORESOURCE_MEM | flags; 608 res->start = start; 609 res->end = end; 610 611 dev_printk(KERN_DEBUG, &dev->dev, "%pR\n", res); 612 return pnp_res; 613 } 614 615 struct pnp_resource *pnp_add_bus_resource(struct pnp_dev *dev, 616 resource_size_t start, 617 resource_size_t end) 618 { 619 struct pnp_resource *pnp_res; 620 struct resource *res; 621 622 pnp_res = pnp_new_resource(dev); 623 if (!pnp_res) { 624 dev_err(&dev->dev, "can't add resource for BUS %#llx-%#llx\n", 625 (unsigned long long) start, 626 (unsigned long long) end); 627 return NULL; 628 } 629 630 res = &pnp_res->res; 631 res->flags = IORESOURCE_BUS; 632 res->start = start; 633 res->end = end; 634 635 dev_printk(KERN_DEBUG, &dev->dev, "%pR\n", res); 636 return pnp_res; 637 } 638 639 /* 640 * Determine whether the specified resource is a possible configuration 641 * for this device. 642 */ 643 int pnp_possible_config(struct pnp_dev *dev, int type, resource_size_t start, 644 resource_size_t size) 645 { 646 struct pnp_option *option; 647 struct pnp_port *port; 648 struct pnp_mem *mem; 649 struct pnp_irq *irq; 650 struct pnp_dma *dma; 651 652 list_for_each_entry(option, &dev->options, list) { 653 if (option->type != type) 654 continue; 655 656 switch (option->type) { 657 case IORESOURCE_IO: 658 port = &option->u.port; 659 if (port->min == start && port->size == size) 660 return 1; 661 break; 662 case IORESOURCE_MEM: 663 mem = &option->u.mem; 664 if (mem->min == start && mem->size == size) 665 return 1; 666 break; 667 case IORESOURCE_IRQ: 668 irq = &option->u.irq; 669 if (start < PNP_IRQ_NR && 670 test_bit(start, irq->map.bits)) 671 return 1; 672 break; 673 case IORESOURCE_DMA: 674 dma = &option->u.dma; 675 if (dma->map & (1 << start)) 676 return 1; 677 break; 678 } 679 } 680 681 return 0; 682 } 683 EXPORT_SYMBOL(pnp_possible_config); 684 685 int pnp_range_reserved(resource_size_t start, resource_size_t end) 686 { 687 struct pnp_dev *dev; 688 struct pnp_resource *pnp_res; 689 resource_size_t *dev_start, *dev_end; 690 691 pnp_for_each_dev(dev) { 692 list_for_each_entry(pnp_res, &dev->resources, list) { 693 dev_start = &pnp_res->res.start; 694 dev_end = &pnp_res->res.end; 695 if (ranged_conflict(&start, &end, dev_start, dev_end)) 696 return 1; 697 } 698 } 699 return 0; 700 } 701 EXPORT_SYMBOL(pnp_range_reserved); 702 703 /* format is: pnp_reserve_irq=irq1[,irq2] .... */ 704 static int __init pnp_setup_reserve_irq(char *str) 705 { 706 int i; 707 708 for (i = 0; i < 16; i++) 709 if (get_option(&str, &pnp_reserve_irq[i]) != 2) 710 break; 711 return 1; 712 } 713 714 __setup("pnp_reserve_irq=", pnp_setup_reserve_irq); 715 716 /* format is: pnp_reserve_dma=dma1[,dma2] .... */ 717 static int __init pnp_setup_reserve_dma(char *str) 718 { 719 int i; 720 721 for (i = 0; i < 8; i++) 722 if (get_option(&str, &pnp_reserve_dma[i]) != 2) 723 break; 724 return 1; 725 } 726 727 __setup("pnp_reserve_dma=", pnp_setup_reserve_dma); 728 729 /* format is: pnp_reserve_io=io1,size1[,io2,size2] .... */ 730 static int __init pnp_setup_reserve_io(char *str) 731 { 732 int i; 733 734 for (i = 0; i < 16; i++) 735 if (get_option(&str, &pnp_reserve_io[i]) != 2) 736 break; 737 return 1; 738 } 739 740 __setup("pnp_reserve_io=", pnp_setup_reserve_io); 741 742 /* format is: pnp_reserve_mem=mem1,size1[,mem2,size2] .... */ 743 static int __init pnp_setup_reserve_mem(char *str) 744 { 745 int i; 746 747 for (i = 0; i < 16; i++) 748 if (get_option(&str, &pnp_reserve_mem[i]) != 2) 749 break; 750 return 1; 751 } 752 753 __setup("pnp_reserve_mem=", pnp_setup_reserve_mem); 754