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, smth'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 * Ouput: 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 " 793 "bailing out...\n"); 794 return -ENODEV; 795 } 796 797 switch (res->type) { 798 case IO: 799 res_cur = bus_cur->firstIO; 800 type = "io"; 801 break; 802 case MEM: 803 res_cur = bus_cur->firstMem; 804 type = "mem"; 805 break; 806 case PFMEM: 807 res_cur = bus_cur->firstPFMem; 808 type = "pfmem"; 809 break; 810 default: 811 err ("unknown type for resource to remove\n"); 812 return -EINVAL; 813 } 814 res_prev = NULL; 815 816 while (res_cur) { 817 if ((res_cur->start == res->start) && (res_cur->end == res->end)) 818 break; 819 res_prev = res_cur; 820 if (res_cur->next) 821 res_cur = res_cur->next; 822 else 823 res_cur = res_cur->nextRange; 824 } 825 826 if (!res_cur) { 827 if (res->type == PFMEM) { 828 /* 829 * case where pfmem might be in the PFMemFromMem list 830 * so will also need to remove the corresponding mem 831 * entry 832 */ 833 res_cur = bus_cur->firstPFMemFromMem; 834 res_prev = NULL; 835 836 while (res_cur) { 837 if ((res_cur->start == res->start) && (res_cur->end == res->end)) { 838 mem_cur = bus_cur->firstMem; 839 while (mem_cur) { 840 if ((mem_cur->start == res_cur->start) 841 && (mem_cur->end == res_cur->end)) 842 break; 843 if (mem_cur->next) 844 mem_cur = mem_cur->next; 845 else 846 mem_cur = mem_cur->nextRange; 847 } 848 if (!mem_cur) { 849 err ("cannot find corresponding mem node for pfmem...\n"); 850 return -EINVAL; 851 } 852 853 ibmphp_remove_resource (mem_cur); 854 if (!res_prev) 855 bus_cur->firstPFMemFromMem = res_cur->next; 856 else 857 res_prev->next = res_cur->next; 858 kfree (res_cur); 859 return 0; 860 } 861 res_prev = res_cur; 862 if (res_cur->next) 863 res_cur = res_cur->next; 864 else 865 res_cur = res_cur->nextRange; 866 } 867 if (!res_cur) { 868 err ("cannot find pfmem to delete...\n"); 869 return -EINVAL; 870 } 871 } else { 872 err ("the %s resource is not in the list to be deleted...\n", type); 873 return -EINVAL; 874 } 875 } 876 if (!res_prev) { 877 /* first device to be deleted */ 878 if (res_cur->next) { 879 switch (res->type) { 880 case IO: 881 bus_cur->firstIO = res_cur->next; 882 break; 883 case MEM: 884 bus_cur->firstMem = res_cur->next; 885 break; 886 case PFMEM: 887 bus_cur->firstPFMem = res_cur->next; 888 break; 889 } 890 } else if (res_cur->nextRange) { 891 switch (res->type) { 892 case IO: 893 bus_cur->firstIO = res_cur->nextRange; 894 break; 895 case MEM: 896 bus_cur->firstMem = res_cur->nextRange; 897 break; 898 case PFMEM: 899 bus_cur->firstPFMem = res_cur->nextRange; 900 break; 901 } 902 } else { 903 switch (res->type) { 904 case IO: 905 bus_cur->firstIO = NULL; 906 break; 907 case MEM: 908 bus_cur->firstMem = NULL; 909 break; 910 case PFMEM: 911 bus_cur->firstPFMem = NULL; 912 break; 913 } 914 } 915 kfree (res_cur); 916 return 0; 917 } else { 918 if (res_cur->next) { 919 if (res_prev->rangeno == res_cur->rangeno) 920 res_prev->next = res_cur->next; 921 else 922 res_prev->nextRange = res_cur->next; 923 } else if (res_cur->nextRange) { 924 res_prev->next = NULL; 925 res_prev->nextRange = res_cur->nextRange; 926 } else { 927 res_prev->next = NULL; 928 res_prev->nextRange = NULL; 929 } 930 kfree (res_cur); 931 return 0; 932 } 933 934 return 0; 935 } 936 937 static struct range_node * find_range (struct bus_node *bus_cur, struct resource_node * res) 938 { 939 struct range_node * range = NULL; 940 941 switch (res->type) { 942 case IO: 943 range = bus_cur->rangeIO; 944 break; 945 case MEM: 946 range = bus_cur->rangeMem; 947 break; 948 case PFMEM: 949 range = bus_cur->rangePFMem; 950 break; 951 default: 952 err ("cannot read resource type in find_range\n"); 953 } 954 955 while (range) { 956 if (res->rangeno == range->rangeno) 957 break; 958 range = range->next; 959 } 960 return range; 961 } 962 963 /***************************************************************************** 964 * This routine will check to make sure the io/mem/pfmem->len that the device asked for 965 * can fit w/i our list of available IO/MEM/PFMEM resources. If cannot, returns -EINVAL, 966 * otherwise, returns 0 967 * 968 * Input: resource 969 * Ouput: the correct start and end address are inputted into the resource node, 970 * 0 or -EINVAL 971 *****************************************************************************/ 972 int ibmphp_check_resource (struct resource_node *res, u8 bridge) 973 { 974 struct bus_node *bus_cur; 975 struct range_node *range = NULL; 976 struct resource_node *res_prev; 977 struct resource_node *res_cur = NULL; 978 u32 len_cur = 0, start_cur = 0, len_tmp = 0; 979 int noranges = 0; 980 u32 tmp_start; /* this is to make sure start address is divisible by the length needed */ 981 u32 tmp_divide; 982 u8 flag = 0; 983 984 if (!res) 985 return -EINVAL; 986 987 if (bridge) { 988 /* The rules for bridges are different, 4K divisible for IO, 1M for (pf)mem*/ 989 if (res->type == IO) 990 tmp_divide = IOBRIDGE; 991 else 992 tmp_divide = MEMBRIDGE; 993 } else 994 tmp_divide = res->len; 995 996 bus_cur = find_bus_wprev (res->busno, NULL, 0); 997 998 if (!bus_cur) { 999 /* didn't find a bus, smth's wrong!!! */ 1000 debug ("no bus in the system, either pci_dev's wrong or allocation failed\n"); 1001 return -EINVAL; 1002 } 1003 1004 debug ("%s - enter\n", __func__); 1005 debug ("bus_cur->busno is %d\n", bus_cur->busno); 1006 1007 /* This is a quick fix to not mess up with the code very much. i.e., 1008 * 2000-2fff, len = 1000, but when we compare, we need it to be fff */ 1009 res->len -= 1; 1010 1011 switch (res->type) { 1012 case IO: 1013 res_cur = bus_cur->firstIO; 1014 noranges = bus_cur->noIORanges; 1015 break; 1016 case MEM: 1017 res_cur = bus_cur->firstMem; 1018 noranges = bus_cur->noMemRanges; 1019 break; 1020 case PFMEM: 1021 res_cur = bus_cur->firstPFMem; 1022 noranges = bus_cur->noPFMemRanges; 1023 break; 1024 default: 1025 err ("wrong type of resource to check\n"); 1026 return -EINVAL; 1027 } 1028 res_prev = NULL; 1029 1030 while (res_cur) { 1031 range = find_range (bus_cur, res_cur); 1032 debug ("%s - rangeno = %d\n", __func__, res_cur->rangeno); 1033 1034 if (!range) { 1035 err ("no range for the device exists... bailing out...\n"); 1036 return -EINVAL; 1037 } 1038 1039 /* found our range */ 1040 if (!res_prev) { 1041 /* first time in the loop */ 1042 if ((res_cur->start != range->start) && ((len_tmp = res_cur->start - 1 - range->start) >= res->len)) { 1043 debug ("len_tmp = %x\n", len_tmp); 1044 1045 if ((len_tmp < len_cur) || (len_cur == 0)) { 1046 1047 if ((range->start % tmp_divide) == 0) { 1048 /* just perfect, starting address is divisible by length */ 1049 flag = 1; 1050 len_cur = len_tmp; 1051 start_cur = range->start; 1052 } else { 1053 /* Needs adjusting */ 1054 tmp_start = range->start; 1055 flag = 0; 1056 1057 while ((len_tmp = res_cur->start - 1 - tmp_start) >= res->len) { 1058 if ((tmp_start % tmp_divide) == 0) { 1059 flag = 1; 1060 len_cur = len_tmp; 1061 start_cur = tmp_start; 1062 break; 1063 } 1064 tmp_start += tmp_divide - tmp_start % tmp_divide; 1065 if (tmp_start >= res_cur->start - 1) 1066 break; 1067 } 1068 } 1069 1070 if (flag && len_cur == res->len) { 1071 debug ("but we are not here, right?\n"); 1072 res->start = start_cur; 1073 res->len += 1; /* To restore the balance */ 1074 res->end = res->start + res->len - 1; 1075 return 0; 1076 } 1077 } 1078 } 1079 } 1080 if (!res_cur->next) { 1081 /* last device on the range */ 1082 if ((range->end != res_cur->end) && ((len_tmp = range->end - (res_cur->end + 1)) >= res->len)) { 1083 debug ("len_tmp = %x\n", len_tmp); 1084 if ((len_tmp < len_cur) || (len_cur == 0)) { 1085 1086 if (((res_cur->end + 1) % tmp_divide) == 0) { 1087 /* just perfect, starting address is divisible by length */ 1088 flag = 1; 1089 len_cur = len_tmp; 1090 start_cur = res_cur->end + 1; 1091 } else { 1092 /* Needs adjusting */ 1093 tmp_start = res_cur->end + 1; 1094 flag = 0; 1095 1096 while ((len_tmp = range->end - tmp_start) >= res->len) { 1097 if ((tmp_start % tmp_divide) == 0) { 1098 flag = 1; 1099 len_cur = len_tmp; 1100 start_cur = tmp_start; 1101 break; 1102 } 1103 tmp_start += tmp_divide - tmp_start % tmp_divide; 1104 if (tmp_start >= range->end) 1105 break; 1106 } 1107 } 1108 if (flag && len_cur == res->len) { 1109 res->start = start_cur; 1110 res->len += 1; /* To restore the balance */ 1111 res->end = res->start + res->len - 1; 1112 return 0; 1113 } 1114 } 1115 } 1116 } 1117 1118 if (res_prev) { 1119 if (res_prev->rangeno != res_cur->rangeno) { 1120 /* 1st device on this range */ 1121 if ((res_cur->start != range->start) && 1122 ((len_tmp = res_cur->start - 1 - range->start) >= res->len)) { 1123 if ((len_tmp < len_cur) || (len_cur == 0)) { 1124 if ((range->start % tmp_divide) == 0) { 1125 /* just perfect, starting address is divisible by length */ 1126 flag = 1; 1127 len_cur = len_tmp; 1128 start_cur = range->start; 1129 } else { 1130 /* Needs adjusting */ 1131 tmp_start = range->start; 1132 flag = 0; 1133 1134 while ((len_tmp = res_cur->start - 1 - tmp_start) >= res->len) { 1135 if ((tmp_start % tmp_divide) == 0) { 1136 flag = 1; 1137 len_cur = len_tmp; 1138 start_cur = tmp_start; 1139 break; 1140 } 1141 tmp_start += tmp_divide - tmp_start % tmp_divide; 1142 if (tmp_start >= res_cur->start - 1) 1143 break; 1144 } 1145 } 1146 1147 if (flag && len_cur == res->len) { 1148 res->start = start_cur; 1149 res->len += 1; /* To restore the balance */ 1150 res->end = res->start + res->len - 1; 1151 return 0; 1152 } 1153 } 1154 } 1155 } else { 1156 /* in the same range */ 1157 if ((len_tmp = res_cur->start - 1 - res_prev->end - 1) >= res->len) { 1158 if ((len_tmp < len_cur) || (len_cur == 0)) { 1159 if (((res_prev->end + 1) % tmp_divide) == 0) { 1160 /* just perfect, starting address's divisible by length */ 1161 flag = 1; 1162 len_cur = len_tmp; 1163 start_cur = res_prev->end + 1; 1164 } else { 1165 /* Needs adjusting */ 1166 tmp_start = res_prev->end + 1; 1167 flag = 0; 1168 1169 while ((len_tmp = res_cur->start - 1 - tmp_start) >= res->len) { 1170 if ((tmp_start % tmp_divide) == 0) { 1171 flag = 1; 1172 len_cur = len_tmp; 1173 start_cur = tmp_start; 1174 break; 1175 } 1176 tmp_start += tmp_divide - tmp_start % tmp_divide; 1177 if (tmp_start >= res_cur->start - 1) 1178 break; 1179 } 1180 } 1181 1182 if (flag && len_cur == res->len) { 1183 res->start = start_cur; 1184 res->len += 1; /* To restore the balance */ 1185 res->end = res->start + res->len - 1; 1186 return 0; 1187 } 1188 } 1189 } 1190 } 1191 } 1192 /* end if (res_prev) */ 1193 res_prev = res_cur; 1194 if (res_cur->next) 1195 res_cur = res_cur->next; 1196 else 1197 res_cur = res_cur->nextRange; 1198 } /* end of while */ 1199 1200 1201 if (!res_prev) { 1202 /* 1st device ever */ 1203 /* need to find appropriate range */ 1204 switch (res->type) { 1205 case IO: 1206 range = bus_cur->rangeIO; 1207 break; 1208 case MEM: 1209 range = bus_cur->rangeMem; 1210 break; 1211 case PFMEM: 1212 range = bus_cur->rangePFMem; 1213 break; 1214 } 1215 while (range) { 1216 if ((len_tmp = range->end - range->start) >= res->len) { 1217 if ((len_tmp < len_cur) || (len_cur == 0)) { 1218 if ((range->start % tmp_divide) == 0) { 1219 /* just perfect, starting address's divisible by length */ 1220 flag = 1; 1221 len_cur = len_tmp; 1222 start_cur = range->start; 1223 } else { 1224 /* Needs adjusting */ 1225 tmp_start = range->start; 1226 flag = 0; 1227 1228 while ((len_tmp = range->end - tmp_start) >= res->len) { 1229 if ((tmp_start % tmp_divide) == 0) { 1230 flag = 1; 1231 len_cur = len_tmp; 1232 start_cur = tmp_start; 1233 break; 1234 } 1235 tmp_start += tmp_divide - tmp_start % tmp_divide; 1236 if (tmp_start >= range->end) 1237 break; 1238 } 1239 } 1240 1241 if (flag && len_cur == res->len) { 1242 res->start = start_cur; 1243 res->len += 1; /* To restore the balance */ 1244 res->end = res->start + res->len - 1; 1245 return 0; 1246 } 1247 } 1248 } 1249 range = range->next; 1250 } /* end of while */ 1251 1252 if ((!range) && (len_cur == 0)) { 1253 /* have gone through the list of devices and ranges and haven't found n.e.thing */ 1254 err ("no appropriate range.. bailing out...\n"); 1255 return -EINVAL; 1256 } else if (len_cur) { 1257 res->start = start_cur; 1258 res->len += 1; /* To restore the balance */ 1259 res->end = res->start + res->len - 1; 1260 return 0; 1261 } 1262 } 1263 1264 if (!res_cur) { 1265 debug ("prev->rangeno = %d, noranges = %d\n", res_prev->rangeno, noranges); 1266 if (res_prev->rangeno < noranges) { 1267 /* if there're more ranges out there to check */ 1268 switch (res->type) { 1269 case IO: 1270 range = bus_cur->rangeIO; 1271 break; 1272 case MEM: 1273 range = bus_cur->rangeMem; 1274 break; 1275 case PFMEM: 1276 range = bus_cur->rangePFMem; 1277 break; 1278 } 1279 while (range) { 1280 if ((len_tmp = range->end - range->start) >= res->len) { 1281 if ((len_tmp < len_cur) || (len_cur == 0)) { 1282 if ((range->start % tmp_divide) == 0) { 1283 /* just perfect, starting address's divisible by length */ 1284 flag = 1; 1285 len_cur = len_tmp; 1286 start_cur = range->start; 1287 } else { 1288 /* Needs adjusting */ 1289 tmp_start = range->start; 1290 flag = 0; 1291 1292 while ((len_tmp = range->end - tmp_start) >= res->len) { 1293 if ((tmp_start % tmp_divide) == 0) { 1294 flag = 1; 1295 len_cur = len_tmp; 1296 start_cur = tmp_start; 1297 break; 1298 } 1299 tmp_start += tmp_divide - tmp_start % tmp_divide; 1300 if (tmp_start >= range->end) 1301 break; 1302 } 1303 } 1304 1305 if (flag && len_cur == res->len) { 1306 res->start = start_cur; 1307 res->len += 1; /* To restore the balance */ 1308 res->end = res->start + res->len - 1; 1309 return 0; 1310 } 1311 } 1312 } 1313 range = range->next; 1314 } /* end of while */ 1315 1316 if ((!range) && (len_cur == 0)) { 1317 /* have gone through the list of devices and ranges and haven't found n.e.thing */ 1318 err ("no appropriate range.. bailing out...\n"); 1319 return -EINVAL; 1320 } else if (len_cur) { 1321 res->start = start_cur; 1322 res->len += 1; /* To restore the balance */ 1323 res->end = res->start + res->len - 1; 1324 return 0; 1325 } 1326 } else { 1327 /* no more ranges to check on */ 1328 if (len_cur) { 1329 res->start = start_cur; 1330 res->len += 1; /* To restore the balance */ 1331 res->end = res->start + res->len - 1; 1332 return 0; 1333 } else { 1334 /* have gone through the list of devices and haven't found n.e.thing */ 1335 err ("no appropriate range.. bailing out...\n"); 1336 return -EINVAL; 1337 } 1338 } 1339 } /* end if(!res_cur) */ 1340 return -EINVAL; 1341 } 1342 1343 /******************************************************************************** 1344 * This routine is called from remove_card if the card contained PPB. 1345 * It will remove all the resources on the bus as well as the bus itself 1346 * Input: Bus 1347 * Ouput: 0, -ENODEV 1348 ********************************************************************************/ 1349 int ibmphp_remove_bus (struct bus_node *bus, u8 parent_busno) 1350 { 1351 struct resource_node *res_cur; 1352 struct resource_node *res_tmp; 1353 struct bus_node *prev_bus; 1354 int rc; 1355 1356 prev_bus = find_bus_wprev (parent_busno, NULL, 0); 1357 1358 if (!prev_bus) { 1359 debug ("something terribly wrong. Cannot find parent bus to the one to remove\n"); 1360 return -ENODEV; 1361 } 1362 1363 debug ("In ibmphp_remove_bus... prev_bus->busno is %x\n", prev_bus->busno); 1364 1365 rc = remove_ranges (bus, prev_bus); 1366 if (rc) 1367 return rc; 1368 1369 if (bus->firstIO) { 1370 res_cur = bus->firstIO; 1371 while (res_cur) { 1372 res_tmp = res_cur; 1373 if (res_cur->next) 1374 res_cur = res_cur->next; 1375 else 1376 res_cur = res_cur->nextRange; 1377 kfree (res_tmp); 1378 res_tmp = NULL; 1379 } 1380 bus->firstIO = NULL; 1381 } 1382 if (bus->firstMem) { 1383 res_cur = bus->firstMem; 1384 while (res_cur) { 1385 res_tmp = res_cur; 1386 if (res_cur->next) 1387 res_cur = res_cur->next; 1388 else 1389 res_cur = res_cur->nextRange; 1390 kfree (res_tmp); 1391 res_tmp = NULL; 1392 } 1393 bus->firstMem = NULL; 1394 } 1395 if (bus->firstPFMem) { 1396 res_cur = bus->firstPFMem; 1397 while (res_cur) { 1398 res_tmp = res_cur; 1399 if (res_cur->next) 1400 res_cur = res_cur->next; 1401 else 1402 res_cur = res_cur->nextRange; 1403 kfree (res_tmp); 1404 res_tmp = NULL; 1405 } 1406 bus->firstPFMem = NULL; 1407 } 1408 1409 if (bus->firstPFMemFromMem) { 1410 res_cur = bus->firstPFMemFromMem; 1411 while (res_cur) { 1412 res_tmp = res_cur; 1413 res_cur = res_cur->next; 1414 1415 kfree (res_tmp); 1416 res_tmp = NULL; 1417 } 1418 bus->firstPFMemFromMem = NULL; 1419 } 1420 1421 list_del (&bus->bus_list); 1422 kfree (bus); 1423 return 0; 1424 } 1425 1426 /****************************************************************************** 1427 * This routine deletes the ranges from a given bus, and the entries from the 1428 * parent's bus in the resources 1429 * Input: current bus, previous bus 1430 * Output: 0, -EINVAL 1431 ******************************************************************************/ 1432 static int remove_ranges (struct bus_node *bus_cur, struct bus_node *bus_prev) 1433 { 1434 struct range_node *range_cur; 1435 struct range_node *range_tmp; 1436 int i; 1437 struct resource_node *res = NULL; 1438 1439 if (bus_cur->noIORanges) { 1440 range_cur = bus_cur->rangeIO; 1441 for (i = 0; i < bus_cur->noIORanges; i++) { 1442 if (ibmphp_find_resource (bus_prev, range_cur->start, &res, IO) < 0) 1443 return -EINVAL; 1444 ibmphp_remove_resource (res); 1445 1446 range_tmp = range_cur; 1447 range_cur = range_cur->next; 1448 kfree (range_tmp); 1449 range_tmp = NULL; 1450 } 1451 bus_cur->rangeIO = NULL; 1452 } 1453 if (bus_cur->noMemRanges) { 1454 range_cur = bus_cur->rangeMem; 1455 for (i = 0; i < bus_cur->noMemRanges; i++) { 1456 if (ibmphp_find_resource (bus_prev, range_cur->start, &res, MEM) < 0) 1457 return -EINVAL; 1458 1459 ibmphp_remove_resource (res); 1460 range_tmp = range_cur; 1461 range_cur = range_cur->next; 1462 kfree (range_tmp); 1463 range_tmp = NULL; 1464 } 1465 bus_cur->rangeMem = NULL; 1466 } 1467 if (bus_cur->noPFMemRanges) { 1468 range_cur = bus_cur->rangePFMem; 1469 for (i = 0; i < bus_cur->noPFMemRanges; i++) { 1470 if (ibmphp_find_resource (bus_prev, range_cur->start, &res, PFMEM) < 0) 1471 return -EINVAL; 1472 1473 ibmphp_remove_resource (res); 1474 range_tmp = range_cur; 1475 range_cur = range_cur->next; 1476 kfree (range_tmp); 1477 range_tmp = NULL; 1478 } 1479 bus_cur->rangePFMem = NULL; 1480 } 1481 return 0; 1482 } 1483 1484 /* 1485 * find the resource node in the bus 1486 * Input: Resource needed, start address of the resource, type of resource 1487 */ 1488 int ibmphp_find_resource (struct bus_node *bus, u32 start_address, struct resource_node **res, int flag) 1489 { 1490 struct resource_node *res_cur = NULL; 1491 char * type = ""; 1492 1493 if (!bus) { 1494 err ("The bus passed in NULL to find resource\n"); 1495 return -ENODEV; 1496 } 1497 1498 switch (flag) { 1499 case IO: 1500 res_cur = bus->firstIO; 1501 type = "io"; 1502 break; 1503 case MEM: 1504 res_cur = bus->firstMem; 1505 type = "mem"; 1506 break; 1507 case PFMEM: 1508 res_cur = bus->firstPFMem; 1509 type = "pfmem"; 1510 break; 1511 default: 1512 err ("wrong type of flag\n"); 1513 return -EINVAL; 1514 } 1515 1516 while (res_cur) { 1517 if (res_cur->start == start_address) { 1518 *res = res_cur; 1519 break; 1520 } 1521 if (res_cur->next) 1522 res_cur = res_cur->next; 1523 else 1524 res_cur = res_cur->nextRange; 1525 } 1526 1527 if (!res_cur) { 1528 if (flag == PFMEM) { 1529 res_cur = bus->firstPFMemFromMem; 1530 while (res_cur) { 1531 if (res_cur->start == start_address) { 1532 *res = res_cur; 1533 break; 1534 } 1535 res_cur = res_cur->next; 1536 } 1537 if (!res_cur) { 1538 debug ("SOS...cannot find %s resource in the bus.\n", type); 1539 return -EINVAL; 1540 } 1541 } else { 1542 debug ("SOS... cannot find %s resource in the bus.\n", type); 1543 return -EINVAL; 1544 } 1545 } 1546 1547 if (*res) 1548 debug ("*res->start = %x\n", (*res)->start); 1549 1550 return 0; 1551 } 1552 1553 /*********************************************************************** 1554 * This routine will free the resource structures used by the 1555 * system. It is called from cleanup routine for the module 1556 * Parameters: none 1557 * Returns: none 1558 ***********************************************************************/ 1559 void ibmphp_free_resources (void) 1560 { 1561 struct bus_node *bus_cur = NULL; 1562 struct bus_node *bus_tmp; 1563 struct range_node *range_cur; 1564 struct range_node *range_tmp; 1565 struct resource_node *res_cur; 1566 struct resource_node *res_tmp; 1567 struct list_head *tmp; 1568 struct list_head *next; 1569 int i = 0; 1570 flags = 1; 1571 1572 list_for_each_safe (tmp, next, &gbuses) { 1573 bus_cur = list_entry (tmp, struct bus_node, bus_list); 1574 if (bus_cur->noIORanges) { 1575 range_cur = bus_cur->rangeIO; 1576 for (i = 0; i < bus_cur->noIORanges; i++) { 1577 if (!range_cur) 1578 break; 1579 range_tmp = range_cur; 1580 range_cur = range_cur->next; 1581 kfree (range_tmp); 1582 range_tmp = NULL; 1583 } 1584 } 1585 if (bus_cur->noMemRanges) { 1586 range_cur = bus_cur->rangeMem; 1587 for (i = 0; i < bus_cur->noMemRanges; i++) { 1588 if (!range_cur) 1589 break; 1590 range_tmp = range_cur; 1591 range_cur = range_cur->next; 1592 kfree (range_tmp); 1593 range_tmp = NULL; 1594 } 1595 } 1596 if (bus_cur->noPFMemRanges) { 1597 range_cur = bus_cur->rangePFMem; 1598 for (i = 0; i < bus_cur->noPFMemRanges; i++) { 1599 if (!range_cur) 1600 break; 1601 range_tmp = range_cur; 1602 range_cur = range_cur->next; 1603 kfree (range_tmp); 1604 range_tmp = NULL; 1605 } 1606 } 1607 1608 if (bus_cur->firstIO) { 1609 res_cur = bus_cur->firstIO; 1610 while (res_cur) { 1611 res_tmp = res_cur; 1612 if (res_cur->next) 1613 res_cur = res_cur->next; 1614 else 1615 res_cur = res_cur->nextRange; 1616 kfree (res_tmp); 1617 res_tmp = NULL; 1618 } 1619 bus_cur->firstIO = NULL; 1620 } 1621 if (bus_cur->firstMem) { 1622 res_cur = bus_cur->firstMem; 1623 while (res_cur) { 1624 res_tmp = res_cur; 1625 if (res_cur->next) 1626 res_cur = res_cur->next; 1627 else 1628 res_cur = res_cur->nextRange; 1629 kfree (res_tmp); 1630 res_tmp = NULL; 1631 } 1632 bus_cur->firstMem = NULL; 1633 } 1634 if (bus_cur->firstPFMem) { 1635 res_cur = bus_cur->firstPFMem; 1636 while (res_cur) { 1637 res_tmp = res_cur; 1638 if (res_cur->next) 1639 res_cur = res_cur->next; 1640 else 1641 res_cur = res_cur->nextRange; 1642 kfree (res_tmp); 1643 res_tmp = NULL; 1644 } 1645 bus_cur->firstPFMem = NULL; 1646 } 1647 1648 if (bus_cur->firstPFMemFromMem) { 1649 res_cur = bus_cur->firstPFMemFromMem; 1650 while (res_cur) { 1651 res_tmp = res_cur; 1652 res_cur = res_cur->next; 1653 1654 kfree (res_tmp); 1655 res_tmp = NULL; 1656 } 1657 bus_cur->firstPFMemFromMem = NULL; 1658 } 1659 1660 bus_tmp = bus_cur; 1661 list_del (&bus_cur->bus_list); 1662 kfree (bus_tmp); 1663 bus_tmp = NULL; 1664 } 1665 } 1666 1667 /********************************************************************************* 1668 * This function will go over the PFmem resources to check if the EBDA allocated 1669 * pfmem out of memory buckets of the bus. If so, it will change the range numbers 1670 * and a flag to indicate that this resource is out of memory. It will also move the 1671 * Pfmem out of the pfmem resource list to the PFMemFromMem list, and will create 1672 * a new Mem node 1673 * This routine is called right after initialization 1674 *******************************************************************************/ 1675 static int __init once_over (void) 1676 { 1677 struct resource_node *pfmem_cur; 1678 struct resource_node *pfmem_prev; 1679 struct resource_node *mem; 1680 struct bus_node *bus_cur; 1681 struct list_head *tmp; 1682 1683 list_for_each (tmp, &gbuses) { 1684 bus_cur = list_entry (tmp, struct bus_node, bus_list); 1685 if ((!bus_cur->rangePFMem) && (bus_cur->firstPFMem)) { 1686 for (pfmem_cur = bus_cur->firstPFMem, pfmem_prev = NULL; pfmem_cur; pfmem_prev = pfmem_cur, pfmem_cur = pfmem_cur->next) { 1687 pfmem_cur->fromMem = 1; 1688 if (pfmem_prev) 1689 pfmem_prev->next = pfmem_cur->next; 1690 else 1691 bus_cur->firstPFMem = pfmem_cur->next; 1692 1693 if (!bus_cur->firstPFMemFromMem) 1694 pfmem_cur->next = NULL; 1695 else 1696 /* we don't need to sort PFMemFromMem since we're using mem node for 1697 all the real work anyways, so just insert at the beginning of the 1698 list 1699 */ 1700 pfmem_cur->next = bus_cur->firstPFMemFromMem; 1701 1702 bus_cur->firstPFMemFromMem = pfmem_cur; 1703 1704 mem = kzalloc(sizeof(struct resource_node), GFP_KERNEL); 1705 if (!mem) { 1706 err ("out of system memory\n"); 1707 return -ENOMEM; 1708 } 1709 mem->type = MEM; 1710 mem->busno = pfmem_cur->busno; 1711 mem->devfunc = pfmem_cur->devfunc; 1712 mem->start = pfmem_cur->start; 1713 mem->end = pfmem_cur->end; 1714 mem->len = pfmem_cur->len; 1715 if (ibmphp_add_resource (mem) < 0) 1716 err ("Trouble...trouble... EBDA allocated pfmem from mem, but system doesn't display it has this space... unless not PCI device...\n"); 1717 pfmem_cur->rangeno = mem->rangeno; 1718 } /* end for pfmem */ 1719 } /* end if */ 1720 } /* end list_for_each bus */ 1721 return 0; 1722 } 1723 1724 int ibmphp_add_pfmem_from_mem (struct resource_node *pfmem) 1725 { 1726 struct bus_node *bus_cur = find_bus_wprev (pfmem->busno, NULL, 0); 1727 1728 if (!bus_cur) { 1729 err ("cannot find bus of pfmem to add...\n"); 1730 return -ENODEV; 1731 } 1732 1733 if (bus_cur->firstPFMemFromMem) 1734 pfmem->next = bus_cur->firstPFMemFromMem; 1735 else 1736 pfmem->next = NULL; 1737 1738 bus_cur->firstPFMemFromMem = pfmem; 1739 1740 return 0; 1741 } 1742 1743 /* This routine just goes through the buses to see if the bus already exists. 1744 * It is called from ibmphp_find_sec_number, to find out a secondary bus number for 1745 * bridged cards 1746 * Parameters: bus_number 1747 * Returns: Bus pointer or NULL 1748 */ 1749 struct bus_node *ibmphp_find_res_bus (u8 bus_number) 1750 { 1751 return find_bus_wprev (bus_number, NULL, 0); 1752 } 1753 1754 static struct bus_node *find_bus_wprev (u8 bus_number, struct bus_node **prev, u8 flag) 1755 { 1756 struct bus_node *bus_cur; 1757 struct list_head *tmp; 1758 struct list_head *tmp_prev; 1759 1760 list_for_each (tmp, &gbuses) { 1761 tmp_prev = tmp->prev; 1762 bus_cur = list_entry (tmp, struct bus_node, bus_list); 1763 if (flag) 1764 *prev = list_entry (tmp_prev, struct bus_node, bus_list); 1765 if (bus_cur->busno == bus_number) 1766 return bus_cur; 1767 } 1768 1769 return NULL; 1770 } 1771 1772 void ibmphp_print_test (void) 1773 { 1774 int i = 0; 1775 struct bus_node *bus_cur = NULL; 1776 struct range_node *range; 1777 struct resource_node *res; 1778 struct list_head *tmp; 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 (tmp, &gbuses) { 1788 bus_cur = list_entry (tmp, struct bus_node, bus_list); 1789 debug_pci ("This is bus # %d. There are\n", bus_cur->busno); 1790 debug_pci ("IORanges = %d\t", bus_cur->noIORanges); 1791 debug_pci ("MemRanges = %d\t", bus_cur->noMemRanges); 1792 debug_pci ("PFMemRanges = %d\n", bus_cur->noPFMemRanges); 1793 debug_pci ("The IO Ranges are as follows:\n"); 1794 if (bus_cur->rangeIO) { 1795 range = bus_cur->rangeIO; 1796 for (i = 0; i < bus_cur->noIORanges; i++) { 1797 debug_pci ("rangeno is %d\n", range->rangeno); 1798 debug_pci ("[%x - %x]\n", range->start, range->end); 1799 range = range->next; 1800 } 1801 } 1802 1803 debug_pci ("The Mem Ranges are as follows:\n"); 1804 if (bus_cur->rangeMem) { 1805 range = bus_cur->rangeMem; 1806 for (i = 0; i < bus_cur->noMemRanges; i++) { 1807 debug_pci ("rangeno is %d\n", range->rangeno); 1808 debug_pci ("[%x - %x]\n", range->start, range->end); 1809 range = range->next; 1810 } 1811 } 1812 1813 debug_pci ("The PFMem Ranges are as follows:\n"); 1814 1815 if (bus_cur->rangePFMem) { 1816 range = bus_cur->rangePFMem; 1817 for (i = 0; i < bus_cur->noPFMemRanges; i++) { 1818 debug_pci ("rangeno is %d\n", range->rangeno); 1819 debug_pci ("[%x - %x]\n", range->start, range->end); 1820 range = range->next; 1821 } 1822 } 1823 1824 debug_pci ("The resources on this bus are as follows\n"); 1825 1826 debug_pci ("IO...\n"); 1827 if (bus_cur->firstIO) { 1828 res = bus_cur->firstIO; 1829 while (res) { 1830 debug_pci ("The range # is %d\n", res->rangeno); 1831 debug_pci ("The bus, devfnc is %d, %x\n", res->busno, res->devfunc); 1832 debug_pci ("[%x - %x], len=%x\n", res->start, res->end, res->len); 1833 if (res->next) 1834 res = res->next; 1835 else if (res->nextRange) 1836 res = res->nextRange; 1837 else 1838 break; 1839 } 1840 } 1841 debug_pci ("Mem...\n"); 1842 if (bus_cur->firstMem) { 1843 res = bus_cur->firstMem; 1844 while (res) { 1845 debug_pci ("The range # is %d\n", res->rangeno); 1846 debug_pci ("The bus, devfnc is %d, %x\n", res->busno, res->devfunc); 1847 debug_pci ("[%x - %x], len=%x\n", res->start, res->end, res->len); 1848 if (res->next) 1849 res = res->next; 1850 else if (res->nextRange) 1851 res = res->nextRange; 1852 else 1853 break; 1854 } 1855 } 1856 debug_pci ("PFMem...\n"); 1857 if (bus_cur->firstPFMem) { 1858 res = bus_cur->firstPFMem; 1859 while (res) { 1860 debug_pci ("The range # is %d\n", res->rangeno); 1861 debug_pci ("The bus, devfnc is %d, %x\n", res->busno, res->devfunc); 1862 debug_pci ("[%x - %x], len=%x\n", res->start, res->end, res->len); 1863 if (res->next) 1864 res = res->next; 1865 else if (res->nextRange) 1866 res = res->nextRange; 1867 else 1868 break; 1869 } 1870 } 1871 1872 debug_pci ("PFMemFromMem...\n"); 1873 if (bus_cur->firstPFMemFromMem) { 1874 res = bus_cur->firstPFMemFromMem; 1875 while (res) { 1876 debug_pci ("The range # is %d\n", res->rangeno); 1877 debug_pci ("The bus, devfnc is %d, %x\n", res->busno, res->devfunc); 1878 debug_pci ("[%x - %x], len=%x\n", res->start, res->end, res->len); 1879 res = res->next; 1880 } 1881 } 1882 } 1883 debug_pci ("***********************END***********************\n"); 1884 } 1885 1886 static int range_exists_already (struct range_node * range, struct bus_node * bus_cur, u8 type) 1887 { 1888 struct range_node * range_cur = NULL; 1889 switch (type) { 1890 case IO: 1891 range_cur = bus_cur->rangeIO; 1892 break; 1893 case MEM: 1894 range_cur = bus_cur->rangeMem; 1895 break; 1896 case PFMEM: 1897 range_cur = bus_cur->rangePFMem; 1898 break; 1899 default: 1900 err ("wrong type passed to find out if range already exists\n"); 1901 return -ENODEV; 1902 } 1903 1904 while (range_cur) { 1905 if ((range_cur->start == range->start) && (range_cur->end == range->end)) 1906 return 1; 1907 range_cur = range_cur->next; 1908 } 1909 1910 return 0; 1911 } 1912 1913 /* This routine will read the windows for any PPB we have and update the 1914 * range info for the secondary bus, and will also input this info into 1915 * primary bus, since BIOS doesn't. This is for PPB that are in the system 1916 * on bootup. For bridged cards that were added during previous load of the 1917 * driver, only the ranges and the bus structure are added, the devices are 1918 * added from NVRAM 1919 * Input: primary busno 1920 * Returns: none 1921 * Note: this function doesn't take into account IO restrictions etc, 1922 * so will only work for bridges with no video/ISA devices behind them It 1923 * also will not work for onboard PPB's that can have more than 1 *bus 1924 * behind them All these are TO DO. 1925 * Also need to add more error checkings... (from fnc returns etc) 1926 */ 1927 static int __init update_bridge_ranges (struct bus_node **bus) 1928 { 1929 u8 sec_busno, device, function, hdr_type, start_io_address, end_io_address; 1930 u16 vendor_id, upper_io_start, upper_io_end, start_mem_address, end_mem_address; 1931 u32 start_address, end_address, upper_start, upper_end; 1932 struct bus_node *bus_sec; 1933 struct bus_node *bus_cur; 1934 struct resource_node *io; 1935 struct resource_node *mem; 1936 struct resource_node *pfmem; 1937 struct range_node *range; 1938 unsigned int devfn; 1939 1940 bus_cur = *bus; 1941 if (!bus_cur) 1942 return -ENODEV; 1943 ibmphp_pci_bus->number = bus_cur->busno; 1944 1945 debug ("inside %s\n", __func__); 1946 debug ("bus_cur->busno = %x\n", bus_cur->busno); 1947 1948 for (device = 0; device < 32; device++) { 1949 for (function = 0x00; function < 0x08; function++) { 1950 devfn = PCI_DEVFN(device, function); 1951 pci_bus_read_config_word (ibmphp_pci_bus, devfn, PCI_VENDOR_ID, &vendor_id); 1952 1953 if (vendor_id != PCI_VENDOR_ID_NOTVALID) { 1954 /* found correct device!!! */ 1955 pci_bus_read_config_byte (ibmphp_pci_bus, devfn, PCI_HEADER_TYPE, &hdr_type); 1956 1957 switch (hdr_type) { 1958 case PCI_HEADER_TYPE_NORMAL: 1959 function = 0x8; 1960 break; 1961 case PCI_HEADER_TYPE_MULTIDEVICE: 1962 break; 1963 case PCI_HEADER_TYPE_BRIDGE: 1964 function = 0x8; 1965 case PCI_HEADER_TYPE_MULTIBRIDGE: 1966 /* We assume here that only 1 bus behind the bridge 1967 TO DO: add functionality for several: 1968 temp = secondary; 1969 while (temp < subordinate) { 1970 ... 1971 temp++; 1972 } 1973 */ 1974 pci_bus_read_config_byte (ibmphp_pci_bus, devfn, PCI_SECONDARY_BUS, &sec_busno); 1975 bus_sec = find_bus_wprev (sec_busno, NULL, 0); 1976 /* this bus structure doesn't exist yet, PPB was configured during previous loading of ibmphp */ 1977 if (!bus_sec) { 1978 bus_sec = alloc_error_bus (NULL, sec_busno, 1); 1979 /* the rest will be populated during NVRAM call */ 1980 return 0; 1981 } 1982 pci_bus_read_config_byte (ibmphp_pci_bus, devfn, PCI_IO_BASE, &start_io_address); 1983 pci_bus_read_config_byte (ibmphp_pci_bus, devfn, PCI_IO_LIMIT, &end_io_address); 1984 pci_bus_read_config_word (ibmphp_pci_bus, devfn, PCI_IO_BASE_UPPER16, &upper_io_start); 1985 pci_bus_read_config_word (ibmphp_pci_bus, devfn, PCI_IO_LIMIT_UPPER16, &upper_io_end); 1986 start_address = (start_io_address & PCI_IO_RANGE_MASK) << 8; 1987 start_address |= (upper_io_start << 16); 1988 end_address = (end_io_address & PCI_IO_RANGE_MASK) << 8; 1989 end_address |= (upper_io_end << 16); 1990 1991 if ((start_address) && (start_address <= end_address)) { 1992 range = kzalloc(sizeof(struct range_node), GFP_KERNEL); 1993 if (!range) { 1994 err ("out of system memory\n"); 1995 return -ENOMEM; 1996 } 1997 range->start = start_address; 1998 range->end = end_address + 0xfff; 1999 2000 if (bus_sec->noIORanges > 0) { 2001 if (!range_exists_already (range, bus_sec, IO)) { 2002 add_bus_range (IO, range, bus_sec); 2003 ++bus_sec->noIORanges; 2004 } else { 2005 kfree (range); 2006 range = NULL; 2007 } 2008 } else { 2009 /* 1st IO Range on the bus */ 2010 range->rangeno = 1; 2011 bus_sec->rangeIO = range; 2012 ++bus_sec->noIORanges; 2013 } 2014 fix_resources (bus_sec); 2015 2016 if (ibmphp_find_resource (bus_cur, start_address, &io, IO)) { 2017 io = kzalloc(sizeof(struct resource_node), GFP_KERNEL); 2018 if (!io) { 2019 kfree (range); 2020 err ("out of system memory\n"); 2021 return -ENOMEM; 2022 } 2023 io->type = IO; 2024 io->busno = bus_cur->busno; 2025 io->devfunc = ((device << 3) | (function & 0x7)); 2026 io->start = start_address; 2027 io->end = end_address + 0xfff; 2028 io->len = io->end - io->start + 1; 2029 ibmphp_add_resource (io); 2030 } 2031 } 2032 2033 pci_bus_read_config_word (ibmphp_pci_bus, devfn, PCI_MEMORY_BASE, &start_mem_address); 2034 pci_bus_read_config_word (ibmphp_pci_bus, devfn, PCI_MEMORY_LIMIT, &end_mem_address); 2035 2036 start_address = 0x00000000 | (start_mem_address & PCI_MEMORY_RANGE_MASK) << 16; 2037 end_address = 0x00000000 | (end_mem_address & PCI_MEMORY_RANGE_MASK) << 16; 2038 2039 if ((start_address) && (start_address <= end_address)) { 2040 2041 range = kzalloc(sizeof(struct range_node), GFP_KERNEL); 2042 if (!range) { 2043 err ("out of system memory\n"); 2044 return -ENOMEM; 2045 } 2046 range->start = start_address; 2047 range->end = end_address + 0xfffff; 2048 2049 if (bus_sec->noMemRanges > 0) { 2050 if (!range_exists_already (range, bus_sec, MEM)) { 2051 add_bus_range (MEM, range, bus_sec); 2052 ++bus_sec->noMemRanges; 2053 } else { 2054 kfree (range); 2055 range = NULL; 2056 } 2057 } else { 2058 /* 1st Mem Range on the bus */ 2059 range->rangeno = 1; 2060 bus_sec->rangeMem = range; 2061 ++bus_sec->noMemRanges; 2062 } 2063 2064 fix_resources (bus_sec); 2065 2066 if (ibmphp_find_resource (bus_cur, start_address, &mem, MEM)) { 2067 mem = kzalloc(sizeof(struct resource_node), GFP_KERNEL); 2068 if (!mem) { 2069 kfree (range); 2070 err ("out of system memory\n"); 2071 return -ENOMEM; 2072 } 2073 mem->type = MEM; 2074 mem->busno = bus_cur->busno; 2075 mem->devfunc = ((device << 3) | (function & 0x7)); 2076 mem->start = start_address; 2077 mem->end = end_address + 0xfffff; 2078 mem->len = mem->end - mem->start + 1; 2079 ibmphp_add_resource (mem); 2080 } 2081 } 2082 pci_bus_read_config_word (ibmphp_pci_bus, devfn, PCI_PREF_MEMORY_BASE, &start_mem_address); 2083 pci_bus_read_config_word (ibmphp_pci_bus, devfn, PCI_PREF_MEMORY_LIMIT, &end_mem_address); 2084 pci_bus_read_config_dword (ibmphp_pci_bus, devfn, PCI_PREF_BASE_UPPER32, &upper_start); 2085 pci_bus_read_config_dword (ibmphp_pci_bus, devfn, PCI_PREF_LIMIT_UPPER32, &upper_end); 2086 start_address = 0x00000000 | (start_mem_address & PCI_MEMORY_RANGE_MASK) << 16; 2087 end_address = 0x00000000 | (end_mem_address & PCI_MEMORY_RANGE_MASK) << 16; 2088 #if BITS_PER_LONG == 64 2089 start_address |= ((long) upper_start) << 32; 2090 end_address |= ((long) upper_end) << 32; 2091 #endif 2092 2093 if ((start_address) && (start_address <= end_address)) { 2094 2095 range = kzalloc(sizeof(struct range_node), GFP_KERNEL); 2096 if (!range) { 2097 err ("out of system memory\n"); 2098 return -ENOMEM; 2099 } 2100 range->start = start_address; 2101 range->end = end_address + 0xfffff; 2102 2103 if (bus_sec->noPFMemRanges > 0) { 2104 if (!range_exists_already (range, bus_sec, PFMEM)) { 2105 add_bus_range (PFMEM, range, bus_sec); 2106 ++bus_sec->noPFMemRanges; 2107 } else { 2108 kfree (range); 2109 range = NULL; 2110 } 2111 } else { 2112 /* 1st PFMem Range on the bus */ 2113 range->rangeno = 1; 2114 bus_sec->rangePFMem = range; 2115 ++bus_sec->noPFMemRanges; 2116 } 2117 2118 fix_resources (bus_sec); 2119 if (ibmphp_find_resource (bus_cur, start_address, &pfmem, PFMEM)) { 2120 pfmem = kzalloc(sizeof(struct resource_node), GFP_KERNEL); 2121 if (!pfmem) { 2122 kfree (range); 2123 err ("out of system memory\n"); 2124 return -ENOMEM; 2125 } 2126 pfmem->type = PFMEM; 2127 pfmem->busno = bus_cur->busno; 2128 pfmem->devfunc = ((device << 3) | (function & 0x7)); 2129 pfmem->start = start_address; 2130 pfmem->end = end_address + 0xfffff; 2131 pfmem->len = pfmem->end - pfmem->start + 1; 2132 pfmem->fromMem = 0; 2133 2134 ibmphp_add_resource (pfmem); 2135 } 2136 } 2137 break; 2138 } /* end of switch */ 2139 } /* end if vendor */ 2140 } /* end for function */ 2141 } /* end for device */ 2142 2143 bus = &bus_cur; 2144 return 0; 2145 } 2146