1 /* 2 * IBM Hot Plug Controller Driver 3 * 4 * Written By: Irene Zubarev, IBM Corporation 5 * 6 * Copyright (C) 2001 Greg Kroah-Hartman (greg@kroah.com) 7 * Copyright (C) 2001,2002 IBM Corp. 8 * 9 * All rights reserved. 10 * 11 * This program is free software; you can redistribute it and/or modify 12 * it under the terms of the GNU General Public License as published by 13 * the Free Software Foundation; either version 2 of the License, or (at 14 * your option) any later version. 15 * 16 * This program is distributed in the hope that it will be useful, but 17 * WITHOUT ANY WARRANTY; without even the implied warranty of 18 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or 19 * NON INFRINGEMENT. See the GNU General Public License for more 20 * details. 21 * 22 * You should have received a copy of the GNU General Public License 23 * along with this program; if not, write to the Free Software 24 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 25 * 26 * Send feedback to <gregkh@us.ibm.com> 27 * 28 */ 29 30 #include <linux/module.h> 31 #include <linux/slab.h> 32 #include <linux/pci.h> 33 #include <linux/list.h> 34 #include <linux/init.h> 35 #include "ibmphp.h" 36 37 static int flags = 0; /* for testing */ 38 39 static void update_resources(struct bus_node *bus_cur, int type, int rangeno); 40 static int once_over(void); 41 static int remove_ranges(struct bus_node *, struct bus_node *); 42 static int update_bridge_ranges(struct bus_node **); 43 static int add_bus_range(int type, struct range_node *, struct bus_node *); 44 static void fix_resources(struct bus_node *); 45 static struct bus_node *find_bus_wprev(u8, struct bus_node **, u8); 46 47 static LIST_HEAD(gbuses); 48 49 static struct bus_node * __init alloc_error_bus(struct ebda_pci_rsrc *curr, u8 busno, int flag) 50 { 51 struct bus_node *newbus; 52 53 if (!(curr) && !(flag)) { 54 err("NULL pointer passed\n"); 55 return NULL; 56 } 57 58 newbus = kzalloc(sizeof(struct bus_node), GFP_KERNEL); 59 if (!newbus) { 60 err("out of system memory\n"); 61 return NULL; 62 } 63 64 if (flag) 65 newbus->busno = busno; 66 else 67 newbus->busno = curr->bus_num; 68 list_add_tail(&newbus->bus_list, &gbuses); 69 return newbus; 70 } 71 72 static struct resource_node * __init alloc_resources(struct ebda_pci_rsrc *curr) 73 { 74 struct resource_node *rs; 75 76 if (!curr) { 77 err("NULL passed to allocate\n"); 78 return NULL; 79 } 80 81 rs = kzalloc(sizeof(struct resource_node), GFP_KERNEL); 82 if (!rs) { 83 err("out of system memory\n"); 84 return NULL; 85 } 86 rs->busno = curr->bus_num; 87 rs->devfunc = curr->dev_fun; 88 rs->start = curr->start_addr; 89 rs->end = curr->end_addr; 90 rs->len = curr->end_addr - curr->start_addr + 1; 91 return rs; 92 } 93 94 static int __init alloc_bus_range(struct bus_node **new_bus, struct range_node **new_range, struct ebda_pci_rsrc *curr, int flag, u8 first_bus) 95 { 96 struct bus_node *newbus; 97 struct range_node *newrange; 98 u8 num_ranges = 0; 99 100 if (first_bus) { 101 newbus = kzalloc(sizeof(struct bus_node), GFP_KERNEL); 102 if (!newbus) { 103 err("out of system memory.\n"); 104 return -ENOMEM; 105 } 106 newbus->busno = curr->bus_num; 107 } else { 108 newbus = *new_bus; 109 switch (flag) { 110 case MEM: 111 num_ranges = newbus->noMemRanges; 112 break; 113 case PFMEM: 114 num_ranges = newbus->noPFMemRanges; 115 break; 116 case IO: 117 num_ranges = newbus->noIORanges; 118 break; 119 } 120 } 121 122 newrange = kzalloc(sizeof(struct range_node), GFP_KERNEL); 123 if (!newrange) { 124 if (first_bus) 125 kfree(newbus); 126 err("out of system memory\n"); 127 return -ENOMEM; 128 } 129 newrange->start = curr->start_addr; 130 newrange->end = curr->end_addr; 131 132 if (first_bus || (!num_ranges)) 133 newrange->rangeno = 1; 134 else { 135 /* need to insert our range */ 136 add_bus_range(flag, newrange, newbus); 137 debug("%d resource Primary Bus inserted on bus %x [%x - %x]\n", flag, newbus->busno, newrange->start, newrange->end); 138 } 139 140 switch (flag) { 141 case MEM: 142 newbus->rangeMem = newrange; 143 if (first_bus) 144 newbus->noMemRanges = 1; 145 else { 146 debug("First Memory Primary on bus %x, [%x - %x]\n", newbus->busno, newrange->start, newrange->end); 147 ++newbus->noMemRanges; 148 fix_resources(newbus); 149 } 150 break; 151 case IO: 152 newbus->rangeIO = newrange; 153 if (first_bus) 154 newbus->noIORanges = 1; 155 else { 156 debug("First IO Primary on bus %x, [%x - %x]\n", newbus->busno, newrange->start, newrange->end); 157 ++newbus->noIORanges; 158 fix_resources(newbus); 159 } 160 break; 161 case PFMEM: 162 newbus->rangePFMem = newrange; 163 if (first_bus) 164 newbus->noPFMemRanges = 1; 165 else { 166 debug("1st PFMemory Primary on Bus %x [%x - %x]\n", newbus->busno, newrange->start, newrange->end); 167 ++newbus->noPFMemRanges; 168 fix_resources(newbus); 169 } 170 171 break; 172 } 173 174 *new_bus = newbus; 175 *new_range = newrange; 176 return 0; 177 } 178 179 180 /* Notes: 181 * 1. The ranges are ordered. The buses are not ordered. (First come) 182 * 183 * 2. If cannot allocate out of PFMem range, allocate from Mem ranges. PFmemFromMem 184 * are not sorted. (no need since use mem node). To not change the entire code, we 185 * also add mem node whenever this case happens so as not to change 186 * ibmphp_check_mem_resource etc(and since it really is taking Mem resource) 187 */ 188 189 /***************************************************************************** 190 * This is the Resource Management initialization function. It will go through 191 * the Resource list taken from EBDA and fill in this module's data structures 192 * 193 * THIS IS NOT TAKING INTO CONSIDERATION IO RESTRICTIONS OF PRIMARY BUSES, 194 * SINCE WE'RE GOING TO ASSUME FOR NOW WE DON'T HAVE THOSE ON OUR BUSES FOR NOW 195 * 196 * Input: ptr to the head of the resource list from EBDA 197 * Output: 0, -1 or error codes 198 ***************************************************************************/ 199 int __init ibmphp_rsrc_init(void) 200 { 201 struct ebda_pci_rsrc *curr; 202 struct range_node *newrange = NULL; 203 struct bus_node *newbus = NULL; 204 struct bus_node *bus_cur; 205 struct bus_node *bus_prev; 206 struct resource_node *new_io = NULL; 207 struct resource_node *new_mem = NULL; 208 struct resource_node *new_pfmem = NULL; 209 int rc; 210 211 list_for_each_entry(curr, &ibmphp_ebda_pci_rsrc_head, 212 ebda_pci_rsrc_list) { 213 if (!(curr->rsrc_type & PCIDEVMASK)) { 214 /* EBDA still lists non PCI devices, so ignore... */ 215 debug("this is not a PCI DEVICE in rsrc_init, please take care\n"); 216 // continue; 217 } 218 219 /* this is a primary bus resource */ 220 if (curr->rsrc_type & PRIMARYBUSMASK) { 221 /* memory */ 222 if ((curr->rsrc_type & RESTYPE) == MMASK) { 223 /* no bus structure exists in place yet */ 224 if (list_empty(&gbuses)) { 225 rc = alloc_bus_range(&newbus, &newrange, curr, MEM, 1); 226 if (rc) 227 return rc; 228 list_add_tail(&newbus->bus_list, &gbuses); 229 debug("gbuses = NULL, Memory Primary Bus %x [%x - %x]\n", newbus->busno, newrange->start, newrange->end); 230 } else { 231 bus_cur = find_bus_wprev(curr->bus_num, &bus_prev, 1); 232 /* found our bus */ 233 if (bus_cur) { 234 rc = alloc_bus_range(&bus_cur, &newrange, curr, MEM, 0); 235 if (rc) 236 return rc; 237 } else { 238 /* went through all the buses and didn't find ours, need to create a new bus node */ 239 rc = alloc_bus_range(&newbus, &newrange, curr, MEM, 1); 240 if (rc) 241 return rc; 242 243 list_add_tail(&newbus->bus_list, &gbuses); 244 debug("New Bus, Memory Primary Bus %x [%x - %x]\n", newbus->busno, newrange->start, newrange->end); 245 } 246 } 247 } else if ((curr->rsrc_type & RESTYPE) == PFMASK) { 248 /* prefetchable memory */ 249 if (list_empty(&gbuses)) { 250 /* no bus structure exists in place yet */ 251 rc = alloc_bus_range(&newbus, &newrange, curr, PFMEM, 1); 252 if (rc) 253 return rc; 254 list_add_tail(&newbus->bus_list, &gbuses); 255 debug("gbuses = NULL, PFMemory Primary Bus %x [%x - %x]\n", newbus->busno, newrange->start, newrange->end); 256 } else { 257 bus_cur = find_bus_wprev(curr->bus_num, &bus_prev, 1); 258 if (bus_cur) { 259 /* found our bus */ 260 rc = alloc_bus_range(&bus_cur, &newrange, curr, PFMEM, 0); 261 if (rc) 262 return rc; 263 } else { 264 /* went through all the buses and didn't find ours, need to create a new bus node */ 265 rc = alloc_bus_range(&newbus, &newrange, curr, PFMEM, 1); 266 if (rc) 267 return rc; 268 list_add_tail(&newbus->bus_list, &gbuses); 269 debug("1st Bus, PFMemory Primary Bus %x [%x - %x]\n", newbus->busno, newrange->start, newrange->end); 270 } 271 } 272 } else if ((curr->rsrc_type & RESTYPE) == IOMASK) { 273 /* IO */ 274 if (list_empty(&gbuses)) { 275 /* no bus structure exists in place yet */ 276 rc = alloc_bus_range(&newbus, &newrange, curr, IO, 1); 277 if (rc) 278 return rc; 279 list_add_tail(&newbus->bus_list, &gbuses); 280 debug("gbuses = NULL, IO Primary Bus %x [%x - %x]\n", newbus->busno, newrange->start, newrange->end); 281 } else { 282 bus_cur = find_bus_wprev(curr->bus_num, &bus_prev, 1); 283 if (bus_cur) { 284 rc = alloc_bus_range(&bus_cur, &newrange, curr, IO, 0); 285 if (rc) 286 return rc; 287 } else { 288 /* went through all the buses and didn't find ours, need to create a new bus node */ 289 rc = alloc_bus_range(&newbus, &newrange, curr, IO, 1); 290 if (rc) 291 return rc; 292 list_add_tail(&newbus->bus_list, &gbuses); 293 debug("1st Bus, IO Primary Bus %x [%x - %x]\n", newbus->busno, newrange->start, newrange->end); 294 } 295 } 296 297 } else { 298 ; /* type is reserved WHAT TO DO IN THIS CASE??? 299 NOTHING TO DO??? */ 300 } 301 } else { 302 /* regular pci device resource */ 303 if ((curr->rsrc_type & RESTYPE) == MMASK) { 304 /* Memory resource */ 305 new_mem = alloc_resources(curr); 306 if (!new_mem) 307 return -ENOMEM; 308 new_mem->type = MEM; 309 /* 310 * if it didn't find the bus, means PCI dev 311 * came b4 the Primary Bus info, so need to 312 * create a bus rangeno becomes a problem... 313 * assign a -1 and then update once the range 314 * actually appears... 315 */ 316 if (ibmphp_add_resource(new_mem) < 0) { 317 newbus = alloc_error_bus(curr, 0, 0); 318 if (!newbus) 319 return -ENOMEM; 320 newbus->firstMem = new_mem; 321 ++newbus->needMemUpdate; 322 new_mem->rangeno = -1; 323 } 324 debug("Memory resource for device %x, bus %x, [%x - %x]\n", new_mem->devfunc, new_mem->busno, new_mem->start, new_mem->end); 325 326 } else if ((curr->rsrc_type & RESTYPE) == PFMASK) { 327 /* PFMemory resource */ 328 new_pfmem = alloc_resources(curr); 329 if (!new_pfmem) 330 return -ENOMEM; 331 new_pfmem->type = PFMEM; 332 new_pfmem->fromMem = 0; 333 if (ibmphp_add_resource(new_pfmem) < 0) { 334 newbus = alloc_error_bus(curr, 0, 0); 335 if (!newbus) 336 return -ENOMEM; 337 newbus->firstPFMem = new_pfmem; 338 ++newbus->needPFMemUpdate; 339 new_pfmem->rangeno = -1; 340 } 341 342 debug("PFMemory resource for device %x, bus %x, [%x - %x]\n", new_pfmem->devfunc, new_pfmem->busno, new_pfmem->start, new_pfmem->end); 343 } else if ((curr->rsrc_type & RESTYPE) == IOMASK) { 344 /* IO resource */ 345 new_io = alloc_resources(curr); 346 if (!new_io) 347 return -ENOMEM; 348 new_io->type = IO; 349 350 /* 351 * if it didn't find the bus, means PCI dev 352 * came b4 the Primary Bus info, so need to 353 * create a bus rangeno becomes a problem... 354 * Can assign a -1 and then update once the 355 * range actually appears... 356 */ 357 if (ibmphp_add_resource(new_io) < 0) { 358 newbus = alloc_error_bus(curr, 0, 0); 359 if (!newbus) 360 return -ENOMEM; 361 newbus->firstIO = new_io; 362 ++newbus->needIOUpdate; 363 new_io->rangeno = -1; 364 } 365 debug("IO resource for device %x, bus %x, [%x - %x]\n", new_io->devfunc, new_io->busno, new_io->start, new_io->end); 366 } 367 } 368 } 369 370 list_for_each_entry(bus_cur, &gbuses, bus_list) { 371 /* This is to get info about PPB resources, since EBDA doesn't put this info into the primary bus info */ 372 rc = update_bridge_ranges(&bus_cur); 373 if (rc) 374 return rc; 375 } 376 return once_over(); /* This is to align ranges (so no -1) */ 377 } 378 379 /******************************************************************************** 380 * This function adds a range into a sorted list of ranges per bus for a particular 381 * range type, it then calls another routine to update the range numbers on the 382 * pci devices' resources for the appropriate resource 383 * 384 * Input: type of the resource, range to add, current bus 385 * Output: 0 or -1, bus and range ptrs 386 ********************************************************************************/ 387 static int add_bus_range(int type, struct range_node *range, struct bus_node *bus_cur) 388 { 389 struct range_node *range_cur = NULL; 390 struct range_node *range_prev; 391 int count = 0, i_init; 392 int noRanges = 0; 393 394 switch (type) { 395 case MEM: 396 range_cur = bus_cur->rangeMem; 397 noRanges = bus_cur->noMemRanges; 398 break; 399 case PFMEM: 400 range_cur = bus_cur->rangePFMem; 401 noRanges = bus_cur->noPFMemRanges; 402 break; 403 case IO: 404 range_cur = bus_cur->rangeIO; 405 noRanges = bus_cur->noIORanges; 406 break; 407 } 408 409 range_prev = NULL; 410 while (range_cur) { 411 if (range->start < range_cur->start) 412 break; 413 range_prev = range_cur; 414 range_cur = range_cur->next; 415 count = count + 1; 416 } 417 if (!count) { 418 /* our range will go at the beginning of the list */ 419 switch (type) { 420 case MEM: 421 bus_cur->rangeMem = range; 422 break; 423 case PFMEM: 424 bus_cur->rangePFMem = range; 425 break; 426 case IO: 427 bus_cur->rangeIO = range; 428 break; 429 } 430 range->next = range_cur; 431 range->rangeno = 1; 432 i_init = 0; 433 } else if (!range_cur) { 434 /* our range will go at the end of the list */ 435 range->next = NULL; 436 range_prev->next = range; 437 range->rangeno = range_prev->rangeno + 1; 438 return 0; 439 } else { 440 /* the range is in the middle */ 441 range_prev->next = range; 442 range->next = range_cur; 443 range->rangeno = range_cur->rangeno; 444 i_init = range_prev->rangeno; 445 } 446 447 for (count = i_init; count < noRanges; ++count) { 448 ++range_cur->rangeno; 449 range_cur = range_cur->next; 450 } 451 452 update_resources(bus_cur, type, i_init + 1); 453 return 0; 454 } 455 456 /******************************************************************************* 457 * This routine goes through the list of resources of type 'type' and updates 458 * the range numbers that they correspond to. It was called from add_bus_range fnc 459 * 460 * Input: bus, type of the resource, the rangeno starting from which to update 461 ******************************************************************************/ 462 static void update_resources(struct bus_node *bus_cur, int type, int rangeno) 463 { 464 struct resource_node *res = NULL; 465 u8 eol = 0; /* end of list indicator */ 466 467 switch (type) { 468 case MEM: 469 if (bus_cur->firstMem) 470 res = bus_cur->firstMem; 471 break; 472 case PFMEM: 473 if (bus_cur->firstPFMem) 474 res = bus_cur->firstPFMem; 475 break; 476 case IO: 477 if (bus_cur->firstIO) 478 res = bus_cur->firstIO; 479 break; 480 } 481 482 if (res) { 483 while (res) { 484 if (res->rangeno == rangeno) 485 break; 486 if (res->next) 487 res = res->next; 488 else if (res->nextRange) 489 res = res->nextRange; 490 else { 491 eol = 1; 492 break; 493 } 494 } 495 496 if (!eol) { 497 /* found the range */ 498 while (res) { 499 ++res->rangeno; 500 res = res->next; 501 } 502 } 503 } 504 } 505 506 static void fix_me(struct resource_node *res, struct bus_node *bus_cur, struct range_node *range) 507 { 508 char *str = ""; 509 switch (res->type) { 510 case IO: 511 str = "io"; 512 break; 513 case MEM: 514 str = "mem"; 515 break; 516 case PFMEM: 517 str = "pfmem"; 518 break; 519 } 520 521 while (res) { 522 if (res->rangeno == -1) { 523 while (range) { 524 if ((res->start >= range->start) && (res->end <= range->end)) { 525 res->rangeno = range->rangeno; 526 debug("%s->rangeno in fix_resources is %d\n", str, res->rangeno); 527 switch (res->type) { 528 case IO: 529 --bus_cur->needIOUpdate; 530 break; 531 case MEM: 532 --bus_cur->needMemUpdate; 533 break; 534 case PFMEM: 535 --bus_cur->needPFMemUpdate; 536 break; 537 } 538 break; 539 } 540 range = range->next; 541 } 542 } 543 if (res->next) 544 res = res->next; 545 else 546 res = res->nextRange; 547 } 548 549 } 550 551 /***************************************************************************** 552 * This routine reassigns the range numbers to the resources that had a -1 553 * This case can happen only if upon initialization, resources taken by pci dev 554 * appear in EBDA before the resources allocated for that bus, since we don't 555 * know the range, we assign -1, and this routine is called after a new range 556 * is assigned to see the resources with unknown range belong to the added range 557 * 558 * Input: current bus 559 * Output: none, list of resources for that bus are fixed if can be 560 *******************************************************************************/ 561 static void fix_resources(struct bus_node *bus_cur) 562 { 563 struct range_node *range; 564 struct resource_node *res; 565 566 debug("%s - bus_cur->busno = %d\n", __func__, bus_cur->busno); 567 568 if (bus_cur->needIOUpdate) { 569 res = bus_cur->firstIO; 570 range = bus_cur->rangeIO; 571 fix_me(res, bus_cur, range); 572 } 573 if (bus_cur->needMemUpdate) { 574 res = bus_cur->firstMem; 575 range = bus_cur->rangeMem; 576 fix_me(res, bus_cur, range); 577 } 578 if (bus_cur->needPFMemUpdate) { 579 res = bus_cur->firstPFMem; 580 range = bus_cur->rangePFMem; 581 fix_me(res, bus_cur, range); 582 } 583 } 584 585 /******************************************************************************* 586 * This routine adds a resource to the list of resources to the appropriate bus 587 * based on their resource type and sorted by their starting addresses. It assigns 588 * the ptrs to next and nextRange if needed. 589 * 590 * Input: resource ptr 591 * Output: ptrs assigned (to the node) 592 * 0 or -1 593 *******************************************************************************/ 594 int ibmphp_add_resource(struct resource_node *res) 595 { 596 struct resource_node *res_cur; 597 struct resource_node *res_prev; 598 struct bus_node *bus_cur; 599 struct range_node *range_cur = NULL; 600 struct resource_node *res_start = NULL; 601 602 debug("%s - enter\n", __func__); 603 604 if (!res) { 605 err("NULL passed to add\n"); 606 return -ENODEV; 607 } 608 609 bus_cur = find_bus_wprev(res->busno, NULL, 0); 610 611 if (!bus_cur) { 612 /* didn't find a bus, something's wrong!!! */ 613 debug("no bus in the system, either pci_dev's wrong or allocation failed\n"); 614 return -ENODEV; 615 } 616 617 /* Normal case */ 618 switch (res->type) { 619 case IO: 620 range_cur = bus_cur->rangeIO; 621 res_start = bus_cur->firstIO; 622 break; 623 case MEM: 624 range_cur = bus_cur->rangeMem; 625 res_start = bus_cur->firstMem; 626 break; 627 case PFMEM: 628 range_cur = bus_cur->rangePFMem; 629 res_start = bus_cur->firstPFMem; 630 break; 631 default: 632 err("cannot read the type of the resource to add... problem\n"); 633 return -EINVAL; 634 } 635 while (range_cur) { 636 if ((res->start >= range_cur->start) && (res->end <= range_cur->end)) { 637 res->rangeno = range_cur->rangeno; 638 break; 639 } 640 range_cur = range_cur->next; 641 } 642 643 /* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 644 * this is again the case of rangeno = -1 645 * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 646 */ 647 648 if (!range_cur) { 649 switch (res->type) { 650 case IO: 651 ++bus_cur->needIOUpdate; 652 break; 653 case MEM: 654 ++bus_cur->needMemUpdate; 655 break; 656 case PFMEM: 657 ++bus_cur->needPFMemUpdate; 658 break; 659 } 660 res->rangeno = -1; 661 } 662 663 debug("The range is %d\n", res->rangeno); 664 if (!res_start) { 665 /* no first{IO,Mem,Pfmem} on the bus, 1st IO/Mem/Pfmem resource ever */ 666 switch (res->type) { 667 case IO: 668 bus_cur->firstIO = res; 669 break; 670 case MEM: 671 bus_cur->firstMem = res; 672 break; 673 case PFMEM: 674 bus_cur->firstPFMem = res; 675 break; 676 } 677 res->next = NULL; 678 res->nextRange = NULL; 679 } else { 680 res_cur = res_start; 681 res_prev = NULL; 682 683 debug("res_cur->rangeno is %d\n", res_cur->rangeno); 684 685 while (res_cur) { 686 if (res_cur->rangeno >= res->rangeno) 687 break; 688 res_prev = res_cur; 689 if (res_cur->next) 690 res_cur = res_cur->next; 691 else 692 res_cur = res_cur->nextRange; 693 } 694 695 if (!res_cur) { 696 /* at the end of the resource list */ 697 debug("i should be here, [%x - %x]\n", res->start, res->end); 698 res_prev->nextRange = res; 699 res->next = NULL; 700 res->nextRange = NULL; 701 } else if (res_cur->rangeno == res->rangeno) { 702 /* in the same range */ 703 while (res_cur) { 704 if (res->start < res_cur->start) 705 break; 706 res_prev = res_cur; 707 res_cur = res_cur->next; 708 } 709 if (!res_cur) { 710 /* the last resource in this range */ 711 res_prev->next = res; 712 res->next = NULL; 713 res->nextRange = res_prev->nextRange; 714 res_prev->nextRange = NULL; 715 } else if (res->start < res_cur->start) { 716 /* at the beginning or middle of the range */ 717 if (!res_prev) { 718 switch (res->type) { 719 case IO: 720 bus_cur->firstIO = res; 721 break; 722 case MEM: 723 bus_cur->firstMem = res; 724 break; 725 case PFMEM: 726 bus_cur->firstPFMem = res; 727 break; 728 } 729 } else if (res_prev->rangeno == res_cur->rangeno) 730 res_prev->next = res; 731 else 732 res_prev->nextRange = res; 733 734 res->next = res_cur; 735 res->nextRange = NULL; 736 } 737 } else { 738 /* this is the case where it is 1st occurrence of the range */ 739 if (!res_prev) { 740 /* at the beginning of the resource list */ 741 res->next = NULL; 742 switch (res->type) { 743 case IO: 744 res->nextRange = bus_cur->firstIO; 745 bus_cur->firstIO = res; 746 break; 747 case MEM: 748 res->nextRange = bus_cur->firstMem; 749 bus_cur->firstMem = res; 750 break; 751 case PFMEM: 752 res->nextRange = bus_cur->firstPFMem; 753 bus_cur->firstPFMem = res; 754 break; 755 } 756 } else if (res_cur->rangeno > res->rangeno) { 757 /* in the middle of the resource list */ 758 res_prev->nextRange = res; 759 res->next = NULL; 760 res->nextRange = res_cur; 761 } 762 } 763 } 764 765 debug("%s - exit\n", __func__); 766 return 0; 767 } 768 769 /**************************************************************************** 770 * This routine will remove the resource from the list of resources 771 * 772 * Input: io, mem, and/or pfmem resource to be deleted 773 * Output: modified resource list 774 * 0 or error code 775 ****************************************************************************/ 776 int ibmphp_remove_resource(struct resource_node *res) 777 { 778 struct bus_node *bus_cur; 779 struct resource_node *res_cur = NULL; 780 struct resource_node *res_prev; 781 struct resource_node *mem_cur; 782 char *type = ""; 783 784 if (!res) { 785 err("resource to remove is NULL\n"); 786 return -ENODEV; 787 } 788 789 bus_cur = find_bus_wprev(res->busno, NULL, 0); 790 791 if (!bus_cur) { 792 err("cannot find corresponding bus of the io resource to remove bailing out...\n"); 793 return -ENODEV; 794 } 795 796 switch (res->type) { 797 case IO: 798 res_cur = bus_cur->firstIO; 799 type = "io"; 800 break; 801 case MEM: 802 res_cur = bus_cur->firstMem; 803 type = "mem"; 804 break; 805 case PFMEM: 806 res_cur = bus_cur->firstPFMem; 807 type = "pfmem"; 808 break; 809 default: 810 err("unknown type for resource to remove\n"); 811 return -EINVAL; 812 } 813 res_prev = NULL; 814 815 while (res_cur) { 816 if ((res_cur->start == res->start) && (res_cur->end == res->end)) 817 break; 818 res_prev = res_cur; 819 if (res_cur->next) 820 res_cur = res_cur->next; 821 else 822 res_cur = res_cur->nextRange; 823 } 824 825 if (!res_cur) { 826 if (res->type == PFMEM) { 827 /* 828 * case where pfmem might be in the PFMemFromMem list 829 * so will also need to remove the corresponding mem 830 * entry 831 */ 832 res_cur = bus_cur->firstPFMemFromMem; 833 res_prev = NULL; 834 835 while (res_cur) { 836 if ((res_cur->start == res->start) && (res_cur->end == res->end)) { 837 mem_cur = bus_cur->firstMem; 838 while (mem_cur) { 839 if ((mem_cur->start == res_cur->start) 840 && (mem_cur->end == res_cur->end)) 841 break; 842 if (mem_cur->next) 843 mem_cur = mem_cur->next; 844 else 845 mem_cur = mem_cur->nextRange; 846 } 847 if (!mem_cur) { 848 err("cannot find corresponding mem node for pfmem...\n"); 849 return -EINVAL; 850 } 851 852 ibmphp_remove_resource(mem_cur); 853 if (!res_prev) 854 bus_cur->firstPFMemFromMem = res_cur->next; 855 else 856 res_prev->next = res_cur->next; 857 kfree(res_cur); 858 return 0; 859 } 860 res_prev = res_cur; 861 if (res_cur->next) 862 res_cur = res_cur->next; 863 else 864 res_cur = res_cur->nextRange; 865 } 866 if (!res_cur) { 867 err("cannot find pfmem to delete...\n"); 868 return -EINVAL; 869 } 870 } else { 871 err("the %s resource is not in the list to be deleted...\n", type); 872 return -EINVAL; 873 } 874 } 875 if (!res_prev) { 876 /* first device to be deleted */ 877 if (res_cur->next) { 878 switch (res->type) { 879 case IO: 880 bus_cur->firstIO = res_cur->next; 881 break; 882 case MEM: 883 bus_cur->firstMem = res_cur->next; 884 break; 885 case PFMEM: 886 bus_cur->firstPFMem = res_cur->next; 887 break; 888 } 889 } else if (res_cur->nextRange) { 890 switch (res->type) { 891 case IO: 892 bus_cur->firstIO = res_cur->nextRange; 893 break; 894 case MEM: 895 bus_cur->firstMem = res_cur->nextRange; 896 break; 897 case PFMEM: 898 bus_cur->firstPFMem = res_cur->nextRange; 899 break; 900 } 901 } else { 902 switch (res->type) { 903 case IO: 904 bus_cur->firstIO = NULL; 905 break; 906 case MEM: 907 bus_cur->firstMem = NULL; 908 break; 909 case PFMEM: 910 bus_cur->firstPFMem = NULL; 911 break; 912 } 913 } 914 kfree(res_cur); 915 return 0; 916 } else { 917 if (res_cur->next) { 918 if (res_prev->rangeno == res_cur->rangeno) 919 res_prev->next = res_cur->next; 920 else 921 res_prev->nextRange = res_cur->next; 922 } else if (res_cur->nextRange) { 923 res_prev->next = NULL; 924 res_prev->nextRange = res_cur->nextRange; 925 } else { 926 res_prev->next = NULL; 927 res_prev->nextRange = NULL; 928 } 929 kfree(res_cur); 930 return 0; 931 } 932 933 return 0; 934 } 935 936 static struct range_node *find_range(struct bus_node *bus_cur, struct resource_node *res) 937 { 938 struct range_node *range = NULL; 939 940 switch (res->type) { 941 case IO: 942 range = bus_cur->rangeIO; 943 break; 944 case MEM: 945 range = bus_cur->rangeMem; 946 break; 947 case PFMEM: 948 range = bus_cur->rangePFMem; 949 break; 950 default: 951 err("cannot read resource type in find_range\n"); 952 } 953 954 while (range) { 955 if (res->rangeno == range->rangeno) 956 break; 957 range = range->next; 958 } 959 return range; 960 } 961 962 /***************************************************************************** 963 * This routine will check to make sure the io/mem/pfmem->len that the device asked for 964 * can fit w/i our list of available IO/MEM/PFMEM resources. If cannot, returns -EINVAL, 965 * otherwise, returns 0 966 * 967 * Input: resource 968 * Output: the correct start and end address are inputted into the resource node, 969 * 0 or -EINVAL 970 *****************************************************************************/ 971 int ibmphp_check_resource(struct resource_node *res, u8 bridge) 972 { 973 struct bus_node *bus_cur; 974 struct range_node *range = NULL; 975 struct resource_node *res_prev; 976 struct resource_node *res_cur = NULL; 977 u32 len_cur = 0, start_cur = 0, len_tmp = 0; 978 int noranges = 0; 979 u32 tmp_start; /* this is to make sure start address is divisible by the length needed */ 980 u32 tmp_divide; 981 u8 flag = 0; 982 983 if (!res) 984 return -EINVAL; 985 986 if (bridge) { 987 /* The rules for bridges are different, 4K divisible for IO, 1M for (pf)mem*/ 988 if (res->type == IO) 989 tmp_divide = IOBRIDGE; 990 else 991 tmp_divide = MEMBRIDGE; 992 } else 993 tmp_divide = res->len; 994 995 bus_cur = find_bus_wprev(res->busno, NULL, 0); 996 997 if (!bus_cur) { 998 /* didn't find a bus, something's wrong!!! */ 999 debug("no bus in the system, either pci_dev's wrong or allocation failed\n"); 1000 return -EINVAL; 1001 } 1002 1003 debug("%s - enter\n", __func__); 1004 debug("bus_cur->busno is %d\n", bus_cur->busno); 1005 1006 /* This is a quick fix to not mess up with the code very much. i.e., 1007 * 2000-2fff, len = 1000, but when we compare, we need it to be fff */ 1008 res->len -= 1; 1009 1010 switch (res->type) { 1011 case IO: 1012 res_cur = bus_cur->firstIO; 1013 noranges = bus_cur->noIORanges; 1014 break; 1015 case MEM: 1016 res_cur = bus_cur->firstMem; 1017 noranges = bus_cur->noMemRanges; 1018 break; 1019 case PFMEM: 1020 res_cur = bus_cur->firstPFMem; 1021 noranges = bus_cur->noPFMemRanges; 1022 break; 1023 default: 1024 err("wrong type of resource to check\n"); 1025 return -EINVAL; 1026 } 1027 res_prev = NULL; 1028 1029 while (res_cur) { 1030 range = find_range(bus_cur, res_cur); 1031 debug("%s - rangeno = %d\n", __func__, res_cur->rangeno); 1032 1033 if (!range) { 1034 err("no range for the device exists... bailing out...\n"); 1035 return -EINVAL; 1036 } 1037 1038 /* found our range */ 1039 if (!res_prev) { 1040 /* first time in the loop */ 1041 len_tmp = res_cur->start - 1 - range->start; 1042 1043 if ((res_cur->start != range->start) && (len_tmp >= res->len)) { 1044 debug("len_tmp = %x\n", len_tmp); 1045 1046 if ((len_tmp < len_cur) || (len_cur == 0)) { 1047 1048 if ((range->start % tmp_divide) == 0) { 1049 /* just perfect, starting address is divisible by length */ 1050 flag = 1; 1051 len_cur = len_tmp; 1052 start_cur = range->start; 1053 } else { 1054 /* Needs adjusting */ 1055 tmp_start = range->start; 1056 flag = 0; 1057 1058 while ((len_tmp = res_cur->start - 1 - tmp_start) >= res->len) { 1059 if ((tmp_start % tmp_divide) == 0) { 1060 flag = 1; 1061 len_cur = len_tmp; 1062 start_cur = tmp_start; 1063 break; 1064 } 1065 tmp_start += tmp_divide - tmp_start % tmp_divide; 1066 if (tmp_start >= res_cur->start - 1) 1067 break; 1068 } 1069 } 1070 1071 if (flag && len_cur == res->len) { 1072 debug("but we are not here, right?\n"); 1073 res->start = start_cur; 1074 res->len += 1; /* To restore the balance */ 1075 res->end = res->start + res->len - 1; 1076 return 0; 1077 } 1078 } 1079 } 1080 } 1081 if (!res_cur->next) { 1082 /* last device on the range */ 1083 len_tmp = range->end - (res_cur->end + 1); 1084 1085 if ((range->end != res_cur->end) && (len_tmp >= res->len)) { 1086 debug("len_tmp = %x\n", len_tmp); 1087 if ((len_tmp < len_cur) || (len_cur == 0)) { 1088 1089 if (((res_cur->end + 1) % tmp_divide) == 0) { 1090 /* just perfect, starting address is divisible by length */ 1091 flag = 1; 1092 len_cur = len_tmp; 1093 start_cur = res_cur->end + 1; 1094 } else { 1095 /* Needs adjusting */ 1096 tmp_start = res_cur->end + 1; 1097 flag = 0; 1098 1099 while ((len_tmp = range->end - tmp_start) >= res->len) { 1100 if ((tmp_start % tmp_divide) == 0) { 1101 flag = 1; 1102 len_cur = len_tmp; 1103 start_cur = tmp_start; 1104 break; 1105 } 1106 tmp_start += tmp_divide - tmp_start % tmp_divide; 1107 if (tmp_start >= range->end) 1108 break; 1109 } 1110 } 1111 if (flag && len_cur == res->len) { 1112 res->start = start_cur; 1113 res->len += 1; /* To restore the balance */ 1114 res->end = res->start + res->len - 1; 1115 return 0; 1116 } 1117 } 1118 } 1119 } 1120 1121 if (res_prev) { 1122 if (res_prev->rangeno != res_cur->rangeno) { 1123 /* 1st device on this range */ 1124 len_tmp = res_cur->start - 1 - range->start; 1125 1126 if ((res_cur->start != range->start) && (len_tmp >= res->len)) { 1127 if ((len_tmp < len_cur) || (len_cur == 0)) { 1128 if ((range->start % tmp_divide) == 0) { 1129 /* just perfect, starting address is divisible by length */ 1130 flag = 1; 1131 len_cur = len_tmp; 1132 start_cur = range->start; 1133 } else { 1134 /* Needs adjusting */ 1135 tmp_start = range->start; 1136 flag = 0; 1137 1138 while ((len_tmp = res_cur->start - 1 - tmp_start) >= res->len) { 1139 if ((tmp_start % tmp_divide) == 0) { 1140 flag = 1; 1141 len_cur = len_tmp; 1142 start_cur = tmp_start; 1143 break; 1144 } 1145 tmp_start += tmp_divide - tmp_start % tmp_divide; 1146 if (tmp_start >= res_cur->start - 1) 1147 break; 1148 } 1149 } 1150 1151 if (flag && len_cur == res->len) { 1152 res->start = start_cur; 1153 res->len += 1; /* To restore the balance */ 1154 res->end = res->start + res->len - 1; 1155 return 0; 1156 } 1157 } 1158 } 1159 } else { 1160 /* in the same range */ 1161 len_tmp = res_cur->start - 1 - res_prev->end - 1; 1162 1163 if (len_tmp >= res->len) { 1164 if ((len_tmp < len_cur) || (len_cur == 0)) { 1165 if (((res_prev->end + 1) % tmp_divide) == 0) { 1166 /* just perfect, starting address's divisible by length */ 1167 flag = 1; 1168 len_cur = len_tmp; 1169 start_cur = res_prev->end + 1; 1170 } else { 1171 /* Needs adjusting */ 1172 tmp_start = res_prev->end + 1; 1173 flag = 0; 1174 1175 while ((len_tmp = res_cur->start - 1 - tmp_start) >= res->len) { 1176 if ((tmp_start % tmp_divide) == 0) { 1177 flag = 1; 1178 len_cur = len_tmp; 1179 start_cur = tmp_start; 1180 break; 1181 } 1182 tmp_start += tmp_divide - tmp_start % tmp_divide; 1183 if (tmp_start >= res_cur->start - 1) 1184 break; 1185 } 1186 } 1187 1188 if (flag && len_cur == res->len) { 1189 res->start = start_cur; 1190 res->len += 1; /* To restore the balance */ 1191 res->end = res->start + res->len - 1; 1192 return 0; 1193 } 1194 } 1195 } 1196 } 1197 } 1198 /* end if (res_prev) */ 1199 res_prev = res_cur; 1200 if (res_cur->next) 1201 res_cur = res_cur->next; 1202 else 1203 res_cur = res_cur->nextRange; 1204 } /* end of while */ 1205 1206 1207 if (!res_prev) { 1208 /* 1st device ever */ 1209 /* need to find appropriate range */ 1210 switch (res->type) { 1211 case IO: 1212 range = bus_cur->rangeIO; 1213 break; 1214 case MEM: 1215 range = bus_cur->rangeMem; 1216 break; 1217 case PFMEM: 1218 range = bus_cur->rangePFMem; 1219 break; 1220 } 1221 while (range) { 1222 len_tmp = range->end - range->start; 1223 1224 if (len_tmp >= res->len) { 1225 if ((len_tmp < len_cur) || (len_cur == 0)) { 1226 if ((range->start % tmp_divide) == 0) { 1227 /* just perfect, starting address's divisible by length */ 1228 flag = 1; 1229 len_cur = len_tmp; 1230 start_cur = range->start; 1231 } else { 1232 /* Needs adjusting */ 1233 tmp_start = range->start; 1234 flag = 0; 1235 1236 while ((len_tmp = range->end - tmp_start) >= res->len) { 1237 if ((tmp_start % tmp_divide) == 0) { 1238 flag = 1; 1239 len_cur = len_tmp; 1240 start_cur = tmp_start; 1241 break; 1242 } 1243 tmp_start += tmp_divide - tmp_start % tmp_divide; 1244 if (tmp_start >= range->end) 1245 break; 1246 } 1247 } 1248 1249 if (flag && len_cur == res->len) { 1250 res->start = start_cur; 1251 res->len += 1; /* To restore the balance */ 1252 res->end = res->start + res->len - 1; 1253 return 0; 1254 } 1255 } 1256 } 1257 range = range->next; 1258 } /* end of while */ 1259 1260 if ((!range) && (len_cur == 0)) { 1261 /* have gone through the list of devices and ranges and haven't found n.e.thing */ 1262 err("no appropriate range.. bailing out...\n"); 1263 return -EINVAL; 1264 } else if (len_cur) { 1265 res->start = start_cur; 1266 res->len += 1; /* To restore the balance */ 1267 res->end = res->start + res->len - 1; 1268 return 0; 1269 } 1270 } 1271 1272 if (!res_cur) { 1273 debug("prev->rangeno = %d, noranges = %d\n", res_prev->rangeno, noranges); 1274 if (res_prev->rangeno < noranges) { 1275 /* if there're more ranges out there to check */ 1276 switch (res->type) { 1277 case IO: 1278 range = bus_cur->rangeIO; 1279 break; 1280 case MEM: 1281 range = bus_cur->rangeMem; 1282 break; 1283 case PFMEM: 1284 range = bus_cur->rangePFMem; 1285 break; 1286 } 1287 while (range) { 1288 len_tmp = range->end - range->start; 1289 1290 if (len_tmp >= res->len) { 1291 if ((len_tmp < len_cur) || (len_cur == 0)) { 1292 if ((range->start % tmp_divide) == 0) { 1293 /* just perfect, starting address's divisible by length */ 1294 flag = 1; 1295 len_cur = len_tmp; 1296 start_cur = range->start; 1297 } else { 1298 /* Needs adjusting */ 1299 tmp_start = range->start; 1300 flag = 0; 1301 1302 while ((len_tmp = range->end - tmp_start) >= res->len) { 1303 if ((tmp_start % tmp_divide) == 0) { 1304 flag = 1; 1305 len_cur = len_tmp; 1306 start_cur = tmp_start; 1307 break; 1308 } 1309 tmp_start += tmp_divide - tmp_start % tmp_divide; 1310 if (tmp_start >= range->end) 1311 break; 1312 } 1313 } 1314 1315 if (flag && len_cur == res->len) { 1316 res->start = start_cur; 1317 res->len += 1; /* To restore the balance */ 1318 res->end = res->start + res->len - 1; 1319 return 0; 1320 } 1321 } 1322 } 1323 range = range->next; 1324 } /* end of while */ 1325 1326 if ((!range) && (len_cur == 0)) { 1327 /* have gone through the list of devices and ranges and haven't found n.e.thing */ 1328 err("no appropriate range.. bailing out...\n"); 1329 return -EINVAL; 1330 } else if (len_cur) { 1331 res->start = start_cur; 1332 res->len += 1; /* To restore the balance */ 1333 res->end = res->start + res->len - 1; 1334 return 0; 1335 } 1336 } else { 1337 /* no more ranges to check on */ 1338 if (len_cur) { 1339 res->start = start_cur; 1340 res->len += 1; /* To restore the balance */ 1341 res->end = res->start + res->len - 1; 1342 return 0; 1343 } else { 1344 /* have gone through the list of devices and haven't found n.e.thing */ 1345 err("no appropriate range.. bailing out...\n"); 1346 return -EINVAL; 1347 } 1348 } 1349 } /* end if (!res_cur) */ 1350 return -EINVAL; 1351 } 1352 1353 /******************************************************************************** 1354 * This routine is called from remove_card if the card contained PPB. 1355 * It will remove all the resources on the bus as well as the bus itself 1356 * Input: Bus 1357 * Output: 0, -ENODEV 1358 ********************************************************************************/ 1359 int ibmphp_remove_bus(struct bus_node *bus, u8 parent_busno) 1360 { 1361 struct resource_node *res_cur; 1362 struct resource_node *res_tmp; 1363 struct bus_node *prev_bus; 1364 int rc; 1365 1366 prev_bus = find_bus_wprev(parent_busno, NULL, 0); 1367 1368 if (!prev_bus) { 1369 debug("something terribly wrong. Cannot find parent bus to the one to remove\n"); 1370 return -ENODEV; 1371 } 1372 1373 debug("In ibmphp_remove_bus... prev_bus->busno is %x\n", prev_bus->busno); 1374 1375 rc = remove_ranges(bus, prev_bus); 1376 if (rc) 1377 return rc; 1378 1379 if (bus->firstIO) { 1380 res_cur = bus->firstIO; 1381 while (res_cur) { 1382 res_tmp = res_cur; 1383 if (res_cur->next) 1384 res_cur = res_cur->next; 1385 else 1386 res_cur = res_cur->nextRange; 1387 kfree(res_tmp); 1388 res_tmp = NULL; 1389 } 1390 bus->firstIO = NULL; 1391 } 1392 if (bus->firstMem) { 1393 res_cur = bus->firstMem; 1394 while (res_cur) { 1395 res_tmp = res_cur; 1396 if (res_cur->next) 1397 res_cur = res_cur->next; 1398 else 1399 res_cur = res_cur->nextRange; 1400 kfree(res_tmp); 1401 res_tmp = NULL; 1402 } 1403 bus->firstMem = NULL; 1404 } 1405 if (bus->firstPFMem) { 1406 res_cur = bus->firstPFMem; 1407 while (res_cur) { 1408 res_tmp = res_cur; 1409 if (res_cur->next) 1410 res_cur = res_cur->next; 1411 else 1412 res_cur = res_cur->nextRange; 1413 kfree(res_tmp); 1414 res_tmp = NULL; 1415 } 1416 bus->firstPFMem = NULL; 1417 } 1418 1419 if (bus->firstPFMemFromMem) { 1420 res_cur = bus->firstPFMemFromMem; 1421 while (res_cur) { 1422 res_tmp = res_cur; 1423 res_cur = res_cur->next; 1424 1425 kfree(res_tmp); 1426 res_tmp = NULL; 1427 } 1428 bus->firstPFMemFromMem = NULL; 1429 } 1430 1431 list_del(&bus->bus_list); 1432 kfree(bus); 1433 return 0; 1434 } 1435 1436 /****************************************************************************** 1437 * This routine deletes the ranges from a given bus, and the entries from the 1438 * parent's bus in the resources 1439 * Input: current bus, previous bus 1440 * Output: 0, -EINVAL 1441 ******************************************************************************/ 1442 static int remove_ranges(struct bus_node *bus_cur, struct bus_node *bus_prev) 1443 { 1444 struct range_node *range_cur; 1445 struct range_node *range_tmp; 1446 int i; 1447 struct resource_node *res = NULL; 1448 1449 if (bus_cur->noIORanges) { 1450 range_cur = bus_cur->rangeIO; 1451 for (i = 0; i < bus_cur->noIORanges; i++) { 1452 if (ibmphp_find_resource(bus_prev, range_cur->start, &res, IO) < 0) 1453 return -EINVAL; 1454 ibmphp_remove_resource(res); 1455 1456 range_tmp = range_cur; 1457 range_cur = range_cur->next; 1458 kfree(range_tmp); 1459 range_tmp = NULL; 1460 } 1461 bus_cur->rangeIO = NULL; 1462 } 1463 if (bus_cur->noMemRanges) { 1464 range_cur = bus_cur->rangeMem; 1465 for (i = 0; i < bus_cur->noMemRanges; i++) { 1466 if (ibmphp_find_resource(bus_prev, range_cur->start, &res, MEM) < 0) 1467 return -EINVAL; 1468 1469 ibmphp_remove_resource(res); 1470 range_tmp = range_cur; 1471 range_cur = range_cur->next; 1472 kfree(range_tmp); 1473 range_tmp = NULL; 1474 } 1475 bus_cur->rangeMem = NULL; 1476 } 1477 if (bus_cur->noPFMemRanges) { 1478 range_cur = bus_cur->rangePFMem; 1479 for (i = 0; i < bus_cur->noPFMemRanges; i++) { 1480 if (ibmphp_find_resource(bus_prev, range_cur->start, &res, PFMEM) < 0) 1481 return -EINVAL; 1482 1483 ibmphp_remove_resource(res); 1484 range_tmp = range_cur; 1485 range_cur = range_cur->next; 1486 kfree(range_tmp); 1487 range_tmp = NULL; 1488 } 1489 bus_cur->rangePFMem = NULL; 1490 } 1491 return 0; 1492 } 1493 1494 /* 1495 * find the resource node in the bus 1496 * Input: Resource needed, start address of the resource, type of resource 1497 */ 1498 int ibmphp_find_resource(struct bus_node *bus, u32 start_address, struct resource_node **res, int flag) 1499 { 1500 struct resource_node *res_cur = NULL; 1501 char *type = ""; 1502 1503 if (!bus) { 1504 err("The bus passed in NULL to find resource\n"); 1505 return -ENODEV; 1506 } 1507 1508 switch (flag) { 1509 case IO: 1510 res_cur = bus->firstIO; 1511 type = "io"; 1512 break; 1513 case MEM: 1514 res_cur = bus->firstMem; 1515 type = "mem"; 1516 break; 1517 case PFMEM: 1518 res_cur = bus->firstPFMem; 1519 type = "pfmem"; 1520 break; 1521 default: 1522 err("wrong type of flag\n"); 1523 return -EINVAL; 1524 } 1525 1526 while (res_cur) { 1527 if (res_cur->start == start_address) { 1528 *res = res_cur; 1529 break; 1530 } 1531 if (res_cur->next) 1532 res_cur = res_cur->next; 1533 else 1534 res_cur = res_cur->nextRange; 1535 } 1536 1537 if (!res_cur) { 1538 if (flag == PFMEM) { 1539 res_cur = bus->firstPFMemFromMem; 1540 while (res_cur) { 1541 if (res_cur->start == start_address) { 1542 *res = res_cur; 1543 break; 1544 } 1545 res_cur = res_cur->next; 1546 } 1547 if (!res_cur) { 1548 debug("SOS...cannot find %s resource in the bus.\n", type); 1549 return -EINVAL; 1550 } 1551 } else { 1552 debug("SOS... cannot find %s resource in the bus.\n", type); 1553 return -EINVAL; 1554 } 1555 } 1556 1557 if (*res) 1558 debug("*res->start = %x\n", (*res)->start); 1559 1560 return 0; 1561 } 1562 1563 /*********************************************************************** 1564 * This routine will free the resource structures used by the 1565 * system. It is called from cleanup routine for the module 1566 * Parameters: none 1567 * Returns: none 1568 ***********************************************************************/ 1569 void ibmphp_free_resources(void) 1570 { 1571 struct bus_node *bus_cur = NULL, *next; 1572 struct bus_node *bus_tmp; 1573 struct range_node *range_cur; 1574 struct range_node *range_tmp; 1575 struct resource_node *res_cur; 1576 struct resource_node *res_tmp; 1577 int i = 0; 1578 flags = 1; 1579 1580 list_for_each_entry_safe(bus_cur, next, &gbuses, bus_list) { 1581 if (bus_cur->noIORanges) { 1582 range_cur = bus_cur->rangeIO; 1583 for (i = 0; i < bus_cur->noIORanges; i++) { 1584 if (!range_cur) 1585 break; 1586 range_tmp = range_cur; 1587 range_cur = range_cur->next; 1588 kfree(range_tmp); 1589 range_tmp = NULL; 1590 } 1591 } 1592 if (bus_cur->noMemRanges) { 1593 range_cur = bus_cur->rangeMem; 1594 for (i = 0; i < bus_cur->noMemRanges; i++) { 1595 if (!range_cur) 1596 break; 1597 range_tmp = range_cur; 1598 range_cur = range_cur->next; 1599 kfree(range_tmp); 1600 range_tmp = NULL; 1601 } 1602 } 1603 if (bus_cur->noPFMemRanges) { 1604 range_cur = bus_cur->rangePFMem; 1605 for (i = 0; i < bus_cur->noPFMemRanges; i++) { 1606 if (!range_cur) 1607 break; 1608 range_tmp = range_cur; 1609 range_cur = range_cur->next; 1610 kfree(range_tmp); 1611 range_tmp = NULL; 1612 } 1613 } 1614 1615 if (bus_cur->firstIO) { 1616 res_cur = bus_cur->firstIO; 1617 while (res_cur) { 1618 res_tmp = res_cur; 1619 if (res_cur->next) 1620 res_cur = res_cur->next; 1621 else 1622 res_cur = res_cur->nextRange; 1623 kfree(res_tmp); 1624 res_tmp = NULL; 1625 } 1626 bus_cur->firstIO = NULL; 1627 } 1628 if (bus_cur->firstMem) { 1629 res_cur = bus_cur->firstMem; 1630 while (res_cur) { 1631 res_tmp = res_cur; 1632 if (res_cur->next) 1633 res_cur = res_cur->next; 1634 else 1635 res_cur = res_cur->nextRange; 1636 kfree(res_tmp); 1637 res_tmp = NULL; 1638 } 1639 bus_cur->firstMem = NULL; 1640 } 1641 if (bus_cur->firstPFMem) { 1642 res_cur = bus_cur->firstPFMem; 1643 while (res_cur) { 1644 res_tmp = res_cur; 1645 if (res_cur->next) 1646 res_cur = res_cur->next; 1647 else 1648 res_cur = res_cur->nextRange; 1649 kfree(res_tmp); 1650 res_tmp = NULL; 1651 } 1652 bus_cur->firstPFMem = NULL; 1653 } 1654 1655 if (bus_cur->firstPFMemFromMem) { 1656 res_cur = bus_cur->firstPFMemFromMem; 1657 while (res_cur) { 1658 res_tmp = res_cur; 1659 res_cur = res_cur->next; 1660 1661 kfree(res_tmp); 1662 res_tmp = NULL; 1663 } 1664 bus_cur->firstPFMemFromMem = NULL; 1665 } 1666 1667 bus_tmp = bus_cur; 1668 list_del(&bus_cur->bus_list); 1669 kfree(bus_tmp); 1670 bus_tmp = NULL; 1671 } 1672 } 1673 1674 /********************************************************************************* 1675 * This function will go over the PFmem resources to check if the EBDA allocated 1676 * pfmem out of memory buckets of the bus. If so, it will change the range numbers 1677 * and a flag to indicate that this resource is out of memory. It will also move the 1678 * Pfmem out of the pfmem resource list to the PFMemFromMem list, and will create 1679 * a new Mem node 1680 * This routine is called right after initialization 1681 *******************************************************************************/ 1682 static int __init once_over(void) 1683 { 1684 struct resource_node *pfmem_cur; 1685 struct resource_node *pfmem_prev; 1686 struct resource_node *mem; 1687 struct bus_node *bus_cur; 1688 1689 list_for_each_entry(bus_cur, &gbuses, bus_list) { 1690 if ((!bus_cur->rangePFMem) && (bus_cur->firstPFMem)) { 1691 for (pfmem_cur = bus_cur->firstPFMem, pfmem_prev = NULL; pfmem_cur; pfmem_prev = pfmem_cur, pfmem_cur = pfmem_cur->next) { 1692 pfmem_cur->fromMem = 1; 1693 if (pfmem_prev) 1694 pfmem_prev->next = pfmem_cur->next; 1695 else 1696 bus_cur->firstPFMem = pfmem_cur->next; 1697 1698 if (!bus_cur->firstPFMemFromMem) 1699 pfmem_cur->next = NULL; 1700 else 1701 /* we don't need to sort PFMemFromMem since we're using mem node for 1702 all the real work anyways, so just insert at the beginning of the 1703 list 1704 */ 1705 pfmem_cur->next = bus_cur->firstPFMemFromMem; 1706 1707 bus_cur->firstPFMemFromMem = pfmem_cur; 1708 1709 mem = kzalloc(sizeof(struct resource_node), GFP_KERNEL); 1710 if (!mem) { 1711 err("out of system memory\n"); 1712 return -ENOMEM; 1713 } 1714 mem->type = MEM; 1715 mem->busno = pfmem_cur->busno; 1716 mem->devfunc = pfmem_cur->devfunc; 1717 mem->start = pfmem_cur->start; 1718 mem->end = pfmem_cur->end; 1719 mem->len = pfmem_cur->len; 1720 if (ibmphp_add_resource(mem) < 0) 1721 err("Trouble...trouble... EBDA allocated pfmem from mem, but system doesn't display it has this space... unless not PCI device...\n"); 1722 pfmem_cur->rangeno = mem->rangeno; 1723 } /* end for pfmem */ 1724 } /* end if */ 1725 } /* end list_for_each bus */ 1726 return 0; 1727 } 1728 1729 int ibmphp_add_pfmem_from_mem(struct resource_node *pfmem) 1730 { 1731 struct bus_node *bus_cur = find_bus_wprev(pfmem->busno, NULL, 0); 1732 1733 if (!bus_cur) { 1734 err("cannot find bus of pfmem to add...\n"); 1735 return -ENODEV; 1736 } 1737 1738 if (bus_cur->firstPFMemFromMem) 1739 pfmem->next = bus_cur->firstPFMemFromMem; 1740 else 1741 pfmem->next = NULL; 1742 1743 bus_cur->firstPFMemFromMem = pfmem; 1744 1745 return 0; 1746 } 1747 1748 /* This routine just goes through the buses to see if the bus already exists. 1749 * It is called from ibmphp_find_sec_number, to find out a secondary bus number for 1750 * bridged cards 1751 * Parameters: bus_number 1752 * Returns: Bus pointer or NULL 1753 */ 1754 struct bus_node *ibmphp_find_res_bus(u8 bus_number) 1755 { 1756 return find_bus_wprev(bus_number, NULL, 0); 1757 } 1758 1759 static struct bus_node *find_bus_wprev(u8 bus_number, struct bus_node **prev, u8 flag) 1760 { 1761 struct bus_node *bus_cur; 1762 1763 list_for_each_entry(bus_cur, &gbuses, bus_list) { 1764 if (flag) 1765 *prev = list_prev_entry(bus_cur, bus_list); 1766 if (bus_cur->busno == bus_number) 1767 return bus_cur; 1768 } 1769 1770 return NULL; 1771 } 1772 1773 void ibmphp_print_test(void) 1774 { 1775 int i = 0; 1776 struct bus_node *bus_cur = NULL; 1777 struct range_node *range; 1778 struct resource_node *res; 1779 1780 debug_pci("*****************START**********************\n"); 1781 1782 if ((!list_empty(&gbuses)) && flags) { 1783 err("The GBUSES is not NULL?!?!?!?!?\n"); 1784 return; 1785 } 1786 1787 list_for_each_entry(bus_cur, &gbuses, bus_list) { 1788 debug_pci ("This is bus # %d. There are\n", bus_cur->busno); 1789 debug_pci ("IORanges = %d\t", bus_cur->noIORanges); 1790 debug_pci ("MemRanges = %d\t", bus_cur->noMemRanges); 1791 debug_pci ("PFMemRanges = %d\n", bus_cur->noPFMemRanges); 1792 debug_pci ("The IO Ranges are as follows:\n"); 1793 if (bus_cur->rangeIO) { 1794 range = bus_cur->rangeIO; 1795 for (i = 0; i < bus_cur->noIORanges; i++) { 1796 debug_pci("rangeno is %d\n", range->rangeno); 1797 debug_pci("[%x - %x]\n", range->start, range->end); 1798 range = range->next; 1799 } 1800 } 1801 1802 debug_pci("The Mem Ranges are as follows:\n"); 1803 if (bus_cur->rangeMem) { 1804 range = bus_cur->rangeMem; 1805 for (i = 0; i < bus_cur->noMemRanges; i++) { 1806 debug_pci("rangeno is %d\n", range->rangeno); 1807 debug_pci("[%x - %x]\n", range->start, range->end); 1808 range = range->next; 1809 } 1810 } 1811 1812 debug_pci("The PFMem Ranges are as follows:\n"); 1813 1814 if (bus_cur->rangePFMem) { 1815 range = bus_cur->rangePFMem; 1816 for (i = 0; i < bus_cur->noPFMemRanges; i++) { 1817 debug_pci("rangeno is %d\n", range->rangeno); 1818 debug_pci("[%x - %x]\n", range->start, range->end); 1819 range = range->next; 1820 } 1821 } 1822 1823 debug_pci("The resources on this bus are as follows\n"); 1824 1825 debug_pci("IO...\n"); 1826 if (bus_cur->firstIO) { 1827 res = bus_cur->firstIO; 1828 while (res) { 1829 debug_pci("The range # is %d\n", res->rangeno); 1830 debug_pci("The bus, devfnc is %d, %x\n", res->busno, res->devfunc); 1831 debug_pci("[%x - %x], len=%x\n", res->start, res->end, res->len); 1832 if (res->next) 1833 res = res->next; 1834 else if (res->nextRange) 1835 res = res->nextRange; 1836 else 1837 break; 1838 } 1839 } 1840 debug_pci("Mem...\n"); 1841 if (bus_cur->firstMem) { 1842 res = bus_cur->firstMem; 1843 while (res) { 1844 debug_pci("The range # is %d\n", res->rangeno); 1845 debug_pci("The bus, devfnc is %d, %x\n", res->busno, res->devfunc); 1846 debug_pci("[%x - %x], len=%x\n", res->start, res->end, res->len); 1847 if (res->next) 1848 res = res->next; 1849 else if (res->nextRange) 1850 res = res->nextRange; 1851 else 1852 break; 1853 } 1854 } 1855 debug_pci("PFMem...\n"); 1856 if (bus_cur->firstPFMem) { 1857 res = bus_cur->firstPFMem; 1858 while (res) { 1859 debug_pci("The range # is %d\n", res->rangeno); 1860 debug_pci("The bus, devfnc is %d, %x\n", res->busno, res->devfunc); 1861 debug_pci("[%x - %x], len=%x\n", res->start, res->end, res->len); 1862 if (res->next) 1863 res = res->next; 1864 else if (res->nextRange) 1865 res = res->nextRange; 1866 else 1867 break; 1868 } 1869 } 1870 1871 debug_pci("PFMemFromMem...\n"); 1872 if (bus_cur->firstPFMemFromMem) { 1873 res = bus_cur->firstPFMemFromMem; 1874 while (res) { 1875 debug_pci("The range # is %d\n", res->rangeno); 1876 debug_pci("The bus, devfnc is %d, %x\n", res->busno, res->devfunc); 1877 debug_pci("[%x - %x], len=%x\n", res->start, res->end, res->len); 1878 res = res->next; 1879 } 1880 } 1881 } 1882 debug_pci("***********************END***********************\n"); 1883 } 1884 1885 static int range_exists_already(struct range_node *range, struct bus_node *bus_cur, u8 type) 1886 { 1887 struct range_node *range_cur = NULL; 1888 switch (type) { 1889 case IO: 1890 range_cur = bus_cur->rangeIO; 1891 break; 1892 case MEM: 1893 range_cur = bus_cur->rangeMem; 1894 break; 1895 case PFMEM: 1896 range_cur = bus_cur->rangePFMem; 1897 break; 1898 default: 1899 err("wrong type passed to find out if range already exists\n"); 1900 return -ENODEV; 1901 } 1902 1903 while (range_cur) { 1904 if ((range_cur->start == range->start) && (range_cur->end == range->end)) 1905 return 1; 1906 range_cur = range_cur->next; 1907 } 1908 1909 return 0; 1910 } 1911 1912 /* This routine will read the windows for any PPB we have and update the 1913 * range info for the secondary bus, and will also input this info into 1914 * primary bus, since BIOS doesn't. This is for PPB that are in the system 1915 * on bootup. For bridged cards that were added during previous load of the 1916 * driver, only the ranges and the bus structure are added, the devices are 1917 * added from NVRAM 1918 * Input: primary busno 1919 * Returns: none 1920 * Note: this function doesn't take into account IO restrictions etc, 1921 * so will only work for bridges with no video/ISA devices behind them It 1922 * also will not work for onboard PPBs that can have more than 1 *bus 1923 * behind them All these are TO DO. 1924 * Also need to add more error checkings... (from fnc returns etc) 1925 */ 1926 static int __init update_bridge_ranges(struct bus_node **bus) 1927 { 1928 u8 sec_busno, device, function, hdr_type, start_io_address, end_io_address; 1929 u16 vendor_id, upper_io_start, upper_io_end, start_mem_address, end_mem_address; 1930 u32 start_address, end_address, upper_start, upper_end; 1931 struct bus_node *bus_sec; 1932 struct bus_node *bus_cur; 1933 struct resource_node *io; 1934 struct resource_node *mem; 1935 struct resource_node *pfmem; 1936 struct range_node *range; 1937 unsigned int devfn; 1938 1939 bus_cur = *bus; 1940 if (!bus_cur) 1941 return -ENODEV; 1942 ibmphp_pci_bus->number = bus_cur->busno; 1943 1944 debug("inside %s\n", __func__); 1945 debug("bus_cur->busno = %x\n", bus_cur->busno); 1946 1947 for (device = 0; device < 32; device++) { 1948 for (function = 0x00; function < 0x08; function++) { 1949 devfn = PCI_DEVFN(device, function); 1950 pci_bus_read_config_word(ibmphp_pci_bus, devfn, PCI_VENDOR_ID, &vendor_id); 1951 1952 if (vendor_id != PCI_VENDOR_ID_NOTVALID) { 1953 /* found correct device!!! */ 1954 pci_bus_read_config_byte(ibmphp_pci_bus, devfn, PCI_HEADER_TYPE, &hdr_type); 1955 1956 switch (hdr_type) { 1957 case PCI_HEADER_TYPE_NORMAL: 1958 function = 0x8; 1959 break; 1960 case PCI_HEADER_TYPE_MULTIDEVICE: 1961 break; 1962 case PCI_HEADER_TYPE_BRIDGE: 1963 function = 0x8; 1964 case PCI_HEADER_TYPE_MULTIBRIDGE: 1965 /* We assume here that only 1 bus behind the bridge 1966 TO DO: add functionality for several: 1967 temp = secondary; 1968 while (temp < subordinate) { 1969 ... 1970 temp++; 1971 } 1972 */ 1973 pci_bus_read_config_byte(ibmphp_pci_bus, devfn, PCI_SECONDARY_BUS, &sec_busno); 1974 bus_sec = find_bus_wprev(sec_busno, NULL, 0); 1975 /* this bus structure doesn't exist yet, PPB was configured during previous loading of ibmphp */ 1976 if (!bus_sec) { 1977 bus_sec = alloc_error_bus(NULL, sec_busno, 1); 1978 /* the rest will be populated during NVRAM call */ 1979 return 0; 1980 } 1981 pci_bus_read_config_byte(ibmphp_pci_bus, devfn, PCI_IO_BASE, &start_io_address); 1982 pci_bus_read_config_byte(ibmphp_pci_bus, devfn, PCI_IO_LIMIT, &end_io_address); 1983 pci_bus_read_config_word(ibmphp_pci_bus, devfn, PCI_IO_BASE_UPPER16, &upper_io_start); 1984 pci_bus_read_config_word(ibmphp_pci_bus, devfn, PCI_IO_LIMIT_UPPER16, &upper_io_end); 1985 start_address = (start_io_address & PCI_IO_RANGE_MASK) << 8; 1986 start_address |= (upper_io_start << 16); 1987 end_address = (end_io_address & PCI_IO_RANGE_MASK) << 8; 1988 end_address |= (upper_io_end << 16); 1989 1990 if ((start_address) && (start_address <= end_address)) { 1991 range = kzalloc(sizeof(struct range_node), GFP_KERNEL); 1992 if (!range) { 1993 err("out of system memory\n"); 1994 return -ENOMEM; 1995 } 1996 range->start = start_address; 1997 range->end = end_address + 0xfff; 1998 1999 if (bus_sec->noIORanges > 0) { 2000 if (!range_exists_already(range, bus_sec, IO)) { 2001 add_bus_range(IO, range, bus_sec); 2002 ++bus_sec->noIORanges; 2003 } else { 2004 kfree(range); 2005 range = NULL; 2006 } 2007 } else { 2008 /* 1st IO Range on the bus */ 2009 range->rangeno = 1; 2010 bus_sec->rangeIO = range; 2011 ++bus_sec->noIORanges; 2012 } 2013 fix_resources(bus_sec); 2014 2015 if (ibmphp_find_resource(bus_cur, start_address, &io, IO)) { 2016 io = kzalloc(sizeof(struct resource_node), GFP_KERNEL); 2017 if (!io) { 2018 kfree(range); 2019 err("out of system memory\n"); 2020 return -ENOMEM; 2021 } 2022 io->type = IO; 2023 io->busno = bus_cur->busno; 2024 io->devfunc = ((device << 3) | (function & 0x7)); 2025 io->start = start_address; 2026 io->end = end_address + 0xfff; 2027 io->len = io->end - io->start + 1; 2028 ibmphp_add_resource(io); 2029 } 2030 } 2031 2032 pci_bus_read_config_word(ibmphp_pci_bus, devfn, PCI_MEMORY_BASE, &start_mem_address); 2033 pci_bus_read_config_word(ibmphp_pci_bus, devfn, PCI_MEMORY_LIMIT, &end_mem_address); 2034 2035 start_address = 0x00000000 | (start_mem_address & PCI_MEMORY_RANGE_MASK) << 16; 2036 end_address = 0x00000000 | (end_mem_address & PCI_MEMORY_RANGE_MASK) << 16; 2037 2038 if ((start_address) && (start_address <= end_address)) { 2039 2040 range = kzalloc(sizeof(struct range_node), GFP_KERNEL); 2041 if (!range) { 2042 err("out of system memory\n"); 2043 return -ENOMEM; 2044 } 2045 range->start = start_address; 2046 range->end = end_address + 0xfffff; 2047 2048 if (bus_sec->noMemRanges > 0) { 2049 if (!range_exists_already(range, bus_sec, MEM)) { 2050 add_bus_range(MEM, range, bus_sec); 2051 ++bus_sec->noMemRanges; 2052 } else { 2053 kfree(range); 2054 range = NULL; 2055 } 2056 } else { 2057 /* 1st Mem Range on the bus */ 2058 range->rangeno = 1; 2059 bus_sec->rangeMem = range; 2060 ++bus_sec->noMemRanges; 2061 } 2062 2063 fix_resources(bus_sec); 2064 2065 if (ibmphp_find_resource(bus_cur, start_address, &mem, MEM)) { 2066 mem = kzalloc(sizeof(struct resource_node), GFP_KERNEL); 2067 if (!mem) { 2068 kfree(range); 2069 err("out of system memory\n"); 2070 return -ENOMEM; 2071 } 2072 mem->type = MEM; 2073 mem->busno = bus_cur->busno; 2074 mem->devfunc = ((device << 3) | (function & 0x7)); 2075 mem->start = start_address; 2076 mem->end = end_address + 0xfffff; 2077 mem->len = mem->end - mem->start + 1; 2078 ibmphp_add_resource(mem); 2079 } 2080 } 2081 pci_bus_read_config_word(ibmphp_pci_bus, devfn, PCI_PREF_MEMORY_BASE, &start_mem_address); 2082 pci_bus_read_config_word(ibmphp_pci_bus, devfn, PCI_PREF_MEMORY_LIMIT, &end_mem_address); 2083 pci_bus_read_config_dword(ibmphp_pci_bus, devfn, PCI_PREF_BASE_UPPER32, &upper_start); 2084 pci_bus_read_config_dword(ibmphp_pci_bus, devfn, PCI_PREF_LIMIT_UPPER32, &upper_end); 2085 start_address = 0x00000000 | (start_mem_address & PCI_MEMORY_RANGE_MASK) << 16; 2086 end_address = 0x00000000 | (end_mem_address & PCI_MEMORY_RANGE_MASK) << 16; 2087 #if BITS_PER_LONG == 64 2088 start_address |= ((long) upper_start) << 32; 2089 end_address |= ((long) upper_end) << 32; 2090 #endif 2091 2092 if ((start_address) && (start_address <= end_address)) { 2093 2094 range = kzalloc(sizeof(struct range_node), GFP_KERNEL); 2095 if (!range) { 2096 err("out of system memory\n"); 2097 return -ENOMEM; 2098 } 2099 range->start = start_address; 2100 range->end = end_address + 0xfffff; 2101 2102 if (bus_sec->noPFMemRanges > 0) { 2103 if (!range_exists_already(range, bus_sec, PFMEM)) { 2104 add_bus_range(PFMEM, range, bus_sec); 2105 ++bus_sec->noPFMemRanges; 2106 } else { 2107 kfree(range); 2108 range = NULL; 2109 } 2110 } else { 2111 /* 1st PFMem Range on the bus */ 2112 range->rangeno = 1; 2113 bus_sec->rangePFMem = range; 2114 ++bus_sec->noPFMemRanges; 2115 } 2116 2117 fix_resources(bus_sec); 2118 if (ibmphp_find_resource(bus_cur, start_address, &pfmem, PFMEM)) { 2119 pfmem = kzalloc(sizeof(struct resource_node), GFP_KERNEL); 2120 if (!pfmem) { 2121 kfree(range); 2122 err("out of system memory\n"); 2123 return -ENOMEM; 2124 } 2125 pfmem->type = PFMEM; 2126 pfmem->busno = bus_cur->busno; 2127 pfmem->devfunc = ((device << 3) | (function & 0x7)); 2128 pfmem->start = start_address; 2129 pfmem->end = end_address + 0xfffff; 2130 pfmem->len = pfmem->end - pfmem->start + 1; 2131 pfmem->fromMem = 0; 2132 2133 ibmphp_add_resource(pfmem); 2134 } 2135 } 2136 break; 2137 } /* end of switch */ 2138 } /* end if vendor */ 2139 } /* end for function */ 2140 } /* end for device */ 2141 2142 bus = &bus_cur; 2143 return 0; 2144 } 2145