1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 * Copyright 2012 Milan Jurik. All rights reserved. 25 */ 26 27 #if defined(DEBUG) 28 #define BUSRA_DEBUG 29 #endif 30 31 /* 32 * This module provides a set of resource management interfaces 33 * to manage bus resources globally in the system. 34 * 35 * The bus nexus drivers are typically responsible to setup resource 36 * maps for the bus resources available for a bus instance. However 37 * this module also provides resource setup functions for PCI bus 38 * (used by both SPARC and X86 platforms) and ISA bus instances (used 39 * only for X86 platforms). 40 */ 41 42 #include <sys/types.h> 43 #include <sys/systm.h> 44 #include <sys/ddi.h> 45 #include <sys/sunddi.h> 46 #include <sys/sunndi.h> 47 #include <sys/ddi_impldefs.h> 48 #include <sys/ndi_impldefs.h> 49 #include <sys/kmem.h> 50 #include <sys/pctypes.h> 51 #include <sys/modctl.h> 52 #include <sys/debug.h> 53 #include <sys/spl.h> 54 #include <sys/pci.h> 55 #include <sys/autoconf.h> 56 57 #if defined(BUSRA_DEBUG) 58 int busra_debug = 0; 59 #define DEBUGPRT \ 60 if (busra_debug) cmn_err 61 62 #else 63 #define DEBUGPRT \ 64 if (0) cmn_err 65 #endif 66 67 68 /* 69 * global mutex that protects the global list of resource maps. 70 */ 71 kmutex_t ra_lock; 72 73 /* 74 * basic resource element 75 */ 76 struct ra_resource { 77 struct ra_resource *ra_next; 78 uint64_t ra_base; 79 uint64_t ra_len; 80 }; 81 82 /* 83 * link list element for the list of dips (and their resource ranges) 84 * for a particular resource type. 85 * ra_rangeset points to the list of resources available 86 * for this type and this dip. 87 */ 88 struct ra_dip_type { 89 struct ra_dip_type *ra_next; 90 struct ra_resource *ra_rangeset; 91 dev_info_t *ra_dip; 92 }; 93 94 95 /* 96 * link list element for list of types resources. Each element 97 * has all resources for a particular type. 98 */ 99 struct ra_type_map { 100 struct ra_type_map *ra_next; 101 struct ra_dip_type *ra_dip_list; 102 char *type; 103 }; 104 105 106 /* 107 * place holder to keep the head of the whole global list. 108 * the address of the first typemap would be stored in it. 109 */ 110 static struct ra_type_map *ra_map_list_head = NULL; 111 112 113 /* 114 * This is the loadable module wrapper. 115 * It is essentially boilerplate so isn't documented 116 */ 117 extern struct mod_ops mod_miscops; 118 119 #ifdef BUSRA_DEBUG 120 void ra_dump_all(char *, dev_info_t *); 121 #endif 122 123 /* internal function prototypes */ 124 static struct ra_dip_type *find_dip_map_resources(dev_info_t *dip, char *type, 125 struct ra_dip_type ***backdip, struct ra_type_map ***backtype, 126 uint32_t flag); 127 static int isnot_pow2(uint64_t value); 128 static int claim_pci_busnum(dev_info_t *dip, void *arg); 129 static int ra_map_exist(dev_info_t *dip, char *type); 130 131 static int pci_get_available_prop(dev_info_t *dip, uint64_t base, 132 uint64_t len, char *busra_type); 133 static int pci_put_available_prop(dev_info_t *dip, uint64_t base, 134 uint64_t len, char *busra_type); 135 static uint32_t pci_type_ra2pci(char *type); 136 static boolean_t is_pcie_fabric(dev_info_t *dip); 137 138 #define PCI_ADDR_TYPE_MASK (PCI_REG_ADDR_M | PCI_REG_PF_M) 139 #define PCI_ADDR_TYPE_INVAL 0xffffffff 140 141 #define RA_INSERT(prev, el) \ 142 el->ra_next = *prev; \ 143 *prev = el; 144 145 #define RA_REMOVE(prev, el) \ 146 *prev = el->ra_next; 147 148 149 static struct modlmisc modlmisc = { 150 &mod_miscops, /* Type of module. This one is a module */ 151 "Bus Resource Allocator (BUSRA)", /* Name of the module. */ 152 }; 153 154 static struct modlinkage modlinkage = { 155 MODREV_1, (void *)&modlmisc, NULL 156 }; 157 158 int 159 _init() 160 { 161 int ret; 162 163 mutex_init(&ra_lock, NULL, MUTEX_DRIVER, 164 (void *)(intptr_t)__ipltospl(SPL7 - 1)); 165 if ((ret = mod_install(&modlinkage)) != 0) { 166 mutex_destroy(&ra_lock); 167 } 168 return (ret); 169 } 170 171 int 172 _fini() 173 { 174 int ret; 175 176 mutex_enter(&ra_lock); 177 178 if (ra_map_list_head != NULL) { 179 mutex_exit(&ra_lock); 180 return (EBUSY); 181 } 182 183 ret = mod_remove(&modlinkage); 184 185 mutex_exit(&ra_lock); 186 187 if (ret == 0) 188 mutex_destroy(&ra_lock); 189 190 return (ret); 191 } 192 193 int 194 _info(struct modinfo *modinfop) 195 196 { 197 return (mod_info(&modlinkage, modinfop)); 198 } 199 200 /* 201 * set up an empty resource map for a given type and dip 202 */ 203 int 204 ndi_ra_map_setup(dev_info_t *dip, char *type) 205 { 206 struct ra_type_map *typemapp; 207 struct ra_dip_type *dipmap; 208 struct ra_dip_type **backdip; 209 struct ra_type_map **backtype; 210 211 212 mutex_enter(&ra_lock); 213 214 dipmap = find_dip_map_resources(dip, type, &backdip, &backtype, 0); 215 216 if (dipmap == NULL) { 217 if (backtype == NULL) { 218 typemapp = (struct ra_type_map *) 219 kmem_zalloc(sizeof (*typemapp), KM_SLEEP); 220 typemapp->type = (char *)kmem_zalloc(strlen(type) + 1, 221 KM_SLEEP); 222 (void) strcpy(typemapp->type, type); 223 RA_INSERT(&ra_map_list_head, typemapp); 224 } else { 225 typemapp = *backtype; 226 } 227 if (backdip == NULL) { 228 /* allocate and insert in list of dips for this type */ 229 dipmap = (struct ra_dip_type *) 230 kmem_zalloc(sizeof (*dipmap), KM_SLEEP); 231 dipmap->ra_dip = dip; 232 RA_INSERT(&typemapp->ra_dip_list, dipmap); 233 } 234 } 235 236 mutex_exit(&ra_lock); 237 return (NDI_SUCCESS); 238 } 239 240 /* 241 * destroys a resource map for a given dip and type 242 */ 243 int 244 ndi_ra_map_destroy(dev_info_t *dip, char *type) 245 { 246 struct ra_dip_type *dipmap; 247 struct ra_dip_type **backdip; 248 struct ra_type_map **backtype, *typemap; 249 struct ra_resource *range; 250 251 mutex_enter(&ra_lock); 252 dipmap = find_dip_map_resources(dip, type, &backdip, &backtype, 0); 253 254 if (dipmap == NULL) { 255 mutex_exit(&ra_lock); 256 return (NDI_FAILURE); 257 } 258 259 /* 260 * destroy all resources for this dip 261 * remove dip from type list 262 */ 263 ASSERT((backdip != NULL) && (backtype != NULL)); 264 while (dipmap->ra_rangeset != NULL) { 265 range = dipmap->ra_rangeset; 266 RA_REMOVE(&dipmap->ra_rangeset, range); 267 kmem_free((caddr_t)range, sizeof (*range)); 268 } 269 /* remove from dip list */ 270 RA_REMOVE(backdip, dipmap); 271 kmem_free((caddr_t)dipmap, sizeof (*dipmap)); 272 if ((*backtype)->ra_dip_list == NULL) { 273 /* 274 * This was the last dip with this resource type. 275 * Remove the type from the global list. 276 */ 277 typemap = *backtype; 278 RA_REMOVE(backtype, (*backtype)); 279 kmem_free((caddr_t)typemap->type, strlen(typemap->type) + 1); 280 kmem_free((caddr_t)typemap, sizeof (*typemap)); 281 } 282 283 mutex_exit(&ra_lock); 284 return (NDI_SUCCESS); 285 } 286 287 static int 288 ra_map_exist(dev_info_t *dip, char *type) 289 { 290 struct ra_dip_type **backdip; 291 struct ra_type_map **backtype; 292 293 mutex_enter(&ra_lock); 294 if (find_dip_map_resources(dip, type, &backdip, &backtype, 0) == NULL) { 295 mutex_exit(&ra_lock); 296 return (NDI_FAILURE); 297 } 298 299 mutex_exit(&ra_lock); 300 return (NDI_SUCCESS); 301 } 302 /* 303 * Find a dip map for the specified type, if NDI_RA_PASS will go up on dev tree 304 * if found, backdip and backtype will be updated to point to the previous 305 * dip in the list and previous type for this dip in the list. 306 * If no such type at all in the resource list both backdip and backtype 307 * will be null. If the type found but no dip, back dip will be null. 308 */ 309 310 static struct ra_dip_type * 311 find_dip_map_resources(dev_info_t *dip, char *type, 312 struct ra_dip_type ***backdip, struct ra_type_map ***backtype, 313 uint32_t flag) 314 { 315 struct ra_type_map **prevmap; 316 struct ra_dip_type *dipmap, **prevdip; 317 318 ASSERT(mutex_owned(&ra_lock)); 319 prevdip = NULL; 320 dipmap = NULL; 321 prevmap = &ra_map_list_head; 322 323 while (*prevmap) { 324 if (strcmp((*prevmap)->type, type) == 0) 325 break; 326 prevmap = &(*prevmap)->ra_next; 327 } 328 329 if (*prevmap) { 330 for (; dip != NULL; dip = ddi_get_parent(dip)) { 331 prevdip = &(*prevmap)->ra_dip_list; 332 dipmap = *prevdip; 333 334 while (dipmap) { 335 if (dipmap->ra_dip == dip) 336 break; 337 prevdip = &dipmap->ra_next; 338 dipmap = dipmap->ra_next; 339 } 340 341 if (dipmap != NULL) { 342 /* found it */ 343 break; 344 } 345 346 if (!(flag & NDI_RA_PASS)) { 347 break; 348 } 349 } 350 } 351 352 *backtype = (*prevmap == NULL) ? NULL: prevmap; 353 *backdip = (dipmap == NULL) ? NULL: prevdip; 354 355 return (dipmap); 356 } 357 358 int 359 ndi_ra_free(dev_info_t *dip, uint64_t base, uint64_t len, char *type, 360 uint32_t flag) 361 { 362 struct ra_dip_type *dipmap; 363 struct ra_resource *newmap, *overlapmap, *oldmap = NULL; 364 struct ra_resource *mapp, **backp; 365 uint64_t newend, mapend; 366 struct ra_dip_type **backdip; 367 struct ra_type_map **backtype; 368 369 if (len == 0) { 370 return (NDI_SUCCESS); 371 } 372 373 mutex_enter(&ra_lock); 374 375 if ((dipmap = find_dip_map_resources(dip, type, &backdip, &backtype, 376 flag)) == NULL) { 377 mutex_exit(&ra_lock); 378 return (NDI_FAILURE); 379 } 380 381 mapp = dipmap->ra_rangeset; 382 backp = &dipmap->ra_rangeset; 383 384 /* now find where range lies and fix things up */ 385 newend = base + len; 386 for (; mapp != NULL; backp = &(mapp->ra_next), mapp = mapp->ra_next) { 387 mapend = mapp->ra_base + mapp->ra_len; 388 389 /* check for overlap first */ 390 if ((base <= mapp->ra_base && newend > mapp->ra_base) || 391 (base > mapp->ra_base && base < mapend)) { 392 /* overlap with mapp */ 393 overlapmap = mapp; 394 goto overlap; 395 } else if ((base == mapend && mapp->ra_next) && 396 (newend > mapp->ra_next->ra_base)) { 397 /* overlap with mapp->ra_next */ 398 overlapmap = mapp->ra_next; 399 goto overlap; 400 } 401 402 if (newend == mapp->ra_base) { 403 /* simple - on front */ 404 mapp->ra_base = base; 405 mapp->ra_len += len; 406 /* 407 * don't need to check if it merges with 408 * previous since that would match on on end 409 */ 410 break; 411 } else if (base == mapend) { 412 /* simple - on end */ 413 mapp->ra_len += len; 414 if (mapp->ra_next && 415 (newend == mapp->ra_next->ra_base)) { 416 /* merge with next node */ 417 oldmap = mapp->ra_next; 418 mapp->ra_len += oldmap->ra_len; 419 RA_REMOVE(&mapp->ra_next, oldmap); 420 kmem_free((caddr_t)oldmap, sizeof (*oldmap)); 421 } 422 break; 423 } else if (base < mapp->ra_base) { 424 /* somewhere in between so just an insert */ 425 newmap = (struct ra_resource *) 426 kmem_zalloc(sizeof (*newmap), KM_SLEEP); 427 newmap->ra_base = base; 428 newmap->ra_len = len; 429 RA_INSERT(backp, newmap); 430 break; 431 } 432 } 433 if (mapp == NULL) { 434 /* stick on end */ 435 newmap = (struct ra_resource *) 436 kmem_zalloc(sizeof (*newmap), KM_SLEEP); 437 newmap->ra_base = base; 438 newmap->ra_len = len; 439 RA_INSERT(backp, newmap); 440 } 441 442 mutex_exit(&ra_lock); 443 444 /* 445 * Update dip's "available" property, adding this piece of 446 * resource to the pool. 447 */ 448 (void) pci_put_available_prop(dipmap->ra_dip, base, len, type); 449 done: 450 return (NDI_SUCCESS); 451 452 overlap: 453 /* 454 * Bad free may happen on some x86 platforms with BIOS exporting 455 * incorrect resource maps. The system is otherwise functioning 456 * normally. We send such messages to syslog only. 457 */ 458 cmn_err(CE_NOTE, "!ndi_ra_free: bad free, dip %p, resource type %s \n", 459 (void *)dip, type); 460 cmn_err(CE_NOTE, "!ndi_ra_free: freeing base 0x%" PRIx64 ", len 0x%" 461 PRIX64 " overlaps with existing resource base 0x%" PRIx64 462 ", len 0x%" PRIx64 "\n", base, len, overlapmap->ra_base, 463 overlapmap->ra_len); 464 465 mutex_exit(&ra_lock); 466 return (NDI_FAILURE); 467 } 468 469 /* check to see if value is power of 2 or not. */ 470 static int 471 isnot_pow2(uint64_t value) 472 { 473 uint32_t low; 474 uint32_t hi; 475 476 low = value & 0xffffffff; 477 hi = value >> 32; 478 479 /* 480 * ddi_ffs and ddi_fls gets long values, so in 32bit environment 481 * won't work correctly for 64bit values 482 */ 483 if ((ddi_ffs(low) == ddi_fls(low)) && 484 (ddi_ffs(hi) == ddi_fls(hi))) 485 return (0); 486 return (1); 487 } 488 489 static void 490 adjust_link(struct ra_resource **backp, struct ra_resource *mapp, 491 uint64_t base, uint64_t len) 492 { 493 struct ra_resource *newmap; 494 uint64_t newlen; 495 496 if (base != mapp->ra_base) { 497 /* in the middle or end */ 498 newlen = base - mapp->ra_base; 499 if ((mapp->ra_len - newlen) == len) { 500 /* on the end */ 501 mapp->ra_len = newlen; 502 } else { 503 /* in the middle */ 504 newmap = (struct ra_resource *) 505 kmem_zalloc(sizeof (*newmap), KM_SLEEP); 506 newmap->ra_base = base + len; 507 newmap->ra_len = mapp->ra_len - (len + newlen); 508 mapp->ra_len = newlen; 509 RA_INSERT(&(mapp->ra_next), newmap); 510 } 511 } else { 512 /* at the beginning */ 513 mapp->ra_base += len; 514 mapp->ra_len -= len; 515 if (mapp->ra_len == 0) { 516 /* remove the whole node */ 517 RA_REMOVE(backp, mapp); 518 kmem_free((caddr_t)mapp, sizeof (*mapp)); 519 } 520 } 521 } 522 523 int 524 ndi_ra_alloc(dev_info_t *dip, ndi_ra_request_t *req, uint64_t *retbasep, 525 uint64_t *retlenp, char *type, uint32_t flag) 526 { 527 struct ra_dip_type *dipmap; 528 struct ra_resource *mapp, **backp, **backlargestp; 529 uint64_t mask = 0; 530 uint64_t len, remlen, largestbase, largestlen; 531 uint64_t base, oldbase, lower, upper; 532 struct ra_dip_type **backdip; 533 struct ra_type_map **backtype; 534 int rval = NDI_FAILURE; 535 536 537 len = req->ra_len; 538 539 if (req->ra_flags & NDI_RA_ALIGN_SIZE) { 540 if (isnot_pow2(req->ra_len)) { 541 DEBUGPRT(CE_WARN, "ndi_ra_alloc: bad length(pow2) 0x%" 542 PRIx64, req->ra_len); 543 *retbasep = 0; 544 *retlenp = 0; 545 return (NDI_FAILURE); 546 } 547 } 548 549 mask = (req->ra_flags & NDI_RA_ALIGN_SIZE) ? (len - 1) : 550 req->ra_align_mask; 551 552 553 mutex_enter(&ra_lock); 554 dipmap = find_dip_map_resources(dip, type, &backdip, &backtype, flag); 555 if ((dipmap == NULL) || ((mapp = dipmap->ra_rangeset) == NULL)) { 556 mutex_exit(&ra_lock); 557 DEBUGPRT(CE_CONT, "ndi_ra_alloc no map found for this type\n"); 558 return (NDI_FAILURE); 559 } 560 561 DEBUGPRT(CE_CONT, "ndi_ra_alloc: mapp = %p len=%" PRIx64 ", mask=%" 562 PRIx64 "\n", (void *)mapp, len, mask); 563 564 backp = &(dipmap->ra_rangeset); 565 backlargestp = NULL; 566 largestbase = 0; 567 largestlen = 0; 568 569 lower = 0; 570 upper = ~(uint64_t)0; 571 572 if (req->ra_flags & NDI_RA_ALLOC_BOUNDED) { 573 /* bounded so skip to first possible */ 574 lower = req->ra_boundbase; 575 upper = req->ra_boundlen + lower; 576 if ((upper == 0) || (upper < req->ra_boundlen)) 577 upper = ~(uint64_t)0; 578 DEBUGPRT(CE_CONT, "ndi_ra_alloc: ra_len = %" PRIx64 ", len = %" 579 PRIx64 " ra_base=%" PRIx64 ", mask=%" PRIx64 580 "\n", mapp->ra_len, len, mapp->ra_base, mask); 581 for (; mapp != NULL && (mapp->ra_base + mapp->ra_len) < lower; 582 backp = &(mapp->ra_next), mapp = mapp->ra_next) { 583 if (((mapp->ra_len + mapp->ra_base) == 0) || 584 ((mapp->ra_len + mapp->ra_base) < mapp->ra_len)) 585 /* 586 * This elements end goes beyond max uint64_t. 587 * potential candidate, check end against lower 588 * would not be precise. 589 */ 590 break; 591 592 DEBUGPRT(CE_CONT, " ra_len = %" PRIx64 ", ra_base=%" 593 PRIx64 "\n", mapp->ra_len, mapp->ra_base); 594 } 595 596 } 597 598 if (!(req->ra_flags & NDI_RA_ALLOC_SPECIFIED)) { 599 /* first fit - not user specified */ 600 DEBUGPRT(CE_CONT, "ndi_ra_alloc(unspecified request)" 601 "lower=%" PRIx64 ", upper=%" PRIx64 "\n", lower, upper); 602 for (; mapp != NULL && mapp->ra_base <= upper; 603 backp = &(mapp->ra_next), mapp = mapp->ra_next) { 604 605 DEBUGPRT(CE_CONT, "ndi_ra_alloc: ra_len = %" PRIx64 606 ", len = %" PRIx64 "", mapp->ra_len, len); 607 base = mapp->ra_base; 608 if (base < lower) { 609 base = lower; 610 DEBUGPRT(CE_CONT, "\tbase=%" PRIx64 611 ", ra_base=%" PRIx64 ", mask=%" PRIx64, 612 base, mapp->ra_base, mask); 613 } 614 615 if ((base & mask) != 0) { 616 oldbase = base; 617 /* 618 * failed a critical constraint 619 * adjust and see if it still fits 620 */ 621 base = base & ~mask; 622 base += (mask + 1); 623 DEBUGPRT(CE_CONT, "\tnew base=%" PRIx64 "\n", 624 base); 625 626 /* 627 * Check to see if the new base is past 628 * the end of the resource. 629 */ 630 if (base >= (oldbase + mapp->ra_len + 1)) { 631 continue; 632 } 633 } 634 635 if (req->ra_flags & NDI_RA_ALLOC_PARTIAL_OK) { 636 if ((upper - mapp->ra_base) < mapp->ra_len) 637 remlen = upper - base; 638 else 639 remlen = mapp->ra_len - 640 (base - mapp->ra_base); 641 642 if ((backlargestp == NULL) || 643 (largestlen < remlen)) { 644 645 backlargestp = backp; 646 largestbase = base; 647 largestlen = remlen; 648 } 649 } 650 651 if (mapp->ra_len >= len) { 652 /* a candidate -- apply constraints */ 653 if ((len > (mapp->ra_len - 654 (base - mapp->ra_base))) || 655 ((len - 1 + base) > upper)) { 656 continue; 657 } 658 659 /* we have a fit */ 660 661 DEBUGPRT(CE_CONT, "\thave a fit\n"); 662 663 adjust_link(backp, mapp, base, len); 664 rval = NDI_SUCCESS; 665 break; 666 667 } 668 } 669 } else { 670 /* want an exact value/fit */ 671 base = req->ra_addr; 672 len = req->ra_len; 673 for (; mapp != NULL && mapp->ra_base <= upper; 674 backp = &(mapp->ra_next), mapp = mapp->ra_next) { 675 if (base >= mapp->ra_base && 676 ((base - mapp->ra_base) < mapp->ra_len)) { 677 /* 678 * This is the node with he requested base in 679 * its range 680 */ 681 if ((len > mapp->ra_len) || 682 (base - mapp->ra_base > 683 mapp->ra_len - len)) { 684 /* length requirement not satisfied */ 685 if (req->ra_flags & 686 NDI_RA_ALLOC_PARTIAL_OK) { 687 if ((upper - mapp->ra_base) 688 < mapp->ra_len) 689 remlen = upper - base; 690 else 691 remlen = 692 mapp->ra_len - 693 (base - 694 mapp->ra_base); 695 } 696 backlargestp = backp; 697 largestbase = base; 698 largestlen = remlen; 699 base = 0; 700 } else { 701 /* We have a match */ 702 adjust_link(backp, mapp, base, len); 703 rval = NDI_SUCCESS; 704 } 705 break; 706 } 707 } 708 } 709 710 if ((rval != NDI_SUCCESS) && 711 (req->ra_flags & NDI_RA_ALLOC_PARTIAL_OK) && 712 (backlargestp != NULL)) { 713 adjust_link(backlargestp, *backlargestp, largestbase, 714 largestlen); 715 716 base = largestbase; 717 len = largestlen; 718 rval = NDI_RA_PARTIAL_REQ; 719 } 720 721 mutex_exit(&ra_lock); 722 723 if (rval == NDI_FAILURE) { 724 *retbasep = 0; 725 *retlenp = 0; 726 } else { 727 *retbasep = base; 728 *retlenp = len; 729 } 730 731 /* 732 * Update dip's "available" property, substract this piece of 733 * resource from the pool. 734 */ 735 if ((rval == NDI_SUCCESS) || (rval == NDI_RA_PARTIAL_REQ)) 736 (void) pci_get_available_prop(dipmap->ra_dip, 737 *retbasep, *retlenp, type); 738 739 return (rval); 740 } 741 742 /* 743 * isa_resource_setup 744 * check for /used-resources and initialize 745 * based on info there. If no /used-resources, 746 * fail. 747 */ 748 int 749 isa_resource_setup() 750 { 751 dev_info_t *used, *usedpdip; 752 /* 753 * note that at this time bootconf creates 32 bit properties for 754 * io-space and device-memory 755 */ 756 struct iorange { 757 uint32_t base; 758 uint32_t len; 759 } *iorange; 760 struct memrange { 761 uint32_t base; 762 uint32_t len; 763 } *memrange; 764 uint32_t *irq; 765 int proplen; 766 int i, len; 767 int maxrange; 768 ndi_ra_request_t req; 769 uint64_t retbase; 770 uint64_t retlen; 771 772 used = ddi_find_devinfo("used-resources", -1, 0); 773 if (used == NULL) { 774 DEBUGPRT(CE_CONT, 775 "isa_resource_setup: used-resources not found"); 776 return (NDI_FAILURE); 777 } 778 779 /* 780 * initialize to all resources being present 781 * and then remove the ones in use. 782 */ 783 784 usedpdip = ddi_root_node(); 785 786 DEBUGPRT(CE_CONT, "isa_resource_setup: used = %p usedpdip = %p\n", 787 (void *)used, (void *)usedpdip); 788 789 if (ndi_ra_map_setup(usedpdip, NDI_RA_TYPE_IO) == NDI_FAILURE) { 790 return (NDI_FAILURE); 791 } 792 793 /* initialize io space, highest end base is 0xffff */ 794 /* note that length is highest addr + 1 since starts from 0 */ 795 796 (void) ndi_ra_free(usedpdip, 0, 0xffff + 1, NDI_RA_TYPE_IO, 0); 797 798 if (ddi_getlongprop(DDI_DEV_T_ANY, used, DDI_PROP_DONTPASS, 799 "io-space", (caddr_t)&iorange, &proplen) == DDI_SUCCESS) { 800 maxrange = proplen / sizeof (struct iorange); 801 /* remove the "used" I/O resources */ 802 for (i = 0; i < maxrange; i++) { 803 bzero((caddr_t)&req, sizeof (req)); 804 req.ra_addr = (uint64_t)iorange[i].base; 805 req.ra_len = (uint64_t)iorange[i].len; 806 req.ra_flags = NDI_RA_ALLOC_SPECIFIED; 807 (void) ndi_ra_alloc(usedpdip, &req, &retbase, &retlen, 808 NDI_RA_TYPE_IO, 0); 809 } 810 811 kmem_free((caddr_t)iorange, proplen); 812 } 813 814 if (ndi_ra_map_setup(usedpdip, NDI_RA_TYPE_MEM) == NDI_FAILURE) { 815 return (NDI_FAILURE); 816 } 817 /* initialize memory space where highest end base is 0xffffffff */ 818 /* note that length is highest addr + 1 since starts from 0 */ 819 (void) ndi_ra_free(usedpdip, 0, ((uint64_t)((uint32_t)~0)) + 1, 820 NDI_RA_TYPE_MEM, 0); 821 822 if (ddi_getlongprop(DDI_DEV_T_ANY, used, DDI_PROP_DONTPASS, 823 "device-memory", (caddr_t)&memrange, &proplen) == DDI_SUCCESS) { 824 maxrange = proplen / sizeof (struct memrange); 825 /* remove the "used" memory resources */ 826 for (i = 0; i < maxrange; i++) { 827 bzero((caddr_t)&req, sizeof (req)); 828 req.ra_addr = (uint64_t)memrange[i].base; 829 req.ra_len = (uint64_t)memrange[i].len; 830 req.ra_flags = NDI_RA_ALLOC_SPECIFIED; 831 (void) ndi_ra_alloc(usedpdip, &req, &retbase, &retlen, 832 NDI_RA_TYPE_MEM, 0); 833 } 834 835 kmem_free((caddr_t)memrange, proplen); 836 } 837 838 if (ndi_ra_map_setup(usedpdip, NDI_RA_TYPE_INTR) == NDI_FAILURE) { 839 return (NDI_FAILURE); 840 } 841 842 /* initialize the interrupt space */ 843 (void) ndi_ra_free(usedpdip, 0, 16, NDI_RA_TYPE_INTR, 0); 844 845 #if defined(__i386) || defined(__amd64) 846 bzero(&req, sizeof (req)); 847 req.ra_addr = 2; /* 2 == 9 so never allow */ 848 req.ra_len = 1; 849 req.ra_flags = NDI_RA_ALLOC_SPECIFIED; 850 (void) ndi_ra_alloc(usedpdip, &req, &retbase, &retlen, 851 NDI_RA_TYPE_INTR, 0); 852 #endif 853 854 if (ddi_getlongprop(DDI_DEV_T_ANY, used, DDI_PROP_DONTPASS, 855 "interrupts", (caddr_t)&irq, &proplen) == DDI_SUCCESS) { 856 /* Initialize available interrupts by negating the used */ 857 len = (proplen / sizeof (uint32_t)); 858 for (i = 0; i < len; i++) { 859 bzero((caddr_t)&req, sizeof (req)); 860 req.ra_addr = (uint64_t)irq[i]; 861 req.ra_len = 1; 862 req.ra_flags = NDI_RA_ALLOC_SPECIFIED; 863 (void) ndi_ra_alloc(usedpdip, &req, &retbase, &retlen, 864 NDI_RA_TYPE_INTR, 0); 865 } 866 kmem_free((caddr_t)irq, proplen); 867 } 868 869 #ifdef BUSRA_DEBUG 870 if (busra_debug) { 871 (void) ra_dump_all(NULL, usedpdip); 872 } 873 #endif 874 return (NDI_SUCCESS); 875 876 } 877 878 #ifdef BUSRA_DEBUG 879 void 880 ra_dump_all(char *type, dev_info_t *dip) 881 { 882 883 struct ra_type_map *typemap; 884 struct ra_dip_type *dipmap; 885 struct ra_resource *res; 886 887 typemap = (struct ra_type_map *)ra_map_list_head; 888 889 for (; typemap != NULL; typemap = typemap->ra_next) { 890 if (type != NULL) { 891 if (strcmp(typemap->type, type) != 0) 892 continue; 893 } 894 cmn_err(CE_CONT, "type is %s\n", typemap->type); 895 for (dipmap = typemap->ra_dip_list; dipmap != NULL; 896 dipmap = dipmap->ra_next) { 897 if (dip != NULL) { 898 if ((dipmap->ra_dip) != dip) 899 continue; 900 } 901 cmn_err(CE_CONT, " dip is %p\n", 902 (void *)dipmap->ra_dip); 903 for (res = dipmap->ra_rangeset; res != NULL; 904 res = res->ra_next) { 905 cmn_err(CE_CONT, "\t range is %" PRIx64 906 " %" PRIx64 "\n", res->ra_base, 907 res->ra_len); 908 } 909 if (dip != NULL) 910 break; 911 } 912 if (type != NULL) 913 break; 914 } 915 } 916 #endif 917 918 struct bus_range { /* 1275 "bus-range" property definition */ 919 uint32_t lo; 920 uint32_t hi; 921 } pci_bus_range; 922 923 struct busnum_ctrl { 924 int rv; 925 dev_info_t *dip; 926 struct bus_range *range; 927 }; 928 929 930 /* 931 * Setup resource map for the pci bus node based on the "available" 932 * property and "bus-range" property. 933 */ 934 int 935 pci_resource_setup(dev_info_t *dip) 936 { 937 pci_regspec_t *regs; 938 int rlen, rcount, i; 939 char bus_type[16] = "(unknown)"; 940 int len; 941 struct busnum_ctrl ctrl; 942 int circular_count; 943 int rval = NDI_SUCCESS; 944 945 /* 946 * If this is a pci bus node then look for "available" property 947 * to find the available resources on this bus. 948 */ 949 len = sizeof (bus_type); 950 if (ddi_prop_op(DDI_DEV_T_ANY, dip, PROP_LEN_AND_VAL_BUF, 951 DDI_PROP_CANSLEEP | DDI_PROP_DONTPASS, "device_type", 952 (caddr_t)&bus_type, &len) != DDI_SUCCESS) 953 return (NDI_FAILURE); 954 955 /* it is not a pci/pci-ex bus type */ 956 if ((strcmp(bus_type, "pci") != 0) && (strcmp(bus_type, "pciex") != 0)) 957 return (NDI_FAILURE); 958 959 /* 960 * The pci-hotplug project addresses adding the call 961 * to pci_resource_setup from pci nexus driver. 962 * However that project would initially be only for x86, 963 * so for sparc pcmcia-pci support we still need to call 964 * pci_resource_setup in pcic driver. Once all pci nexus drivers 965 * are updated to call pci_resource_setup this portion of the 966 * code would really become an assert to make sure this 967 * function is not called for the same dip twice. 968 */ 969 /* 970 * Another user for the check below is hotplug PCI/PCIe bridges. 971 * 972 * For PCI/PCIE devices under a PCIE hierarchy, ndi_ra_alloc/free 973 * will update the devinfo node's "available" property, to reflect 974 * the fact that a piece of resource has been removed/added to 975 * a devinfo node. 976 * During probe of a new PCI bridge in the hotplug case, PCI 977 * configurator firstly allocates maximum MEM/IO from its parent, 978 * then calls ndi_ra_free() to use these resources to setup busra 979 * pool for the new bridge, as well as adding these resources to 980 * the "available" property of the new devinfo node. Then configu- 981 * rator will attach driver for the bridge before probing its 982 * children, and the bridge driver will then initialize its hotplug 983 * contollers (if it supports hotplug) and HPC driver will call 984 * this function to setup the busra pool, but the resource pool 985 * has already been setup at the first of pcicfg_probe_bridge(), 986 * thus we need the check below to return directly in this case. 987 * Otherwise the ndi_ra_free() below will see overlapping resources. 988 */ 989 { 990 if (ra_map_exist(dip, NDI_RA_TYPE_MEM) == NDI_SUCCESS) { 991 return (NDI_FAILURE); 992 } 993 } 994 995 996 /* 997 * Create empty resource maps first. 998 * 999 * NOTE: If all the allocated resources are already assigned to 1000 * device(s) in the hot plug slot then "available" property may not 1001 * be present. But, subsequent hot plug operation may unconfigure 1002 * the device in the slot and try to free up it's resources. So, 1003 * at the minimum we should create empty maps here. 1004 */ 1005 if (ndi_ra_map_setup(dip, NDI_RA_TYPE_MEM) == NDI_FAILURE) { 1006 return (NDI_FAILURE); 1007 } 1008 1009 if (ndi_ra_map_setup(dip, NDI_RA_TYPE_IO) == NDI_FAILURE) { 1010 return (NDI_FAILURE); 1011 } 1012 1013 if (ndi_ra_map_setup(dip, NDI_RA_TYPE_PCI_BUSNUM) == NDI_FAILURE) { 1014 return (NDI_FAILURE); 1015 } 1016 1017 if (ndi_ra_map_setup(dip, NDI_RA_TYPE_PCI_PREFETCH_MEM) == 1018 NDI_FAILURE) { 1019 return (NDI_FAILURE); 1020 } 1021 1022 /* read the "available" property if it is available */ 1023 if (ddi_getlongprop(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, 1024 "available", (caddr_t)®s, &rlen) == DDI_SUCCESS) { 1025 /* 1026 * Remove "available" property as the entries will be 1027 * re-created in ndi_ra_free() below, note prom based 1028 * property will not be removed. But in ndi_ra_free() 1029 * we'll be creating non prom based property entries. 1030 */ 1031 (void) ndi_prop_remove(DDI_DEV_T_NONE, dip, "available"); 1032 /* 1033 * create the available resource list for both memory and 1034 * io space 1035 */ 1036 rcount = rlen / sizeof (pci_regspec_t); 1037 for (i = 0; i < rcount; i++) { 1038 switch (PCI_REG_ADDR_G(regs[i].pci_phys_hi)) { 1039 case PCI_REG_ADDR_G(PCI_ADDR_MEM32): 1040 (void) ndi_ra_free(dip, 1041 (uint64_t)regs[i].pci_phys_low, 1042 (uint64_t)regs[i].pci_size_low, 1043 (regs[i].pci_phys_hi & PCI_REG_PF_M) ? 1044 NDI_RA_TYPE_PCI_PREFETCH_MEM : 1045 NDI_RA_TYPE_MEM, 1046 0); 1047 break; 1048 case PCI_REG_ADDR_G(PCI_ADDR_MEM64): 1049 (void) ndi_ra_free(dip, 1050 ((uint64_t)(regs[i].pci_phys_mid) << 32) | 1051 ((uint64_t)(regs[i].pci_phys_low)), 1052 ((uint64_t)(regs[i].pci_size_hi) << 32) | 1053 ((uint64_t)(regs[i].pci_size_low)), 1054 (regs[i].pci_phys_hi & PCI_REG_PF_M) ? 1055 NDI_RA_TYPE_PCI_PREFETCH_MEM : 1056 NDI_RA_TYPE_MEM, 1057 0); 1058 break; 1059 case PCI_REG_ADDR_G(PCI_ADDR_IO): 1060 (void) ndi_ra_free(dip, 1061 (uint64_t)regs[i].pci_phys_low, 1062 (uint64_t)regs[i].pci_size_low, 1063 NDI_RA_TYPE_IO, 1064 0); 1065 break; 1066 case PCI_REG_ADDR_G(PCI_ADDR_CONFIG): 1067 break; 1068 default: 1069 cmn_err(CE_WARN, 1070 "pci_resource_setup: bad addr type: %x\n", 1071 PCI_REG_ADDR_G(regs[i].pci_phys_hi)); 1072 break; 1073 } 1074 } 1075 kmem_free(regs, rlen); 1076 } 1077 1078 /* 1079 * update resource map for available bus numbers if the node 1080 * has available-bus-range or bus-range property. 1081 */ 1082 len = sizeof (struct bus_range); 1083 if (ddi_getlongprop_buf(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, 1084 "available-bus-range", (caddr_t)&pci_bus_range, &len) == 1085 DDI_SUCCESS) { 1086 /* 1087 * Add bus numbers in the range to the free list. 1088 */ 1089 (void) ndi_ra_free(dip, (uint64_t)pci_bus_range.lo, 1090 (uint64_t)pci_bus_range.hi - (uint64_t)pci_bus_range.lo + 1091 1, NDI_RA_TYPE_PCI_BUSNUM, 0); 1092 } else { 1093 /* 1094 * We don't have an available-bus-range property. If, instead, 1095 * we have a bus-range property we add all the bus numbers 1096 * in that range to the free list but we must then scan 1097 * for pci-pci bridges on this bus to find out the if there 1098 * are any of those bus numbers already in use. If so, we can 1099 * reclaim them. 1100 */ 1101 len = sizeof (struct bus_range); 1102 if (ddi_getlongprop_buf(DDI_DEV_T_ANY, dip, 1103 DDI_PROP_DONTPASS, "bus-range", (caddr_t)&pci_bus_range, 1104 &len) == DDI_SUCCESS) { 1105 if (pci_bus_range.lo != pci_bus_range.hi) { 1106 /* 1107 * Add bus numbers other than the secondary 1108 * bus number to the free list. 1109 */ 1110 (void) ndi_ra_free(dip, 1111 (uint64_t)pci_bus_range.lo + 1, 1112 (uint64_t)pci_bus_range.hi - 1113 (uint64_t)pci_bus_range.lo, 1114 NDI_RA_TYPE_PCI_BUSNUM, 0); 1115 1116 /* scan for pci-pci bridges */ 1117 ctrl.rv = DDI_SUCCESS; 1118 ctrl.dip = dip; 1119 ctrl.range = &pci_bus_range; 1120 ndi_devi_enter(dip, &circular_count); 1121 ddi_walk_devs(ddi_get_child(dip), 1122 claim_pci_busnum, (void *)&ctrl); 1123 ndi_devi_exit(dip, circular_count); 1124 if (ctrl.rv != DDI_SUCCESS) { 1125 /* failed to create the map */ 1126 (void) ndi_ra_map_destroy(dip, 1127 NDI_RA_TYPE_PCI_BUSNUM); 1128 rval = NDI_FAILURE; 1129 } 1130 } 1131 } 1132 } 1133 1134 #ifdef BUSRA_DEBUG 1135 if (busra_debug) { 1136 (void) ra_dump_all(NULL, dip); 1137 } 1138 #endif 1139 1140 return (rval); 1141 } 1142 1143 /* 1144 * If the device is a PCI bus device (i.e bus-range property exists) then 1145 * claim the bus numbers used by the device from the specified bus 1146 * resource map. 1147 */ 1148 static int 1149 claim_pci_busnum(dev_info_t *dip, void *arg) 1150 { 1151 struct bus_range pci_bus_range; 1152 struct busnum_ctrl *ctrl; 1153 ndi_ra_request_t req; 1154 char bus_type[16] = "(unknown)"; 1155 int len; 1156 uint64_t base; 1157 uint64_t retlen; 1158 1159 ctrl = (struct busnum_ctrl *)arg; 1160 1161 /* check if this is a PCI bus node */ 1162 len = sizeof (bus_type); 1163 if (ddi_prop_op(DDI_DEV_T_ANY, dip, PROP_LEN_AND_VAL_BUF, 1164 DDI_PROP_CANSLEEP | DDI_PROP_DONTPASS, "device_type", 1165 (caddr_t)&bus_type, &len) != DDI_SUCCESS) 1166 return (DDI_WALK_PRUNECHILD); 1167 1168 /* it is not a pci/pci-ex bus type */ 1169 if ((strcmp(bus_type, "pci") != 0) && (strcmp(bus_type, "pciex") != 0)) 1170 return (DDI_WALK_PRUNECHILD); 1171 1172 /* look for the bus-range property */ 1173 len = sizeof (struct bus_range); 1174 if (ddi_getlongprop_buf(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, 1175 "bus-range", (caddr_t)&pci_bus_range, &len) == DDI_SUCCESS) { 1176 if ((pci_bus_range.lo >= ctrl->range->lo) && 1177 (pci_bus_range.hi <= ctrl->range->hi)) { 1178 1179 /* claim the bus range from the bus resource map */ 1180 bzero((caddr_t)&req, sizeof (req)); 1181 req.ra_addr = (uint64_t)pci_bus_range.lo; 1182 req.ra_flags |= NDI_RA_ALLOC_SPECIFIED; 1183 req.ra_len = (uint64_t)pci_bus_range.hi - 1184 (uint64_t)pci_bus_range.lo + 1; 1185 if (ndi_ra_alloc(ctrl->dip, &req, &base, &retlen, 1186 NDI_RA_TYPE_PCI_BUSNUM, 0) == NDI_SUCCESS) 1187 return (DDI_WALK_PRUNECHILD); 1188 } 1189 } 1190 1191 /* 1192 * Error return. 1193 */ 1194 ctrl->rv = DDI_FAILURE; 1195 return (DDI_WALK_TERMINATE); 1196 } 1197 1198 void 1199 pci_resource_destroy(dev_info_t *dip) 1200 { 1201 (void) ndi_ra_map_destroy(dip, NDI_RA_TYPE_IO); 1202 1203 (void) ndi_ra_map_destroy(dip, NDI_RA_TYPE_MEM); 1204 1205 (void) ndi_ra_map_destroy(dip, NDI_RA_TYPE_PCI_BUSNUM); 1206 1207 (void) ndi_ra_map_destroy(dip, NDI_RA_TYPE_PCI_PREFETCH_MEM); 1208 } 1209 1210 1211 int 1212 pci_resource_setup_avail(dev_info_t *dip, pci_regspec_t *avail_p, int entries) 1213 { 1214 int i; 1215 1216 if (ndi_ra_map_setup(dip, NDI_RA_TYPE_MEM) == NDI_FAILURE) 1217 return (NDI_FAILURE); 1218 if (ndi_ra_map_setup(dip, NDI_RA_TYPE_IO) == NDI_FAILURE) 1219 return (NDI_FAILURE); 1220 if (ndi_ra_map_setup(dip, NDI_RA_TYPE_PCI_PREFETCH_MEM) == NDI_FAILURE) 1221 return (NDI_FAILURE); 1222 1223 /* for each entry in the PCI "available" property */ 1224 for (i = 0; i < entries; i++, avail_p++) { 1225 if (avail_p->pci_phys_hi == -1u) 1226 goto err; 1227 1228 switch (PCI_REG_ADDR_G(avail_p->pci_phys_hi)) { 1229 case PCI_REG_ADDR_G(PCI_ADDR_MEM32): { 1230 (void) ndi_ra_free(dip, (uint64_t)avail_p->pci_phys_low, 1231 (uint64_t)avail_p->pci_size_low, 1232 (avail_p->pci_phys_hi & PCI_REG_PF_M) ? 1233 NDI_RA_TYPE_PCI_PREFETCH_MEM : NDI_RA_TYPE_MEM, 1234 0); 1235 } 1236 break; 1237 case PCI_REG_ADDR_G(PCI_ADDR_IO): 1238 (void) ndi_ra_free(dip, (uint64_t)avail_p->pci_phys_low, 1239 (uint64_t)avail_p->pci_size_low, NDI_RA_TYPE_IO, 0); 1240 break; 1241 default: 1242 goto err; 1243 } 1244 } 1245 #ifdef BUSRA_DEBUG 1246 if (busra_debug) { 1247 (void) ra_dump_all(NULL, dip); 1248 } 1249 #endif 1250 return (NDI_SUCCESS); 1251 1252 err: 1253 cmn_err(CE_WARN, "pci_resource_setup_avail: bad entry[%d]=%x\n", 1254 i, avail_p->pci_phys_hi); 1255 return (NDI_FAILURE); 1256 } 1257 1258 /* 1259 * Return true if the devinfo node resides on PCI or PCI Express bus, 1260 * sitting in a PCI Express hierarchy. 1261 */ 1262 static boolean_t 1263 is_pcie_fabric(dev_info_t *dip) 1264 { 1265 dev_info_t *root = ddi_root_node(); 1266 dev_info_t *pdip; 1267 boolean_t found = B_FALSE; 1268 char *bus; 1269 1270 /* 1271 * Is this pci/pcie ? 1272 */ 1273 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, dip, 1274 DDI_PROP_DONTPASS, "device_type", &bus) != 1275 DDI_PROP_SUCCESS) { 1276 DEBUGPRT(CE_WARN, "is_pcie_fabric: cannot find " 1277 "\"device_type\" property for dip %p\n", (void *)dip); 1278 return (B_FALSE); 1279 } 1280 1281 if (strcmp(bus, "pciex") == 0) { 1282 /* pcie bus, done */ 1283 ddi_prop_free(bus); 1284 return (B_TRUE); 1285 } else if (strcmp(bus, "pci") == 0) { 1286 /* 1287 * pci bus, fall through to check if it resides in 1288 * a pcie hierarchy. 1289 */ 1290 ddi_prop_free(bus); 1291 } else { 1292 /* other bus, return failure */ 1293 ddi_prop_free(bus); 1294 return (B_FALSE); 1295 } 1296 1297 /* 1298 * Does this device reside in a pcie fabric ? 1299 */ 1300 for (pdip = ddi_get_parent(dip); pdip && (pdip != root) && 1301 !found; pdip = ddi_get_parent(pdip)) { 1302 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, pdip, 1303 DDI_PROP_DONTPASS, "device_type", &bus) != 1304 DDI_PROP_SUCCESS) 1305 break; 1306 1307 if (strcmp(bus, "pciex") == 0) 1308 found = B_TRUE; 1309 1310 ddi_prop_free(bus); 1311 } 1312 1313 return (found); 1314 } 1315 1316 /* 1317 * Remove a piece of IO/MEM resource from "available" property of 'dip'. 1318 */ 1319 static int 1320 pci_get_available_prop(dev_info_t *dip, uint64_t base, uint64_t len, 1321 char *busra_type) 1322 { 1323 pci_regspec_t *regs, *newregs; 1324 uint_t status; 1325 int rlen, rcount; 1326 int i, j, k; 1327 uint64_t dlen; 1328 boolean_t found = B_FALSE; 1329 uint32_t type; 1330 1331 /* check if we're manipulating MEM/IO resource */ 1332 if ((type = pci_type_ra2pci(busra_type)) == PCI_ADDR_TYPE_INVAL) 1333 return (DDI_SUCCESS); 1334 1335 /* check if dip is a pci/pcie device resides in a pcie fabric */ 1336 if (!is_pcie_fabric(dip)) 1337 return (DDI_SUCCESS); 1338 1339 status = ddi_getlongprop(DDI_DEV_T_ANY, dip, 1340 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, 1341 "available", (caddr_t)®s, &rlen); 1342 1343 ASSERT(status == DDI_SUCCESS); 1344 if (status != DDI_SUCCESS) 1345 return (status); 1346 1347 /* 1348 * The updated "available" property will at most have one more entry 1349 * than existing one (when the requested range is in the middle of 1350 * the matched property entry) 1351 */ 1352 newregs = kmem_alloc(rlen + sizeof (pci_regspec_t), KM_SLEEP); 1353 1354 rcount = rlen / sizeof (pci_regspec_t); 1355 for (i = 0, j = 0; i < rcount; i++) { 1356 if (type == (regs[i].pci_phys_hi & PCI_ADDR_TYPE_MASK)) { 1357 uint64_t range_base, range_len; 1358 1359 range_base = ((uint64_t)(regs[i].pci_phys_mid) << 32) | 1360 ((uint64_t)(regs[i].pci_phys_low)); 1361 range_len = ((uint64_t)(regs[i].pci_size_hi) << 32) | 1362 ((uint64_t)(regs[i].pci_size_low)); 1363 1364 if ((base < range_base) || 1365 (base + len > range_base + range_len)) { 1366 /* 1367 * not a match, copy the entry 1368 */ 1369 goto copy_entry; 1370 } 1371 1372 /* 1373 * range_base base base+len range_base 1374 * +range_len 1375 * +------------+-----------+----------+ 1376 * | |///////////| | 1377 * +------------+-----------+----------+ 1378 */ 1379 /* 1380 * Found a match, remove the range out of this entry. 1381 */ 1382 found = B_TRUE; 1383 1384 dlen = base - range_base; 1385 if (dlen != 0) { 1386 newregs[j].pci_phys_hi = regs[i].pci_phys_hi; 1387 newregs[j].pci_phys_mid = 1388 (uint32_t)(range_base >> 32); 1389 newregs[j].pci_phys_low = 1390 (uint32_t)(range_base); 1391 newregs[j].pci_size_hi = (uint32_t)(dlen >> 32); 1392 newregs[j].pci_size_low = (uint32_t)dlen; 1393 j++; 1394 } 1395 1396 dlen = (range_base + range_len) - (base + len); 1397 if (dlen != 0) { 1398 newregs[j].pci_phys_hi = regs[i].pci_phys_hi; 1399 newregs[j].pci_phys_mid = 1400 (uint32_t)((base + len)>> 32); 1401 newregs[j].pci_phys_low = 1402 (uint32_t)(base + len); 1403 newregs[j].pci_size_hi = (uint32_t)(dlen >> 32); 1404 newregs[j].pci_size_low = (uint32_t)dlen; 1405 j++; 1406 } 1407 1408 /* 1409 * We've allocated the resource from the matched 1410 * entry, almost finished but still need to copy 1411 * the rest entries from the original property 1412 * array. 1413 */ 1414 for (k = i + 1; k < rcount; k++) { 1415 newregs[j] = regs[k]; 1416 j++; 1417 } 1418 1419 goto done; 1420 1421 } else { 1422 copy_entry: 1423 newregs[j] = regs[i]; 1424 j++; 1425 } 1426 } 1427 1428 done: 1429 /* 1430 * This should not fail so assert it. For non-debug kernel we don't 1431 * want to panic thus only logging a warning message. 1432 */ 1433 ASSERT(found == B_TRUE); 1434 if (!found) { 1435 cmn_err(CE_WARN, "pci_get_available_prop: failed to remove " 1436 "resource from dip %p : base 0x%" PRIx64 ", len 0x%" PRIX64 1437 ", type 0x%x\n", (void *)dip, base, len, type); 1438 kmem_free(newregs, rlen + sizeof (pci_regspec_t)); 1439 kmem_free(regs, rlen); 1440 1441 return (DDI_FAILURE); 1442 } 1443 1444 /* 1445 * Found the resources from parent, update the "available" 1446 * property. 1447 */ 1448 if (j == 0) { 1449 /* all the resources are consumed, remove the property */ 1450 (void) ndi_prop_remove(DDI_DEV_T_NONE, dip, "available"); 1451 } else { 1452 /* 1453 * There are still resource available in the parent dip, 1454 * update with the remaining resources. 1455 */ 1456 (void) ndi_prop_update_int_array(DDI_DEV_T_NONE, dip, 1457 "available", (int *)newregs, 1458 (j * sizeof (pci_regspec_t)) / sizeof (int)); 1459 } 1460 1461 kmem_free(newregs, rlen + sizeof (pci_regspec_t)); 1462 kmem_free(regs, rlen); 1463 1464 return (DDI_SUCCESS); 1465 } 1466 1467 /* 1468 * Add a piece of IO/MEM resource to "available" property of 'dip'. 1469 */ 1470 static int 1471 pci_put_available_prop(dev_info_t *dip, uint64_t base, uint64_t len, 1472 char *busra_type) 1473 { 1474 pci_regspec_t *regs, *newregs; 1475 uint_t status; 1476 int rlen, rcount; 1477 int i, j, k; 1478 int matched = 0; 1479 uint64_t orig_base = base; 1480 uint64_t orig_len = len; 1481 uint32_t type; 1482 1483 /* check if we're manipulating MEM/IO resource */ 1484 if ((type = pci_type_ra2pci(busra_type)) == PCI_ADDR_TYPE_INVAL) 1485 return (DDI_SUCCESS); 1486 1487 /* check if dip is a pci/pcie device resides in a pcie fabric */ 1488 if (!is_pcie_fabric(dip)) 1489 return (DDI_SUCCESS); 1490 1491 status = ddi_getlongprop(DDI_DEV_T_ANY, dip, 1492 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, 1493 "available", (caddr_t)®s, &rlen); 1494 1495 switch (status) { 1496 case DDI_PROP_NOT_FOUND: 1497 goto not_found; 1498 1499 case DDI_PROP_SUCCESS: 1500 break; 1501 1502 default: 1503 return (status); 1504 } 1505 1506 /* 1507 * The "available" property exist on the node, try to put this 1508 * resource back, merge if there are adjacent resources. 1509 * 1510 * The updated "available" property will at most have one more entry 1511 * than existing one (when there is no adjacent entries thus the new 1512 * resource is appended at the end) 1513 */ 1514 newregs = kmem_alloc(rlen + sizeof (pci_regspec_t), KM_SLEEP); 1515 1516 rcount = rlen / sizeof (pci_regspec_t); 1517 for (i = 0, j = 0; i < rcount; i++) { 1518 if (type == (regs[i].pci_phys_hi & PCI_ADDR_TYPE_MASK)) { 1519 uint64_t range_base, range_len; 1520 1521 range_base = ((uint64_t)(regs[i].pci_phys_mid) << 32) | 1522 ((uint64_t)(regs[i].pci_phys_low)); 1523 range_len = ((uint64_t)(regs[i].pci_size_hi) << 32) | 1524 ((uint64_t)(regs[i].pci_size_low)); 1525 1526 if ((base + len < range_base) || 1527 (base > range_base + range_len)) { 1528 /* 1529 * Not adjacent, copy the entry and contiue 1530 */ 1531 goto copy_entry; 1532 } 1533 1534 /* 1535 * Adjacent or overlap? 1536 * 1537 * Should not have overlapping resources so assert it. 1538 * For non-debug kernel we don't want to panic thus 1539 * only logging a warning message. 1540 */ 1541 #if 0 1542 ASSERT((base + len == range_base) || 1543 (base == range_base + range_len)); 1544 #endif 1545 if ((base + len != range_base) && 1546 (base != range_base + range_len)) { 1547 cmn_err(CE_WARN, "pci_put_available_prop: " 1548 "failed to add resource to dip %p : " 1549 "base 0x%" PRIx64 ", len 0x%" PRIx64 " " 1550 "overlaps with existing resource " 1551 "base 0x%" PRIx64 ", len 0x%" PRIx64 "\n", 1552 (void *)dip, orig_base, orig_len, 1553 range_base, range_len); 1554 1555 goto failure; 1556 } 1557 1558 /* 1559 * On the left: 1560 * 1561 * base range_base 1562 * +-------------+-------------+ 1563 * |/////////////| | 1564 * +-------------+-------------+ 1565 * len range_len 1566 * 1567 * On the right: 1568 * 1569 * range_base base 1570 * +-------------+-------------+ 1571 * | |/////////////| 1572 * +-------------+-------------+ 1573 * range_len len 1574 */ 1575 /* 1576 * There are at most two piece of resources adjacent 1577 * with this resource, assert it. 1578 */ 1579 ASSERT(matched < 2); 1580 1581 if (!(matched < 2)) { 1582 cmn_err(CE_WARN, "pci_put_available_prop: " 1583 "failed to add resource to dip %p : " 1584 "base 0x%" PRIx64 ", len 0x%" PRIx64 " " 1585 "found overlaps in existing resources\n", 1586 (void *)dip, orig_base, orig_len); 1587 1588 goto failure; 1589 } 1590 1591 /* setup base & len to refer to the merged range */ 1592 len += range_len; 1593 if (base == range_base + range_len) 1594 base = range_base; 1595 1596 if (matched == 0) { 1597 /* 1598 * One adjacent entry, add this resource in 1599 */ 1600 newregs[j].pci_phys_hi = regs[i].pci_phys_hi; 1601 newregs[j].pci_phys_mid = 1602 (uint32_t)(base >> 32); 1603 newregs[j].pci_phys_low = (uint32_t)(base); 1604 newregs[j].pci_size_hi = (uint32_t)(len >> 32); 1605 newregs[j].pci_size_low = (uint32_t)len; 1606 1607 matched = 1; 1608 k = j; 1609 j++; 1610 } else { /* matched == 1 */ 1611 /* 1612 * Two adjacent entries, merge them together 1613 */ 1614 newregs[k].pci_phys_hi = regs[i].pci_phys_hi; 1615 newregs[k].pci_phys_mid = 1616 (uint32_t)(base >> 32); 1617 newregs[k].pci_phys_low = (uint32_t)(base); 1618 newregs[k].pci_size_hi = (uint32_t)(len >> 32); 1619 newregs[k].pci_size_low = (uint32_t)len; 1620 1621 matched = 2; 1622 } 1623 } else { 1624 copy_entry: 1625 newregs[j] = regs[i]; 1626 j++; 1627 } 1628 } 1629 1630 if (matched == 0) { 1631 /* No adjacent entries, append at end */ 1632 ASSERT(j == rcount); 1633 1634 /* 1635 * According to page 15 of 1275 spec, bit "n" of "available" 1636 * should be set to 1. 1637 */ 1638 newregs[j].pci_phys_hi = type; 1639 newregs[j].pci_phys_hi |= PCI_REG_REL_M; 1640 1641 newregs[j].pci_phys_mid = (uint32_t)(base >> 32); 1642 newregs[j].pci_phys_low = (uint32_t)base; 1643 newregs[j].pci_size_hi = (uint32_t)(len >> 32); 1644 newregs[j].pci_size_low = (uint32_t)len; 1645 1646 j++; 1647 } 1648 1649 (void) ndi_prop_update_int_array(DDI_DEV_T_NONE, dip, 1650 "available", (int *)newregs, 1651 (j * sizeof (pci_regspec_t)) / sizeof (int)); 1652 1653 kmem_free(newregs, rlen + sizeof (pci_regspec_t)); 1654 kmem_free(regs, rlen); 1655 return (DDI_SUCCESS); 1656 1657 not_found: 1658 /* 1659 * There is no "available" property on the parent node, create it. 1660 */ 1661 newregs = kmem_alloc(sizeof (pci_regspec_t), KM_SLEEP); 1662 1663 /* 1664 * According to page 15 of 1275 spec, bit "n" of "available" should 1665 * be set to 1. 1666 */ 1667 newregs[0].pci_phys_hi = type; 1668 newregs[0].pci_phys_hi |= PCI_REG_REL_M; 1669 1670 newregs[0].pci_phys_mid = (uint32_t)(base >> 32); 1671 newregs[0].pci_phys_low = (uint32_t)base; 1672 newregs[0].pci_size_hi = (uint32_t)(len >> 32); 1673 newregs[0].pci_size_low = (uint32_t)len; 1674 1675 (void) ndi_prop_update_int_array(DDI_DEV_T_NONE, dip, 1676 "available", (int *)newregs, 1677 sizeof (pci_regspec_t) / sizeof (int)); 1678 kmem_free(newregs, sizeof (pci_regspec_t)); 1679 return (DDI_SUCCESS); 1680 1681 failure: 1682 kmem_free(newregs, rlen + sizeof (pci_regspec_t)); 1683 kmem_free(regs, rlen); 1684 return (DDI_FAILURE); 1685 } 1686 1687 static uint32_t 1688 pci_type_ra2pci(char *type) 1689 { 1690 uint32_t pci_type = PCI_ADDR_TYPE_INVAL; 1691 1692 /* 1693 * No 64 bit mem support for now 1694 */ 1695 if (strcmp(type, NDI_RA_TYPE_IO) == 0) { 1696 pci_type = PCI_ADDR_IO; 1697 1698 } else if (strcmp(type, NDI_RA_TYPE_MEM) == 0) { 1699 pci_type = PCI_ADDR_MEM32; 1700 1701 } else if (strcmp(type, NDI_RA_TYPE_PCI_PREFETCH_MEM) == 0) { 1702 pci_type = PCI_ADDR_MEM32; 1703 pci_type |= PCI_REG_PF_M; 1704 } 1705 1706 return (pci_type); 1707 }