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 list_head *tmp; 207 struct resource_node *new_io = NULL; 208 struct resource_node *new_mem = NULL; 209 struct resource_node *new_pfmem = NULL; 210 int rc; 211 struct list_head *tmp_ebda; 212 213 list_for_each (tmp_ebda, &ibmphp_ebda_pci_rsrc_head) { 214 curr = list_entry (tmp_ebda, struct ebda_pci_rsrc, ebda_pci_rsrc_list); 215 if (!(curr->rsrc_type & PCIDEVMASK)) { 216 /* EBDA still lists non PCI devices, so ignore... */ 217 debug ("this is not a PCI DEVICE in rsrc_init, please take care\n"); 218 // continue; 219 } 220 221 /* this is a primary bus resource */ 222 if (curr->rsrc_type & PRIMARYBUSMASK) { 223 /* memory */ 224 if ((curr->rsrc_type & RESTYPE) == MMASK) { 225 /* no bus structure exists in place yet */ 226 if (list_empty (&gbuses)) { 227 if ((rc = alloc_bus_range (&newbus, &newrange, curr, MEM, 1))) 228 return rc; 229 list_add_tail (&newbus->bus_list, &gbuses); 230 debug ("gbuses = NULL, Memory Primary Bus %x [%x - %x]\n", newbus->busno, newrange->start, newrange->end); 231 } else { 232 bus_cur = find_bus_wprev (curr->bus_num, &bus_prev, 1); 233 /* found our bus */ 234 if (bus_cur) { 235 rc = alloc_bus_range (&bus_cur, &newrange, curr, MEM, 0); 236 if (rc) 237 return rc; 238 } else { 239 /* went through all the buses and didn't find ours, need to create a new bus node */ 240 if ((rc = alloc_bus_range (&newbus, &newrange, curr, MEM, 1))) 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 if ((rc = alloc_bus_range (&newbus, &newrange, curr, PFMEM, 1))) 252 return rc; 253 list_add_tail (&newbus->bus_list, &gbuses); 254 debug ("gbuses = NULL, PFMemory Primary Bus %x [%x - %x]\n", newbus->busno, newrange->start, newrange->end); 255 } else { 256 bus_cur = find_bus_wprev (curr->bus_num, &bus_prev, 1); 257 if (bus_cur) { 258 /* found our bus */ 259 rc = alloc_bus_range (&bus_cur, &newrange, curr, PFMEM, 0); 260 if (rc) 261 return rc; 262 } else { 263 /* went through all the buses and didn't find ours, need to create a new bus node */ 264 if ((rc = alloc_bus_range (&newbus, &newrange, curr, PFMEM, 1))) 265 return rc; 266 list_add_tail (&newbus->bus_list, &gbuses); 267 debug ("1st Bus, PFMemory Primary Bus %x [%x - %x]\n", newbus->busno, newrange->start, newrange->end); 268 } 269 } 270 } else if ((curr->rsrc_type & RESTYPE) == IOMASK) { 271 /* IO */ 272 if (list_empty (&gbuses)) { 273 /* no bus structure exists in place yet */ 274 if ((rc = alloc_bus_range (&newbus, &newrange, curr, IO, 1))) 275 return rc; 276 list_add_tail (&newbus->bus_list, &gbuses); 277 debug ("gbuses = NULL, IO Primary Bus %x [%x - %x]\n", newbus->busno, newrange->start, newrange->end); 278 } else { 279 bus_cur = find_bus_wprev (curr->bus_num, &bus_prev, 1); 280 if (bus_cur) { 281 rc = alloc_bus_range (&bus_cur, &newrange, curr, IO, 0); 282 if (rc) 283 return rc; 284 } else { 285 /* went through all the buses and didn't find ours, need to create a new bus node */ 286 if ((rc = alloc_bus_range (&newbus, &newrange, curr, IO, 1))) 287 return rc; 288 list_add_tail (&newbus->bus_list, &gbuses); 289 debug ("1st Bus, IO Primary Bus %x [%x - %x]\n", newbus->busno, newrange->start, newrange->end); 290 } 291 } 292 293 } else { 294 ; /* type is reserved WHAT TO DO IN THIS CASE??? 295 NOTHING TO DO??? */ 296 } 297 } else { 298 /* regular pci device resource */ 299 if ((curr->rsrc_type & RESTYPE) == MMASK) { 300 /* Memory resource */ 301 new_mem = alloc_resources (curr); 302 if (!new_mem) 303 return -ENOMEM; 304 new_mem->type = MEM; 305 /* 306 * if it didn't find the bus, means PCI dev 307 * came b4 the Primary Bus info, so need to 308 * create a bus rangeno becomes a problem... 309 * assign a -1 and then update once the range 310 * actually appears... 311 */ 312 if (ibmphp_add_resource (new_mem) < 0) { 313 newbus = alloc_error_bus (curr, 0, 0); 314 if (!newbus) 315 return -ENOMEM; 316 newbus->firstMem = new_mem; 317 ++newbus->needMemUpdate; 318 new_mem->rangeno = -1; 319 } 320 debug ("Memory resource for device %x, bus %x, [%x - %x]\n", new_mem->devfunc, new_mem->busno, new_mem->start, new_mem->end); 321 322 } else if ((curr->rsrc_type & RESTYPE) == PFMASK) { 323 /* PFMemory resource */ 324 new_pfmem = alloc_resources (curr); 325 if (!new_pfmem) 326 return -ENOMEM; 327 new_pfmem->type = PFMEM; 328 new_pfmem->fromMem = 0; 329 if (ibmphp_add_resource (new_pfmem) < 0) { 330 newbus = alloc_error_bus (curr, 0, 0); 331 if (!newbus) 332 return -ENOMEM; 333 newbus->firstPFMem = new_pfmem; 334 ++newbus->needPFMemUpdate; 335 new_pfmem->rangeno = -1; 336 } 337 338 debug ("PFMemory resource for device %x, bus %x, [%x - %x]\n", new_pfmem->devfunc, new_pfmem->busno, new_pfmem->start, new_pfmem->end); 339 } else if ((curr->rsrc_type & RESTYPE) == IOMASK) { 340 /* IO resource */ 341 new_io = alloc_resources (curr); 342 if (!new_io) 343 return -ENOMEM; 344 new_io->type = IO; 345 346 /* 347 * if it didn't find the bus, means PCI dev 348 * came b4 the Primary Bus info, so need to 349 * create a bus rangeno becomes a problem... 350 * Can assign a -1 and then update once the 351 * range actually appears... 352 */ 353 if (ibmphp_add_resource (new_io) < 0) { 354 newbus = alloc_error_bus (curr, 0, 0); 355 if (!newbus) 356 return -ENOMEM; 357 newbus->firstIO = new_io; 358 ++newbus->needIOUpdate; 359 new_io->rangeno = -1; 360 } 361 debug ("IO resource for device %x, bus %x, [%x - %x]\n", new_io->devfunc, new_io->busno, new_io->start, new_io->end); 362 } 363 } 364 } 365 366 list_for_each (tmp, &gbuses) { 367 bus_cur = list_entry (tmp, struct bus_node, bus_list); 368 /* This is to get info about PPB resources, since EBDA doesn't put this info into the primary bus info */ 369 rc = update_bridge_ranges (&bus_cur); 370 if (rc) 371 return rc; 372 } 373 rc = once_over (); /* This is to align ranges (so no -1) */ 374 if (rc) 375 return rc; 376 return 0; 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 if ((res_cur->start != range->start) && ((len_tmp = res_cur->start - 1 - range->start) >= res->len)) { 1042 debug ("len_tmp = %x\n", len_tmp); 1043 1044 if ((len_tmp < len_cur) || (len_cur == 0)) { 1045 1046 if ((range->start % tmp_divide) == 0) { 1047 /* just perfect, starting address is divisible by length */ 1048 flag = 1; 1049 len_cur = len_tmp; 1050 start_cur = range->start; 1051 } else { 1052 /* Needs adjusting */ 1053 tmp_start = range->start; 1054 flag = 0; 1055 1056 while ((len_tmp = res_cur->start - 1 - tmp_start) >= res->len) { 1057 if ((tmp_start % tmp_divide) == 0) { 1058 flag = 1; 1059 len_cur = len_tmp; 1060 start_cur = tmp_start; 1061 break; 1062 } 1063 tmp_start += tmp_divide - tmp_start % tmp_divide; 1064 if (tmp_start >= res_cur->start - 1) 1065 break; 1066 } 1067 } 1068 1069 if (flag && len_cur == res->len) { 1070 debug ("but we are not here, right?\n"); 1071 res->start = start_cur; 1072 res->len += 1; /* To restore the balance */ 1073 res->end = res->start + res->len - 1; 1074 return 0; 1075 } 1076 } 1077 } 1078 } 1079 if (!res_cur->next) { 1080 /* last device on the range */ 1081 if ((range->end != res_cur->end) && ((len_tmp = range->end - (res_cur->end + 1)) >= res->len)) { 1082 debug ("len_tmp = %x\n", len_tmp); 1083 if ((len_tmp < len_cur) || (len_cur == 0)) { 1084 1085 if (((res_cur->end + 1) % tmp_divide) == 0) { 1086 /* just perfect, starting address is divisible by length */ 1087 flag = 1; 1088 len_cur = len_tmp; 1089 start_cur = res_cur->end + 1; 1090 } else { 1091 /* Needs adjusting */ 1092 tmp_start = res_cur->end + 1; 1093 flag = 0; 1094 1095 while ((len_tmp = range->end - tmp_start) >= res->len) { 1096 if ((tmp_start % tmp_divide) == 0) { 1097 flag = 1; 1098 len_cur = len_tmp; 1099 start_cur = tmp_start; 1100 break; 1101 } 1102 tmp_start += tmp_divide - tmp_start % tmp_divide; 1103 if (tmp_start >= range->end) 1104 break; 1105 } 1106 } 1107 if (flag && len_cur == res->len) { 1108 res->start = start_cur; 1109 res->len += 1; /* To restore the balance */ 1110 res->end = res->start + res->len - 1; 1111 return 0; 1112 } 1113 } 1114 } 1115 } 1116 1117 if (res_prev) { 1118 if (res_prev->rangeno != res_cur->rangeno) { 1119 /* 1st device on this range */ 1120 if ((res_cur->start != range->start) && 1121 ((len_tmp = res_cur->start - 1 - range->start) >= res->len)) { 1122 if ((len_tmp < len_cur) || (len_cur == 0)) { 1123 if ((range->start % tmp_divide) == 0) { 1124 /* just perfect, starting address is divisible by length */ 1125 flag = 1; 1126 len_cur = len_tmp; 1127 start_cur = range->start; 1128 } else { 1129 /* Needs adjusting */ 1130 tmp_start = range->start; 1131 flag = 0; 1132 1133 while ((len_tmp = res_cur->start - 1 - tmp_start) >= res->len) { 1134 if ((tmp_start % tmp_divide) == 0) { 1135 flag = 1; 1136 len_cur = len_tmp; 1137 start_cur = tmp_start; 1138 break; 1139 } 1140 tmp_start += tmp_divide - tmp_start % tmp_divide; 1141 if (tmp_start >= res_cur->start - 1) 1142 break; 1143 } 1144 } 1145 1146 if (flag && len_cur == res->len) { 1147 res->start = start_cur; 1148 res->len += 1; /* To restore the balance */ 1149 res->end = res->start + res->len - 1; 1150 return 0; 1151 } 1152 } 1153 } 1154 } else { 1155 /* in the same range */ 1156 if ((len_tmp = res_cur->start - 1 - res_prev->end - 1) >= res->len) { 1157 if ((len_tmp < len_cur) || (len_cur == 0)) { 1158 if (((res_prev->end + 1) % tmp_divide) == 0) { 1159 /* just perfect, starting address's divisible by length */ 1160 flag = 1; 1161 len_cur = len_tmp; 1162 start_cur = res_prev->end + 1; 1163 } else { 1164 /* Needs adjusting */ 1165 tmp_start = res_prev->end + 1; 1166 flag = 0; 1167 1168 while ((len_tmp = res_cur->start - 1 - tmp_start) >= res->len) { 1169 if ((tmp_start % tmp_divide) == 0) { 1170 flag = 1; 1171 len_cur = len_tmp; 1172 start_cur = tmp_start; 1173 break; 1174 } 1175 tmp_start += tmp_divide - tmp_start % tmp_divide; 1176 if (tmp_start >= res_cur->start - 1) 1177 break; 1178 } 1179 } 1180 1181 if (flag && len_cur == res->len) { 1182 res->start = start_cur; 1183 res->len += 1; /* To restore the balance */ 1184 res->end = res->start + res->len - 1; 1185 return 0; 1186 } 1187 } 1188 } 1189 } 1190 } 1191 /* end if (res_prev) */ 1192 res_prev = res_cur; 1193 if (res_cur->next) 1194 res_cur = res_cur->next; 1195 else 1196 res_cur = res_cur->nextRange; 1197 } /* end of while */ 1198 1199 1200 if (!res_prev) { 1201 /* 1st device ever */ 1202 /* need to find appropriate range */ 1203 switch (res->type) { 1204 case IO: 1205 range = bus_cur->rangeIO; 1206 break; 1207 case MEM: 1208 range = bus_cur->rangeMem; 1209 break; 1210 case PFMEM: 1211 range = bus_cur->rangePFMem; 1212 break; 1213 } 1214 while (range) { 1215 if ((len_tmp = range->end - range->start) >= res->len) { 1216 if ((len_tmp < len_cur) || (len_cur == 0)) { 1217 if ((range->start % tmp_divide) == 0) { 1218 /* just perfect, starting address's divisible by length */ 1219 flag = 1; 1220 len_cur = len_tmp; 1221 start_cur = range->start; 1222 } else { 1223 /* Needs adjusting */ 1224 tmp_start = range->start; 1225 flag = 0; 1226 1227 while ((len_tmp = range->end - tmp_start) >= res->len) { 1228 if ((tmp_start % tmp_divide) == 0) { 1229 flag = 1; 1230 len_cur = len_tmp; 1231 start_cur = tmp_start; 1232 break; 1233 } 1234 tmp_start += tmp_divide - tmp_start % tmp_divide; 1235 if (tmp_start >= range->end) 1236 break; 1237 } 1238 } 1239 1240 if (flag && len_cur == res->len) { 1241 res->start = start_cur; 1242 res->len += 1; /* To restore the balance */ 1243 res->end = res->start + res->len - 1; 1244 return 0; 1245 } 1246 } 1247 } 1248 range = range->next; 1249 } /* end of while */ 1250 1251 if ((!range) && (len_cur == 0)) { 1252 /* have gone through the list of devices and ranges and haven't found n.e.thing */ 1253 err ("no appropriate range.. bailing out...\n"); 1254 return -EINVAL; 1255 } else if (len_cur) { 1256 res->start = start_cur; 1257 res->len += 1; /* To restore the balance */ 1258 res->end = res->start + res->len - 1; 1259 return 0; 1260 } 1261 } 1262 1263 if (!res_cur) { 1264 debug ("prev->rangeno = %d, noranges = %d\n", res_prev->rangeno, noranges); 1265 if (res_prev->rangeno < noranges) { 1266 /* if there're more ranges out there to check */ 1267 switch (res->type) { 1268 case IO: 1269 range = bus_cur->rangeIO; 1270 break; 1271 case MEM: 1272 range = bus_cur->rangeMem; 1273 break; 1274 case PFMEM: 1275 range = bus_cur->rangePFMem; 1276 break; 1277 } 1278 while (range) { 1279 if ((len_tmp = range->end - range->start) >= res->len) { 1280 if ((len_tmp < len_cur) || (len_cur == 0)) { 1281 if ((range->start % tmp_divide) == 0) { 1282 /* just perfect, starting address's divisible by length */ 1283 flag = 1; 1284 len_cur = len_tmp; 1285 start_cur = range->start; 1286 } else { 1287 /* Needs adjusting */ 1288 tmp_start = range->start; 1289 flag = 0; 1290 1291 while ((len_tmp = range->end - tmp_start) >= res->len) { 1292 if ((tmp_start % tmp_divide) == 0) { 1293 flag = 1; 1294 len_cur = len_tmp; 1295 start_cur = tmp_start; 1296 break; 1297 } 1298 tmp_start += tmp_divide - tmp_start % tmp_divide; 1299 if (tmp_start >= range->end) 1300 break; 1301 } 1302 } 1303 1304 if (flag && len_cur == res->len) { 1305 res->start = start_cur; 1306 res->len += 1; /* To restore the balance */ 1307 res->end = res->start + res->len - 1; 1308 return 0; 1309 } 1310 } 1311 } 1312 range = range->next; 1313 } /* end of while */ 1314 1315 if ((!range) && (len_cur == 0)) { 1316 /* have gone through the list of devices and ranges and haven't found n.e.thing */ 1317 err ("no appropriate range.. bailing out...\n"); 1318 return -EINVAL; 1319 } else if (len_cur) { 1320 res->start = start_cur; 1321 res->len += 1; /* To restore the balance */ 1322 res->end = res->start + res->len - 1; 1323 return 0; 1324 } 1325 } else { 1326 /* no more ranges to check on */ 1327 if (len_cur) { 1328 res->start = start_cur; 1329 res->len += 1; /* To restore the balance */ 1330 res->end = res->start + res->len - 1; 1331 return 0; 1332 } else { 1333 /* have gone through the list of devices and haven't found n.e.thing */ 1334 err ("no appropriate range.. bailing out...\n"); 1335 return -EINVAL; 1336 } 1337 } 1338 } /* end if(!res_cur) */ 1339 return -EINVAL; 1340 } 1341 1342 /******************************************************************************** 1343 * This routine is called from remove_card if the card contained PPB. 1344 * It will remove all the resources on the bus as well as the bus itself 1345 * Input: Bus 1346 * Output: 0, -ENODEV 1347 ********************************************************************************/ 1348 int ibmphp_remove_bus (struct bus_node *bus, u8 parent_busno) 1349 { 1350 struct resource_node *res_cur; 1351 struct resource_node *res_tmp; 1352 struct bus_node *prev_bus; 1353 int rc; 1354 1355 prev_bus = find_bus_wprev (parent_busno, NULL, 0); 1356 1357 if (!prev_bus) { 1358 debug ("something terribly wrong. Cannot find parent bus to the one to remove\n"); 1359 return -ENODEV; 1360 } 1361 1362 debug ("In ibmphp_remove_bus... prev_bus->busno is %x\n", prev_bus->busno); 1363 1364 rc = remove_ranges (bus, prev_bus); 1365 if (rc) 1366 return rc; 1367 1368 if (bus->firstIO) { 1369 res_cur = bus->firstIO; 1370 while (res_cur) { 1371 res_tmp = res_cur; 1372 if (res_cur->next) 1373 res_cur = res_cur->next; 1374 else 1375 res_cur = res_cur->nextRange; 1376 kfree (res_tmp); 1377 res_tmp = NULL; 1378 } 1379 bus->firstIO = NULL; 1380 } 1381 if (bus->firstMem) { 1382 res_cur = bus->firstMem; 1383 while (res_cur) { 1384 res_tmp = res_cur; 1385 if (res_cur->next) 1386 res_cur = res_cur->next; 1387 else 1388 res_cur = res_cur->nextRange; 1389 kfree (res_tmp); 1390 res_tmp = NULL; 1391 } 1392 bus->firstMem = NULL; 1393 } 1394 if (bus->firstPFMem) { 1395 res_cur = bus->firstPFMem; 1396 while (res_cur) { 1397 res_tmp = res_cur; 1398 if (res_cur->next) 1399 res_cur = res_cur->next; 1400 else 1401 res_cur = res_cur->nextRange; 1402 kfree (res_tmp); 1403 res_tmp = NULL; 1404 } 1405 bus->firstPFMem = NULL; 1406 } 1407 1408 if (bus->firstPFMemFromMem) { 1409 res_cur = bus->firstPFMemFromMem; 1410 while (res_cur) { 1411 res_tmp = res_cur; 1412 res_cur = res_cur->next; 1413 1414 kfree (res_tmp); 1415 res_tmp = NULL; 1416 } 1417 bus->firstPFMemFromMem = NULL; 1418 } 1419 1420 list_del (&bus->bus_list); 1421 kfree (bus); 1422 return 0; 1423 } 1424 1425 /****************************************************************************** 1426 * This routine deletes the ranges from a given bus, and the entries from the 1427 * parent's bus in the resources 1428 * Input: current bus, previous bus 1429 * Output: 0, -EINVAL 1430 ******************************************************************************/ 1431 static int remove_ranges (struct bus_node *bus_cur, struct bus_node *bus_prev) 1432 { 1433 struct range_node *range_cur; 1434 struct range_node *range_tmp; 1435 int i; 1436 struct resource_node *res = NULL; 1437 1438 if (bus_cur->noIORanges) { 1439 range_cur = bus_cur->rangeIO; 1440 for (i = 0; i < bus_cur->noIORanges; i++) { 1441 if (ibmphp_find_resource (bus_prev, range_cur->start, &res, IO) < 0) 1442 return -EINVAL; 1443 ibmphp_remove_resource (res); 1444 1445 range_tmp = range_cur; 1446 range_cur = range_cur->next; 1447 kfree (range_tmp); 1448 range_tmp = NULL; 1449 } 1450 bus_cur->rangeIO = NULL; 1451 } 1452 if (bus_cur->noMemRanges) { 1453 range_cur = bus_cur->rangeMem; 1454 for (i = 0; i < bus_cur->noMemRanges; i++) { 1455 if (ibmphp_find_resource (bus_prev, range_cur->start, &res, MEM) < 0) 1456 return -EINVAL; 1457 1458 ibmphp_remove_resource (res); 1459 range_tmp = range_cur; 1460 range_cur = range_cur->next; 1461 kfree (range_tmp); 1462 range_tmp = NULL; 1463 } 1464 bus_cur->rangeMem = NULL; 1465 } 1466 if (bus_cur->noPFMemRanges) { 1467 range_cur = bus_cur->rangePFMem; 1468 for (i = 0; i < bus_cur->noPFMemRanges; i++) { 1469 if (ibmphp_find_resource (bus_prev, range_cur->start, &res, PFMEM) < 0) 1470 return -EINVAL; 1471 1472 ibmphp_remove_resource (res); 1473 range_tmp = range_cur; 1474 range_cur = range_cur->next; 1475 kfree (range_tmp); 1476 range_tmp = NULL; 1477 } 1478 bus_cur->rangePFMem = NULL; 1479 } 1480 return 0; 1481 } 1482 1483 /* 1484 * find the resource node in the bus 1485 * Input: Resource needed, start address of the resource, type of resource 1486 */ 1487 int ibmphp_find_resource (struct bus_node *bus, u32 start_address, struct resource_node **res, int flag) 1488 { 1489 struct resource_node *res_cur = NULL; 1490 char * type = ""; 1491 1492 if (!bus) { 1493 err ("The bus passed in NULL to find resource\n"); 1494 return -ENODEV; 1495 } 1496 1497 switch (flag) { 1498 case IO: 1499 res_cur = bus->firstIO; 1500 type = "io"; 1501 break; 1502 case MEM: 1503 res_cur = bus->firstMem; 1504 type = "mem"; 1505 break; 1506 case PFMEM: 1507 res_cur = bus->firstPFMem; 1508 type = "pfmem"; 1509 break; 1510 default: 1511 err ("wrong type of flag\n"); 1512 return -EINVAL; 1513 } 1514 1515 while (res_cur) { 1516 if (res_cur->start == start_address) { 1517 *res = res_cur; 1518 break; 1519 } 1520 if (res_cur->next) 1521 res_cur = res_cur->next; 1522 else 1523 res_cur = res_cur->nextRange; 1524 } 1525 1526 if (!res_cur) { 1527 if (flag == PFMEM) { 1528 res_cur = bus->firstPFMemFromMem; 1529 while (res_cur) { 1530 if (res_cur->start == start_address) { 1531 *res = res_cur; 1532 break; 1533 } 1534 res_cur = res_cur->next; 1535 } 1536 if (!res_cur) { 1537 debug ("SOS...cannot find %s resource in the bus.\n", type); 1538 return -EINVAL; 1539 } 1540 } else { 1541 debug ("SOS... cannot find %s resource in the bus.\n", type); 1542 return -EINVAL; 1543 } 1544 } 1545 1546 if (*res) 1547 debug ("*res->start = %x\n", (*res)->start); 1548 1549 return 0; 1550 } 1551 1552 /*********************************************************************** 1553 * This routine will free the resource structures used by the 1554 * system. It is called from cleanup routine for the module 1555 * Parameters: none 1556 * Returns: none 1557 ***********************************************************************/ 1558 void ibmphp_free_resources (void) 1559 { 1560 struct bus_node *bus_cur = NULL; 1561 struct bus_node *bus_tmp; 1562 struct range_node *range_cur; 1563 struct range_node *range_tmp; 1564 struct resource_node *res_cur; 1565 struct resource_node *res_tmp; 1566 struct list_head *tmp; 1567 struct list_head *next; 1568 int i = 0; 1569 flags = 1; 1570 1571 list_for_each_safe (tmp, next, &gbuses) { 1572 bus_cur = list_entry (tmp, struct bus_node, bus_list); 1573 if (bus_cur->noIORanges) { 1574 range_cur = bus_cur->rangeIO; 1575 for (i = 0; i < bus_cur->noIORanges; i++) { 1576 if (!range_cur) 1577 break; 1578 range_tmp = range_cur; 1579 range_cur = range_cur->next; 1580 kfree (range_tmp); 1581 range_tmp = NULL; 1582 } 1583 } 1584 if (bus_cur->noMemRanges) { 1585 range_cur = bus_cur->rangeMem; 1586 for (i = 0; i < bus_cur->noMemRanges; i++) { 1587 if (!range_cur) 1588 break; 1589 range_tmp = range_cur; 1590 range_cur = range_cur->next; 1591 kfree (range_tmp); 1592 range_tmp = NULL; 1593 } 1594 } 1595 if (bus_cur->noPFMemRanges) { 1596 range_cur = bus_cur->rangePFMem; 1597 for (i = 0; i < bus_cur->noPFMemRanges; i++) { 1598 if (!range_cur) 1599 break; 1600 range_tmp = range_cur; 1601 range_cur = range_cur->next; 1602 kfree (range_tmp); 1603 range_tmp = NULL; 1604 } 1605 } 1606 1607 if (bus_cur->firstIO) { 1608 res_cur = bus_cur->firstIO; 1609 while (res_cur) { 1610 res_tmp = res_cur; 1611 if (res_cur->next) 1612 res_cur = res_cur->next; 1613 else 1614 res_cur = res_cur->nextRange; 1615 kfree (res_tmp); 1616 res_tmp = NULL; 1617 } 1618 bus_cur->firstIO = NULL; 1619 } 1620 if (bus_cur->firstMem) { 1621 res_cur = bus_cur->firstMem; 1622 while (res_cur) { 1623 res_tmp = res_cur; 1624 if (res_cur->next) 1625 res_cur = res_cur->next; 1626 else 1627 res_cur = res_cur->nextRange; 1628 kfree (res_tmp); 1629 res_tmp = NULL; 1630 } 1631 bus_cur->firstMem = NULL; 1632 } 1633 if (bus_cur->firstPFMem) { 1634 res_cur = bus_cur->firstPFMem; 1635 while (res_cur) { 1636 res_tmp = res_cur; 1637 if (res_cur->next) 1638 res_cur = res_cur->next; 1639 else 1640 res_cur = res_cur->nextRange; 1641 kfree (res_tmp); 1642 res_tmp = NULL; 1643 } 1644 bus_cur->firstPFMem = NULL; 1645 } 1646 1647 if (bus_cur->firstPFMemFromMem) { 1648 res_cur = bus_cur->firstPFMemFromMem; 1649 while (res_cur) { 1650 res_tmp = res_cur; 1651 res_cur = res_cur->next; 1652 1653 kfree (res_tmp); 1654 res_tmp = NULL; 1655 } 1656 bus_cur->firstPFMemFromMem = NULL; 1657 } 1658 1659 bus_tmp = bus_cur; 1660 list_del (&bus_cur->bus_list); 1661 kfree (bus_tmp); 1662 bus_tmp = NULL; 1663 } 1664 } 1665 1666 /********************************************************************************* 1667 * This function will go over the PFmem resources to check if the EBDA allocated 1668 * pfmem out of memory buckets of the bus. If so, it will change the range numbers 1669 * and a flag to indicate that this resource is out of memory. It will also move the 1670 * Pfmem out of the pfmem resource list to the PFMemFromMem list, and will create 1671 * a new Mem node 1672 * This routine is called right after initialization 1673 *******************************************************************************/ 1674 static int __init once_over (void) 1675 { 1676 struct resource_node *pfmem_cur; 1677 struct resource_node *pfmem_prev; 1678 struct resource_node *mem; 1679 struct bus_node *bus_cur; 1680 struct list_head *tmp; 1681 1682 list_for_each (tmp, &gbuses) { 1683 bus_cur = list_entry (tmp, struct bus_node, bus_list); 1684 if ((!bus_cur->rangePFMem) && (bus_cur->firstPFMem)) { 1685 for (pfmem_cur = bus_cur->firstPFMem, pfmem_prev = NULL; pfmem_cur; pfmem_prev = pfmem_cur, pfmem_cur = pfmem_cur->next) { 1686 pfmem_cur->fromMem = 1; 1687 if (pfmem_prev) 1688 pfmem_prev->next = pfmem_cur->next; 1689 else 1690 bus_cur->firstPFMem = pfmem_cur->next; 1691 1692 if (!bus_cur->firstPFMemFromMem) 1693 pfmem_cur->next = NULL; 1694 else 1695 /* we don't need to sort PFMemFromMem since we're using mem node for 1696 all the real work anyways, so just insert at the beginning of the 1697 list 1698 */ 1699 pfmem_cur->next = bus_cur->firstPFMemFromMem; 1700 1701 bus_cur->firstPFMemFromMem = pfmem_cur; 1702 1703 mem = kzalloc(sizeof(struct resource_node), GFP_KERNEL); 1704 if (!mem) { 1705 err ("out of system memory\n"); 1706 return -ENOMEM; 1707 } 1708 mem->type = MEM; 1709 mem->busno = pfmem_cur->busno; 1710 mem->devfunc = pfmem_cur->devfunc; 1711 mem->start = pfmem_cur->start; 1712 mem->end = pfmem_cur->end; 1713 mem->len = pfmem_cur->len; 1714 if (ibmphp_add_resource (mem) < 0) 1715 err ("Trouble...trouble... EBDA allocated pfmem from mem, but system doesn't display it has this space... unless not PCI device...\n"); 1716 pfmem_cur->rangeno = mem->rangeno; 1717 } /* end for pfmem */ 1718 } /* end if */ 1719 } /* end list_for_each bus */ 1720 return 0; 1721 } 1722 1723 int ibmphp_add_pfmem_from_mem (struct resource_node *pfmem) 1724 { 1725 struct bus_node *bus_cur = find_bus_wprev (pfmem->busno, NULL, 0); 1726 1727 if (!bus_cur) { 1728 err ("cannot find bus of pfmem to add...\n"); 1729 return -ENODEV; 1730 } 1731 1732 if (bus_cur->firstPFMemFromMem) 1733 pfmem->next = bus_cur->firstPFMemFromMem; 1734 else 1735 pfmem->next = NULL; 1736 1737 bus_cur->firstPFMemFromMem = pfmem; 1738 1739 return 0; 1740 } 1741 1742 /* This routine just goes through the buses to see if the bus already exists. 1743 * It is called from ibmphp_find_sec_number, to find out a secondary bus number for 1744 * bridged cards 1745 * Parameters: bus_number 1746 * Returns: Bus pointer or NULL 1747 */ 1748 struct bus_node *ibmphp_find_res_bus (u8 bus_number) 1749 { 1750 return find_bus_wprev (bus_number, NULL, 0); 1751 } 1752 1753 static struct bus_node *find_bus_wprev (u8 bus_number, struct bus_node **prev, u8 flag) 1754 { 1755 struct bus_node *bus_cur; 1756 struct list_head *tmp; 1757 struct list_head *tmp_prev; 1758 1759 list_for_each (tmp, &gbuses) { 1760 tmp_prev = tmp->prev; 1761 bus_cur = list_entry (tmp, struct bus_node, bus_list); 1762 if (flag) 1763 *prev = list_entry (tmp_prev, struct bus_node, bus_list); 1764 if (bus_cur->busno == bus_number) 1765 return bus_cur; 1766 } 1767 1768 return NULL; 1769 } 1770 1771 void ibmphp_print_test (void) 1772 { 1773 int i = 0; 1774 struct bus_node *bus_cur = NULL; 1775 struct range_node *range; 1776 struct resource_node *res; 1777 struct list_head *tmp; 1778 1779 debug_pci ("*****************START**********************\n"); 1780 1781 if ((!list_empty(&gbuses)) && flags) { 1782 err ("The GBUSES is not NULL?!?!?!?!?\n"); 1783 return; 1784 } 1785 1786 list_for_each (tmp, &gbuses) { 1787 bus_cur = list_entry (tmp, struct bus_node, 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