pci/hotplug/ibmphp_res.c

0001 // SPDX-License-Identifier: GPL-2.0+
0002 /*
0003  * IBM Hot Plug Controller Driver
0004  *
0005  * Written By: Irene Zubarev, IBM Corporation
0006  *
0007  * Copyright (C) 2001 Greg Kroah-Hartman (greg@kroah.com)
0008  * Copyright (C) 2001,2002 IBM Corp.
0009  *
0010  * All rights reserved.
0011  *
0012  * Send feedback to <gregkh@us.ibm.com>
0013  *
0014  */
0015
0016 #include <linux/module.h>
0017 #include <linux/slab.h>
0018 #include <linux/pci.h>
0019 #include <linux/list.h>
0020 #include <linux/init.h>
0021 #include "ibmphp.h"
0022
0023 static int flags = 0;       /* for testing */
0024
0025 static void update_resources(struct bus_node *bus_cur, int type, int rangeno);
0026 static int once_over(void);
0027 static int remove_ranges(struct bus_node *, struct bus_node *);
0028 static int update_bridge_ranges(struct bus_node **);
0029 static int add_bus_range(int type, struct range_node *, struct bus_node *);
0030 static void fix_resources(struct bus_node *);
0031 static struct bus_node *find_bus_wprev(u8, struct bus_node **, u8);
0032
0033 static LIST_HEAD(gbuses);
0034
0035 static struct bus_node * __init alloc_error_bus(struct ebda_pci_rsrc *curr, u8 busno, int flag)
0036 {
0037     struct bus_node *newbus;
0038
0039     if (!(curr) && !(flag)) {
0040         err("NULL pointer passed\n");
0041         return NULL;
0042     }
0043
0044     newbus = kzalloc(sizeof(struct bus_node), GFP_KERNEL);
0045     if (!newbus)
0046         return NULL;
0047
0048     if (flag)
0049         newbus->busno = busno;
0050     else
0051         newbus->busno = curr->bus_num;
0052     list_add_tail(&newbus->bus_list, &gbuses);
0053     return newbus;
0054 }
0055
0056 static struct resource_node * __init alloc_resources(struct ebda_pci_rsrc *curr)
0057 {
0058     struct resource_node *rs;
0059
0060     if (!curr) {
0061         err("NULL passed to allocate\n");
0062         return NULL;
0063     }
0064
0065     rs = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
0066     if (!rs)
0067         return NULL;
0068
0069     rs->busno = curr->bus_num;
0070     rs->devfunc = curr->dev_fun;
0071     rs->start = curr->start_addr;
0072     rs->end = curr->end_addr;
0073     rs->len = curr->end_addr - curr->start_addr + 1;
0074     return rs;
0075 }
0076
0077 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)
0078 {
0079     struct bus_node *newbus;
0080     struct range_node *newrange;
0081     u8 num_ranges = 0;
0082
0083     if (first_bus) {
0084         newbus = kzalloc(sizeof(struct bus_node), GFP_KERNEL);
0085         if (!newbus)
0086             return -ENOMEM;
0087
0088         newbus->busno = curr->bus_num;
0089     } else {
0090         newbus = *new_bus;
0091         switch (flag) {
0092             case MEM:
0093                 num_ranges = newbus->noMemRanges;
0094                 break;
0095             case PFMEM:
0096                 num_ranges = newbus->noPFMemRanges;
0097                 break;
0098             case IO:
0099                 num_ranges = newbus->noIORanges;
0100                 break;
0101         }
0102     }
0103
0104     newrange = kzalloc(sizeof(struct range_node), GFP_KERNEL);
0105     if (!newrange) {
0106         if (first_bus)
0107             kfree(newbus);
0108         return -ENOMEM;
0109     }
0110     newrange->start = curr->start_addr;
0111     newrange->end = curr->end_addr;
0112
0113     if (first_bus || (!num_ranges))
0114         newrange->rangeno = 1;
0115     else {
0116         /* need to insert our range */
0117         add_bus_range(flag, newrange, newbus);
0118         debug("%d resource Primary Bus inserted on bus %x [%x - %x]\n", flag, newbus->busno, newrange->start, newrange->end);
0119     }
0120
0121     switch (flag) {
0122         case MEM:
0123             newbus->rangeMem = newrange;
0124             if (first_bus)
0125                 newbus->noMemRanges = 1;
0126             else {
0127                 debug("First Memory Primary on bus %x, [%x - %x]\n", newbus->busno, newrange->start, newrange->end);
0128                 ++newbus->noMemRanges;
0129                 fix_resources(newbus);
0130             }
0131             break;
0132         case IO:
0133             newbus->rangeIO = newrange;
0134             if (first_bus)
0135                 newbus->noIORanges = 1;
0136             else {
0137                 debug("First IO Primary on bus %x, [%x - %x]\n", newbus->busno, newrange->start, newrange->end);
0138                 ++newbus->noIORanges;
0139                 fix_resources(newbus);
0140             }
0141             break;
0142         case PFMEM:
0143             newbus->rangePFMem = newrange;
0144             if (first_bus)
0145                 newbus->noPFMemRanges = 1;
0146             else {
0147                 debug("1st PFMemory Primary on Bus %x [%x - %x]\n", newbus->busno, newrange->start, newrange->end);
0148                 ++newbus->noPFMemRanges;
0149                 fix_resources(newbus);
0150             }
0151
0152             break;
0153     }
0154
0155     *new_bus = newbus;
0156     *new_range = newrange;
0157     return 0;
0158 }
0159
0160
0161 /* Notes:
0162  * 1. The ranges are ordered.  The buses are not ordered.  (First come)
0163  *
0164  * 2. If cannot allocate out of PFMem range, allocate from Mem ranges.  PFmemFromMem
0165  * are not sorted. (no need since use mem node). To not change the entire code, we
0166  * also add mem node whenever this case happens so as not to change
0167  * ibmphp_check_mem_resource etc(and since it really is taking Mem resource)
0168  */
0169
0170 /*****************************************************************************
0171  * This is the Resource Management initialization function.  It will go through
0172  * the Resource list taken from EBDA and fill in this module's data structures
0173  *
0174  * THIS IS NOT TAKING INTO CONSIDERATION IO RESTRICTIONS OF PRIMARY BUSES,
0175  * SINCE WE'RE GOING TO ASSUME FOR NOW WE DON'T HAVE THOSE ON OUR BUSES FOR NOW
0176  *
0177  * Input: ptr to the head of the resource list from EBDA
0178  * Output: 0, -1 or error codes
0179  ***************************************************************************/
0180 int __init ibmphp_rsrc_init(void)
0181 {
0182     struct ebda_pci_rsrc *curr;
0183     struct range_node *newrange = NULL;
0184     struct bus_node *newbus = NULL;
0185     struct bus_node *bus_cur;
0186     struct bus_node *bus_prev;
0187     struct resource_node *new_io = NULL;
0188     struct resource_node *new_mem = NULL;
0189     struct resource_node *new_pfmem = NULL;
0190     int rc;
0191
0192     list_for_each_entry(curr, &ibmphp_ebda_pci_rsrc_head,
0193                 ebda_pci_rsrc_list) {
0194         if (!(curr->rsrc_type & PCIDEVMASK)) {
0195             /* EBDA still lists non PCI devices, so ignore... */
0196             debug("this is not a PCI DEVICE in rsrc_init, please take care\n");
0197             // continue;
0198         }
0199
0200         /* this is a primary bus resource */
0201         if (curr->rsrc_type & PRIMARYBUSMASK) {
0202             /* memory */
0203             if ((curr->rsrc_type & RESTYPE) == MMASK) {
0204                 /* no bus structure exists in place yet */
0205                 if (list_empty(&gbuses)) {
0206                     rc = alloc_bus_range(&newbus, &newrange, curr, MEM, 1);
0207                     if (rc)
0208                         return rc;
0209                     list_add_tail(&newbus->bus_list, &gbuses);
0210                     debug("gbuses = NULL, Memory Primary Bus %x [%x - %x]\n", newbus->busno, newrange->start, newrange->end);
0211                 } else {
0212                     bus_cur = find_bus_wprev(curr->bus_num, &bus_prev, 1);
0213                     /* found our bus */
0214                     if (bus_cur) {
0215                         rc = alloc_bus_range(&bus_cur, &newrange, curr, MEM, 0);
0216                         if (rc)
0217                             return rc;
0218                     } else {
0219                         /* went through all the buses and didn't find ours, need to create a new bus node */
0220                         rc = alloc_bus_range(&newbus, &newrange, curr, MEM, 1);
0221                         if (rc)
0222                             return rc;
0223
0224                         list_add_tail(&newbus->bus_list, &gbuses);
0225                         debug("New Bus, Memory Primary Bus %x [%x - %x]\n", newbus->busno, newrange->start, newrange->end);
0226                     }
0227                 }
0228             } else if ((curr->rsrc_type & RESTYPE) == PFMASK) {
0229                 /* prefetchable memory */
0230                 if (list_empty(&gbuses)) {
0231                     /* no bus structure exists in place yet */
0232                     rc = alloc_bus_range(&newbus, &newrange, curr, PFMEM, 1);
0233                     if (rc)
0234                         return rc;
0235                     list_add_tail(&newbus->bus_list, &gbuses);
0236                     debug("gbuses = NULL, PFMemory Primary Bus %x [%x - %x]\n", newbus->busno, newrange->start, newrange->end);
0237                 } else {
0238                     bus_cur = find_bus_wprev(curr->bus_num, &bus_prev, 1);
0239                     if (bus_cur) {
0240                         /* found our bus */
0241                         rc = alloc_bus_range(&bus_cur, &newrange, curr, PFMEM, 0);
0242                         if (rc)
0243                             return rc;
0244                     } else {
0245                         /* went through all the buses and didn't find ours, need to create a new bus node */
0246                         rc = alloc_bus_range(&newbus, &newrange, curr, PFMEM, 1);
0247                         if (rc)
0248                             return rc;
0249                         list_add_tail(&newbus->bus_list, &gbuses);
0250                         debug("1st Bus, PFMemory Primary Bus %x [%x - %x]\n", newbus->busno, newrange->start, newrange->end);
0251                     }
0252                 }
0253             } else if ((curr->rsrc_type & RESTYPE) == IOMASK) {
0254                 /* IO */
0255                 if (list_empty(&gbuses)) {
0256                     /* no bus structure exists in place yet */
0257                     rc = alloc_bus_range(&newbus, &newrange, curr, IO, 1);
0258                     if (rc)
0259                         return rc;
0260                     list_add_tail(&newbus->bus_list, &gbuses);
0261                     debug("gbuses = NULL, IO Primary Bus %x [%x - %x]\n", newbus->busno, newrange->start, newrange->end);
0262                 } else {
0263                     bus_cur = find_bus_wprev(curr->bus_num, &bus_prev, 1);
0264                     if (bus_cur) {
0265                         rc = alloc_bus_range(&bus_cur, &newrange, curr, IO, 0);
0266                         if (rc)
0267                             return rc;
0268                     } else {
0269                         /* went through all the buses and didn't find ours, need to create a new bus node */
0270                         rc = alloc_bus_range(&newbus, &newrange, curr, IO, 1);
0271                         if (rc)
0272                             return rc;
0273                         list_add_tail(&newbus->bus_list, &gbuses);
0274                         debug("1st Bus, IO Primary Bus %x [%x - %x]\n", newbus->busno, newrange->start, newrange->end);
0275                     }
0276                 }
0277
0278             } else {
0279                 ;   /* type is reserved  WHAT TO DO IN THIS CASE???
0280                        NOTHING TO DO??? */
0281             }
0282         } else {
0283             /* regular pci device resource */
0284             if ((curr->rsrc_type & RESTYPE) == MMASK) {
0285                 /* Memory resource */
0286                 new_mem = alloc_resources(curr);
0287                 if (!new_mem)
0288                     return -ENOMEM;
0289                 new_mem->type = MEM;
0290                 /*
0291                  * if it didn't find the bus, means PCI dev
0292                  * came b4 the Primary Bus info, so need to
0293                  * create a bus rangeno becomes a problem...
0294                  * assign a -1 and then update once the range
0295                  * actually appears...
0296                  */
0297                 if (ibmphp_add_resource(new_mem) < 0) {
0298                     newbus = alloc_error_bus(curr, 0, 0);
0299                     if (!newbus)
0300                         return -ENOMEM;
0301                     newbus->firstMem = new_mem;
0302                     ++newbus->needMemUpdate;
0303                     new_mem->rangeno = -1;
0304                 }
0305                 debug("Memory resource for device %x, bus %x, [%x - %x]\n", new_mem->devfunc, new_mem->busno, new_mem->start, new_mem->end);
0306
0307             } else if ((curr->rsrc_type & RESTYPE) == PFMASK) {
0308                 /* PFMemory resource */
0309                 new_pfmem = alloc_resources(curr);
0310                 if (!new_pfmem)
0311                     return -ENOMEM;
0312                 new_pfmem->type = PFMEM;
0313                 new_pfmem->fromMem = 0;
0314                 if (ibmphp_add_resource(new_pfmem) < 0) {
0315                     newbus = alloc_error_bus(curr, 0, 0);
0316                     if (!newbus)
0317                         return -ENOMEM;
0318                     newbus->firstPFMem = new_pfmem;
0319                     ++newbus->needPFMemUpdate;
0320                     new_pfmem->rangeno = -1;
0321                 }
0322
0323                 debug("PFMemory resource for device %x, bus %x, [%x - %x]\n", new_pfmem->devfunc, new_pfmem->busno, new_pfmem->start, new_pfmem->end);
0324             } else if ((curr->rsrc_type & RESTYPE) == IOMASK) {
0325                 /* IO resource */
0326                 new_io = alloc_resources(curr);
0327                 if (!new_io)
0328                     return -ENOMEM;
0329                 new_io->type = IO;
0330
0331                 /*
0332                  * if it didn't find the bus, means PCI dev
0333                  * came b4 the Primary Bus info, so need to
0334                  * create a bus rangeno becomes a problem...
0335                  * Can assign a -1 and then update once the
0336                  * range actually appears...
0337                  */
0338                 if (ibmphp_add_resource(new_io) < 0) {
0339                     newbus = alloc_error_bus(curr, 0, 0);
0340                     if (!newbus)
0341                         return -ENOMEM;
0342                     newbus->firstIO = new_io;
0343                     ++newbus->needIOUpdate;
0344                     new_io->rangeno = -1;
0345                 }
0346                 debug("IO resource for device %x, bus %x, [%x - %x]\n", new_io->devfunc, new_io->busno, new_io->start, new_io->end);
0347             }
0348         }
0349     }
0350
0351     list_for_each_entry(bus_cur, &gbuses, bus_list) {
0352         /* This is to get info about PPB resources, since EBDA doesn't put this info into the primary bus info */
0353         rc = update_bridge_ranges(&bus_cur);
0354         if (rc)
0355             return rc;
0356     }
0357     return once_over(); /* This is to align ranges (so no -1) */
0358 }
0359
0360 /********************************************************************************
0361  * This function adds a range into a sorted list of ranges per bus for a particular
0362  * range type, it then calls another routine to update the range numbers on the
0363  * pci devices' resources for the appropriate resource
0364  *
0365  * Input: type of the resource, range to add, current bus
0366  * Output: 0 or -1, bus and range ptrs
0367  ********************************************************************************/
0368 static int add_bus_range(int type, struct range_node *range, struct bus_node *bus_cur)
0369 {
0370     struct range_node *range_cur = NULL;
0371     struct range_node *range_prev;
0372     int count = 0, i_init;
0373     int noRanges = 0;
0374
0375     switch (type) {
0376         case MEM:
0377             range_cur = bus_cur->rangeMem;
0378             noRanges = bus_cur->noMemRanges;
0379             break;
0380         case PFMEM:
0381             range_cur = bus_cur->rangePFMem;
0382             noRanges = bus_cur->noPFMemRanges;
0383             break;
0384         case IO:
0385             range_cur = bus_cur->rangeIO;
0386             noRanges = bus_cur->noIORanges;
0387             break;
0388     }
0389
0390     range_prev = NULL;
0391     while (range_cur) {
0392         if (range->start < range_cur->start)
0393             break;
0394         range_prev = range_cur;
0395         range_cur = range_cur->next;
0396         count = count + 1;
0397     }
0398     if (!count) {
0399         /* our range will go at the beginning of the list */
0400         switch (type) {
0401             case MEM:
0402                 bus_cur->rangeMem = range;
0403                 break;
0404             case PFMEM:
0405                 bus_cur->rangePFMem = range;
0406                 break;
0407             case IO:
0408                 bus_cur->rangeIO = range;
0409                 break;
0410         }
0411         range->next = range_cur;
0412         range->rangeno = 1;
0413         i_init = 0;
0414     } else if (!range_cur) {
0415         /* our range will go at the end of the list */
0416         range->next = NULL;
0417         range_prev->next = range;
0418         range->rangeno = range_prev->rangeno + 1;
0419         return 0;
0420     } else {
0421         /* the range is in the middle */
0422         range_prev->next = range;
0423         range->next = range_cur;
0424         range->rangeno = range_cur->rangeno;
0425         i_init = range_prev->rangeno;
0426     }
0427
0428     for (count = i_init; count < noRanges; ++count) {
0429         ++range_cur->rangeno;
0430         range_cur = range_cur->next;
0431     }
0432
0433     update_resources(bus_cur, type, i_init + 1);
0434     return 0;
0435 }
0436
0437 /*******************************************************************************
0438  * This routine goes through the list of resources of type 'type' and updates
0439  * the range numbers that they correspond to.  It was called from add_bus_range fnc
0440  *
0441  * Input: bus, type of the resource, the rangeno starting from which to update
0442  ******************************************************************************/
0443 static void update_resources(struct bus_node *bus_cur, int type, int rangeno)
0444 {
0445     struct resource_node *res = NULL;
0446     u8 eol = 0; /* end of list indicator */
0447
0448     switch (type) {
0449         case MEM:
0450             if (bus_cur->firstMem)
0451                 res = bus_cur->firstMem;
0452             break;
0453         case PFMEM:
0454             if (bus_cur->firstPFMem)
0455                 res = bus_cur->firstPFMem;
0456             break;
0457         case IO:
0458             if (bus_cur->firstIO)
0459                 res = bus_cur->firstIO;
0460             break;
0461     }
0462
0463     if (res) {
0464         while (res) {
0465             if (res->rangeno == rangeno)
0466                 break;
0467             if (res->next)
0468                 res = res->next;
0469             else if (res->nextRange)
0470                 res = res->nextRange;
0471             else {
0472                 eol = 1;
0473                 break;
0474             }
0475         }
0476
0477         if (!eol) {
0478             /* found the range */
0479             while (res) {
0480                 ++res->rangeno;
0481                 res = res->next;
0482             }
0483         }
0484     }
0485 }
0486
0487 static void fix_me(struct resource_node *res, struct bus_node *bus_cur, struct range_node *range)
0488 {
0489     char *str = "";
0490     switch (res->type) {
0491         case IO:
0492             str = "io";
0493             break;
0494         case MEM:
0495             str = "mem";
0496             break;
0497         case PFMEM:
0498             str = "pfmem";
0499             break;
0500     }
0501
0502     while (res) {
0503         if (res->rangeno == -1) {
0504             while (range) {
0505                 if ((res->start >= range->start) && (res->end <= range->end)) {
0506                     res->rangeno = range->rangeno;
0507                     debug("%s->rangeno in fix_resources is %d\n", str, res->rangeno);
0508                     switch (res->type) {
0509                         case IO:
0510                             --bus_cur->needIOUpdate;
0511                             break;
0512                         case MEM:
0513                             --bus_cur->needMemUpdate;
0514                             break;
0515                         case PFMEM:
0516                             --bus_cur->needPFMemUpdate;
0517                             break;
0518                     }
0519                     break;
0520                 }
0521                 range = range->next;
0522             }
0523         }
0524         if (res->next)
0525             res = res->next;
0526         else
0527             res = res->nextRange;
0528     }
0529
0530 }
0531
0532 /*****************************************************************************
0533  * This routine reassigns the range numbers to the resources that had a -1
0534  * This case can happen only if upon initialization, resources taken by pci dev
0535  * appear in EBDA before the resources allocated for that bus, since we don't
0536  * know the range, we assign -1, and this routine is called after a new range
0537  * is assigned to see the resources with unknown range belong to the added range
0538  *
0539  * Input: current bus
0540  * Output: none, list of resources for that bus are fixed if can be
0541  *******************************************************************************/
0542 static void fix_resources(struct bus_node *bus_cur)
0543 {
0544     struct range_node *range;
0545     struct resource_node *res;
0546
0547     debug("%s - bus_cur->busno = %d\n", __func__, bus_cur->busno);
0548
0549     if (bus_cur->needIOUpdate) {
0550         res = bus_cur->firstIO;
0551         range = bus_cur->rangeIO;
0552         fix_me(res, bus_cur, range);
0553     }
0554     if (bus_cur->needMemUpdate) {
0555         res = bus_cur->firstMem;
0556         range = bus_cur->rangeMem;
0557         fix_me(res, bus_cur, range);
0558     }
0559     if (bus_cur->needPFMemUpdate) {
0560         res = bus_cur->firstPFMem;
0561         range = bus_cur->rangePFMem;
0562         fix_me(res, bus_cur, range);
0563     }
0564 }
0565
0566 /*******************************************************************************
0567  * This routine adds a resource to the list of resources to the appropriate bus
0568  * based on their resource type and sorted by their starting addresses.  It assigns
0569  * the ptrs to next and nextRange if needed.
0570  *
0571  * Input: resource ptr
0572  * Output: ptrs assigned (to the node)
0573  * 0 or -1
0574  *******************************************************************************/
0575 int ibmphp_add_resource(struct resource_node *res)
0576 {
0577     struct resource_node *res_cur;
0578     struct resource_node *res_prev;
0579     struct bus_node *bus_cur;
0580     struct range_node *range_cur = NULL;
0581     struct resource_node *res_start = NULL;
0582
0583     debug("%s - enter\n", __func__);
0584
0585     if (!res) {
0586         err("NULL passed to add\n");
0587         return -ENODEV;
0588     }
0589
0590     bus_cur = find_bus_wprev(res->busno, NULL, 0);
0591
0592     if (!bus_cur) {
0593         /* didn't find a bus, something's wrong!!! */
0594         debug("no bus in the system, either pci_dev's wrong or allocation failed\n");
0595         return -ENODEV;
0596     }
0597
0598     /* Normal case */
0599     switch (res->type) {
0600         case IO:
0601             range_cur = bus_cur->rangeIO;
0602             res_start = bus_cur->firstIO;
0603             break;
0604         case MEM:
0605             range_cur = bus_cur->rangeMem;
0606             res_start = bus_cur->firstMem;
0607             break;
0608         case PFMEM:
0609             range_cur = bus_cur->rangePFMem;
0610             res_start = bus_cur->firstPFMem;
0611             break;
0612         default:
0613             err("cannot read the type of the resource to add... problem\n");
0614             return -EINVAL;
0615     }
0616     while (range_cur) {
0617         if ((res->start >= range_cur->start) && (res->end <= range_cur->end)) {
0618             res->rangeno = range_cur->rangeno;
0619             break;
0620         }
0621         range_cur = range_cur->next;
0622     }
0623
0624     /* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
0625      * this is again the case of rangeno = -1
0626      * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
0627      */
0628
0629     if (!range_cur) {
0630         switch (res->type) {
0631             case IO:
0632                 ++bus_cur->needIOUpdate;
0633                 break;
0634             case MEM:
0635                 ++bus_cur->needMemUpdate;
0636                 break;
0637             case PFMEM:
0638                 ++bus_cur->needPFMemUpdate;
0639                 break;
0640         }
0641         res->rangeno = -1;
0642     }
0643
0644     debug("The range is %d\n", res->rangeno);
0645     if (!res_start) {
0646         /* no first{IO,Mem,Pfmem} on the bus, 1st IO/Mem/Pfmem resource ever */
0647         switch (res->type) {
0648             case IO:
0649                 bus_cur->firstIO = res;
0650                 break;
0651             case MEM:
0652                 bus_cur->firstMem = res;
0653                 break;
0654             case PFMEM:
0655                 bus_cur->firstPFMem = res;
0656                 break;
0657         }
0658         res->next = NULL;
0659         res->nextRange = NULL;
0660     } else {
0661         res_cur = res_start;
0662         res_prev = NULL;
0663
0664         debug("res_cur->rangeno is %d\n", res_cur->rangeno);
0665
0666         while (res_cur) {
0667             if (res_cur->rangeno >= res->rangeno)
0668                 break;
0669             res_prev = res_cur;
0670             if (res_cur->next)
0671                 res_cur = res_cur->next;
0672             else
0673                 res_cur = res_cur->nextRange;
0674         }
0675
0676         if (!res_cur) {
0677             /* at the end of the resource list */
0678             debug("i should be here, [%x - %x]\n", res->start, res->end);
0679             res_prev->nextRange = res;
0680             res->next = NULL;
0681             res->nextRange = NULL;
0682         } else if (res_cur->rangeno == res->rangeno) {
0683             /* in the same range */
0684             while (res_cur) {
0685                 if (res->start < res_cur->start)
0686                     break;
0687                 res_prev = res_cur;
0688                 res_cur = res_cur->next;
0689             }
0690             if (!res_cur) {
0691                 /* the last resource in this range */
0692                 res_prev->next = res;
0693                 res->next = NULL;
0694                 res->nextRange = res_prev->nextRange;
0695                 res_prev->nextRange = NULL;
0696             } else if (res->start < res_cur->start) {
0697                 /* at the beginning or middle of the range */
0698                 if (!res_prev)  {
0699                     switch (res->type) {
0700                         case IO:
0701                             bus_cur->firstIO = res;
0702                             break;
0703                         case MEM:
0704                             bus_cur->firstMem = res;
0705                             break;
0706                         case PFMEM:
0707                             bus_cur->firstPFMem = res;
0708                             break;
0709                     }
0710                 } else if (res_prev->rangeno == res_cur->rangeno)
0711                     res_prev->next = res;
0712                 else
0713                     res_prev->nextRange = res;
0714
0715                 res->next = res_cur;
0716                 res->nextRange = NULL;
0717             }
0718         } else {
0719             /* this is the case where it is 1st occurrence of the range */
0720             if (!res_prev) {
0721                 /* at the beginning of the resource list */
0722                 res->next = NULL;
0723                 switch (res->type) {
0724                     case IO:
0725                         res->nextRange = bus_cur->firstIO;
0726                         bus_cur->firstIO = res;
0727                         break;
0728                     case MEM:
0729                         res->nextRange = bus_cur->firstMem;
0730                         bus_cur->firstMem = res;
0731                         break;
0732                     case PFMEM:
0733                         res->nextRange = bus_cur->firstPFMem;
0734                         bus_cur->firstPFMem = res;
0735                         break;
0736                 }
0737             } else if (res_cur->rangeno > res->rangeno) {
0738                 /* in the middle of the resource list */
0739                 res_prev->nextRange = res;
0740                 res->next = NULL;
0741                 res->nextRange = res_cur;
0742             }
0743         }
0744     }
0745
0746     debug("%s - exit\n", __func__);
0747     return 0;
0748 }
0749
0750 /****************************************************************************
0751  * This routine will remove the resource from the list of resources
0752  *
0753  * Input: io, mem, and/or pfmem resource to be deleted
0754  * Output: modified resource list
0755  *        0 or error code
0756  ****************************************************************************/
0757 int ibmphp_remove_resource(struct resource_node *res)
0758 {
0759     struct bus_node *bus_cur;
0760     struct resource_node *res_cur = NULL;
0761     struct resource_node *res_prev;
0762     struct resource_node *mem_cur;
0763     char *type = "";
0764
0765     if (!res)  {
0766         err("resource to remove is NULL\n");
0767         return -ENODEV;
0768     }
0769
0770     bus_cur = find_bus_wprev(res->busno, NULL, 0);
0771
0772     if (!bus_cur) {
0773         err("cannot find corresponding bus of the io resource to remove  bailing out...\n");
0774         return -ENODEV;
0775     }
0776
0777     switch (res->type) {
0778         case IO:
0779             res_cur = bus_cur->firstIO;
0780             type = "io";
0781             break;
0782         case MEM:
0783             res_cur = bus_cur->firstMem;
0784             type = "mem";
0785             break;
0786         case PFMEM:
0787             res_cur = bus_cur->firstPFMem;
0788             type = "pfmem";
0789             break;
0790         default:
0791             err("unknown type for resource to remove\n");
0792             return -EINVAL;
0793     }
0794     res_prev = NULL;
0795
0796     while (res_cur) {
0797         if ((res_cur->start == res->start) && (res_cur->end == res->end))
0798             break;
0799         res_prev = res_cur;
0800         if (res_cur->next)
0801             res_cur = res_cur->next;
0802         else
0803             res_cur = res_cur->nextRange;
0804     }
0805
0806     if (!res_cur) {
0807         if (res->type == PFMEM) {
0808             /*
0809              * case where pfmem might be in the PFMemFromMem list
0810              * so will also need to remove the corresponding mem
0811              * entry
0812              */
0813             res_cur = bus_cur->firstPFMemFromMem;
0814             res_prev = NULL;
0815
0816             while (res_cur) {
0817                 if ((res_cur->start == res->start) && (res_cur->end == res->end)) {
0818                     mem_cur = bus_cur->firstMem;
0819                     while (mem_cur) {
0820                         if ((mem_cur->start == res_cur->start)
0821                             && (mem_cur->end == res_cur->end))
0822                             break;
0823                         if (mem_cur->next)
0824                             mem_cur = mem_cur->next;
0825                         else
0826                             mem_cur = mem_cur->nextRange;
0827                     }
0828                     if (!mem_cur) {
0829                         err("cannot find corresponding mem node for pfmem...\n");
0830                         return -EINVAL;
0831                     }
0832
0833                     ibmphp_remove_resource(mem_cur);
0834                     if (!res_prev)
0835                         bus_cur->firstPFMemFromMem = res_cur->next;
0836                     else
0837                         res_prev->next = res_cur->next;
0838                     kfree(res_cur);
0839                     return 0;
0840                 }
0841                 res_prev = res_cur;
0842                 if (res_cur->next)
0843                     res_cur = res_cur->next;
0844                 else
0845                     res_cur = res_cur->nextRange;
0846             }
0847             if (!res_cur) {
0848                 err("cannot find pfmem to delete...\n");
0849                 return -EINVAL;
0850             }
0851         } else {
0852             err("the %s resource is not in the list to be deleted...\n", type);
0853             return -EINVAL;
0854         }
0855     }
0856     if (!res_prev) {
0857         /* first device to be deleted */
0858         if (res_cur->next) {
0859             switch (res->type) {
0860                 case IO:
0861                     bus_cur->firstIO = res_cur->next;
0862                     break;
0863                 case MEM:
0864                     bus_cur->firstMem = res_cur->next;
0865                     break;
0866                 case PFMEM:
0867                     bus_cur->firstPFMem = res_cur->next;
0868                     break;
0869             }
0870         } else if (res_cur->nextRange) {
0871             switch (res->type) {
0872                 case IO:
0873                     bus_cur->firstIO = res_cur->nextRange;
0874                     break;
0875                 case MEM:
0876                     bus_cur->firstMem = res_cur->nextRange;
0877                     break;
0878                 case PFMEM:
0879                     bus_cur->firstPFMem = res_cur->nextRange;
0880                     break;
0881             }
0882         } else {
0883             switch (res->type) {
0884                 case IO:
0885                     bus_cur->firstIO = NULL;
0886                     break;
0887                 case MEM:
0888                     bus_cur->firstMem = NULL;
0889                     break;
0890                 case PFMEM:
0891                     bus_cur->firstPFMem = NULL;
0892                     break;
0893             }
0894         }
0895         kfree(res_cur);
0896         return 0;
0897     } else {
0898         if (res_cur->next) {
0899             if (res_prev->rangeno == res_cur->rangeno)
0900                 res_prev->next = res_cur->next;
0901             else
0902                 res_prev->nextRange = res_cur->next;
0903         } else if (res_cur->nextRange) {
0904             res_prev->next = NULL;
0905             res_prev->nextRange = res_cur->nextRange;
0906         } else {
0907             res_prev->next = NULL;
0908             res_prev->nextRange = NULL;
0909         }
0910         kfree(res_cur);
0911         return 0;
0912     }
0913
0914     return 0;
0915 }
0916
0917 static struct range_node *find_range(struct bus_node *bus_cur, struct resource_node *res)
0918 {
0919     struct range_node *range = NULL;
0920
0921     switch (res->type) {
0922         case IO:
0923             range = bus_cur->rangeIO;
0924             break;
0925         case MEM:
0926             range = bus_cur->rangeMem;
0927             break;
0928         case PFMEM:
0929             range = bus_cur->rangePFMem;
0930             break;
0931         default:
0932             err("cannot read resource type in find_range\n");
0933     }
0934
0935     while (range) {
0936         if (res->rangeno == range->rangeno)
0937             break;
0938         range = range->next;
0939     }
0940     return range;
0941 }
0942
0943 /*****************************************************************************
0944  * This routine will check to make sure the io/mem/pfmem->len that the device asked for
0945  * can fit w/i our list of available IO/MEM/PFMEM resources.  If cannot, returns -EINVAL,
0946  * otherwise, returns 0
0947  *
0948  * Input: resource
0949  * Output: the correct start and end address are inputted into the resource node,
0950  *        0 or -EINVAL
0951  *****************************************************************************/
0952 int ibmphp_check_resource(struct resource_node *res, u8 bridge)
0953 {
0954     struct bus_node *bus_cur;
0955     struct range_node *range = NULL;
0956     struct resource_node *res_prev;
0957     struct resource_node *res_cur = NULL;
0958     u32 len_cur = 0, start_cur = 0, len_tmp = 0;
0959     int noranges = 0;
0960     u32 tmp_start;      /* this is to make sure start address is divisible by the length needed */
0961     u32 tmp_divide;
0962     u8 flag = 0;
0963
0964     if (!res)
0965         return -EINVAL;
0966
0967     if (bridge) {
0968         /* The rules for bridges are different, 4K divisible for IO, 1M for (pf)mem*/
0969         if (res->type == IO)
0970             tmp_divide = IOBRIDGE;
0971         else
0972             tmp_divide = MEMBRIDGE;
0973     } else
0974         tmp_divide = res->len;
0975
0976     bus_cur = find_bus_wprev(res->busno, NULL, 0);
0977
0978     if (!bus_cur) {
0979         /* didn't find a bus, something's wrong!!! */
0980         debug("no bus in the system, either pci_dev's wrong or allocation failed\n");
0981         return -EINVAL;
0982     }
0983
0984     debug("%s - enter\n", __func__);
0985     debug("bus_cur->busno is %d\n", bus_cur->busno);
0986
0987     /* This is a quick fix to not mess up with the code very much.  i.e.,
0988      * 2000-2fff, len = 1000, but when we compare, we need it to be fff */
0989     res->len -= 1;
0990
0991     switch (res->type) {
0992         case IO:
0993             res_cur = bus_cur->firstIO;
0994             noranges = bus_cur->noIORanges;
0995             break;
0996         case MEM:
0997             res_cur = bus_cur->firstMem;
0998             noranges = bus_cur->noMemRanges;
0999             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 }