drivers/pci/hotplug/ibmphp_res.c

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