drivers/pci/hotplug/ibmphp_pci.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 "ibmphp.h"
  21
  22
  23 static int configure_device(struct pci_func *);
  24 static int configure_bridge(struct pci_func **, u8);
  25 static struct res_needed *scan_behind_bridge(struct pci_func *, u8);
  26 static int add_new_bus(struct bus_node *, struct resource_node *, struct resource_node *, struct resource_node *, u8);
  27 static u8 find_sec_number(u8 primary_busno, u8 slotno);
  28
  29 /*
  30  * NOTE..... If BIOS doesn't provide default routing, we assign:
  31  * 9 for SCSI, 10 for LAN adapters, and 11 for everything else.
  32  * If adapter is bridged, then we assign 11 to it and devices behind it.
  33  * We also assign the same irq numbers for multi function devices.
  34  * These are PIC mode, so shouldn't matter n.e.ways (hopefully)
  35  */
  36 static void assign_alt_irq(struct pci_func *cur_func, u8 class_code)
  37 {
  38         int j;
  39         for (j = 0; j < 4; j++) {
  40                 if (cur_func->irq[j] == 0xff) {
  41                         switch (class_code) {
  42                                 case PCI_BASE_CLASS_STORAGE:
  43                                         cur_func->irq[j] = SCSI_IRQ;
  44                                         break;
  45                                 case PCI_BASE_CLASS_NETWORK:
  46                                         cur_func->irq[j] = LAN_IRQ;
  47                                         break;
  48                                 default:
  49                                         cur_func->irq[j] = OTHER_IRQ;
  50                                         break;
  51                         }
  52                 }
  53         }
  54 }
  55
  56 /*
  57  * Configures the device to be added (will allocate needed resources if it
  58  * can), the device can be a bridge or a regular pci device, can also be
  59  * multi-functional
  60  *
  61  * Input: function to be added
  62  *
  63  * TO DO:  The error case with Multifunction device or multi function bridge,
  64  * if there is an error, will need to go through all previous functions and
  65  * unconfigure....or can add some code into unconfigure_card....
  66  */
  67 int ibmphp_configure_card(struct pci_func *func, u8 slotno)
  68 {
  69         u16 vendor_id;
  70         u32 class;
  71         u8 class_code;
  72         u8 hdr_type, device, sec_number;
  73         u8 function;
  74         struct pci_func *newfunc;       /* for multi devices */
  75         struct pci_func *cur_func, *prev_func;
  76         int rc, i, j;
  77         int cleanup_count;
  78         u8 flag;
  79         u8 valid_device = 0x00; /* to see if we are able to read from card any device info at all */
  80
  81         debug("inside configure_card, func->busno = %x\n", func->busno);
  82
  83         device = func->device;
  84         cur_func = func;
  85
  86         /* We only get bus and device from IRQ routing table.  So at this point,
  87          * func->busno is correct, and func->device contains only device (at the 5
  88          * highest bits)
  89          */
  90
  91         /* For every function on the card */
  92         for (function = 0x00; function < 0x08; function++) {
  93                 unsigned int devfn = PCI_DEVFN(device, function);
  94                 ibmphp_pci_bus->number = cur_func->busno;
  95
  96                 cur_func->function = function;
  97
  98                 debug("inside the loop, cur_func->busno = %x, cur_func->device = %x, cur_func->function = %x\n",
  99                         cur_func->busno, cur_func->device, cur_func->function);
 100
 101                 pci_bus_read_config_word(ibmphp_pci_bus, devfn, PCI_VENDOR_ID, &vendor_id);
 102
 103                 debug("vendor_id is %x\n", vendor_id);
 104                 if (vendor_id != PCI_VENDOR_ID_NOTVALID) {
 105                         /* found correct device!!! */
 106                         debug("found valid device, vendor_id = %x\n", vendor_id);
 107
 108                         ++valid_device;
 109
 110                         /* header: x x x x x x x x
 111                          *         | |___________|=> 1=PPB bridge, 0=normal device, 2=CardBus Bridge
 112                          *         |_=> 0 = single function device, 1 = multi-function device
 113                          */
 114
 115                         pci_bus_read_config_byte(ibmphp_pci_bus, devfn, PCI_HEADER_TYPE, &hdr_type);
 116                         pci_bus_read_config_dword(ibmphp_pci_bus, devfn, PCI_CLASS_REVISION, &class);
 117
 118                         class_code = class >> 24;
 119                         debug("hrd_type = %x, class = %x, class_code %x\n", hdr_type, class, class_code);
 120                         class >>= 8;    /* to take revision out, class = class.subclass.prog i/f */
 121                         if (class == PCI_CLASS_NOT_DEFINED_VGA) {
 122                                 err("The device %x is VGA compatible and as is not supported for hot plugging. "
 123                                      "Please choose another device.\n", cur_func->device);
 124                                 return -ENODEV;
 125                         } else if (class == PCI_CLASS_DISPLAY_VGA) {
 126                                 err("The device %x is not supported for hot plugging. Please choose another device.\n",
 127                                      cur_func->device);
 128                                 return -ENODEV;
 129                         }
 130                         switch (hdr_type) {
 131                                 case PCI_HEADER_TYPE_NORMAL:
 132                                         debug("single device case.... vendor id = %x, hdr_type = %x, class = %x\n", vendor_id, hdr_type, class);
 133                                         assign_alt_irq(cur_func, class_code);
 134                                         rc = configure_device(cur_func);
 135                                         if (rc < 0) {
 136                                                 /* We need to do this in case some other BARs were properly inserted */
 137                                                 err("was not able to configure devfunc %x on bus %x.\n",
 138                                                      cur_func->device, cur_func->busno);
 139                                                 cleanup_count = 6;
 140                                                 goto error;
 141                                         }
 142                                         cur_func->next = NULL;
 143                                         function = 0x8;
 144                                         break;
 145                                 case PCI_HEADER_TYPE_MULTIDEVICE:
 146                                         assign_alt_irq(cur_func, class_code);
 147                                         rc = configure_device(cur_func);
 148                                         if (rc < 0) {
 149                                                 /* We need to do this in case some other BARs were properly inserted */
 150                                                 err("was not able to configure devfunc %x on bus %x...bailing out\n",
 151                                                      cur_func->device, cur_func->busno);
 152                                                 cleanup_count = 6;
 153                                                 goto error;
 154                                         }
 155                                         newfunc = kzalloc(sizeof(*newfunc), GFP_KERNEL);
 156                                         if (!newfunc)
 157                                                 return -ENOMEM;
 158
 159                                         newfunc->busno = cur_func->busno;
 160                                         newfunc->device = device;
 161                                         cur_func->next = newfunc;
 162                                         cur_func = newfunc;
 163                                         for (j = 0; j < 4; j++)
 164                                                 newfunc->irq[j] = cur_func->irq[j];
 165                                         break;
 166                                 case PCI_HEADER_TYPE_MULTIBRIDGE:
 167                                         class >>= 8;
 168                                         if (class != PCI_CLASS_BRIDGE_PCI) {
 169                                                 err("This %x is not PCI-to-PCI bridge, and as is not supported for hot-plugging.  Please insert another card.\n",
 170                                                      cur_func->device);
 171                                                 return -ENODEV;
 172                                         }
 173                                         assign_alt_irq(cur_func, class_code);
 174                                         rc = configure_bridge(&cur_func, slotno);
 175                                         if (rc == -ENODEV) {
 176                                                 err("You chose to insert Single Bridge, or nested bridges, this is not supported...\n");
 177                                                 err("Bus %x, devfunc %x\n", cur_func->busno, cur_func->device);
 178                                                 return rc;
 179                                         }
 180                                         if (rc) {
 181                                                 /* We need to do this in case some other BARs were properly inserted */
 182                                                 err("was not able to hot-add PPB properly.\n");
 183                                                 func->bus = 1; /* To indicate to the unconfigure function that this is a PPB */
 184                                                 cleanup_count = 2;
 185                                                 goto error;
 186                                         }
 187
 188                                         pci_bus_read_config_byte(ibmphp_pci_bus, devfn, PCI_SECONDARY_BUS, &sec_number);
 189                                         flag = 0;
 190                                         for (i = 0; i < 32; i++) {
 191                                                 if (func->devices[i]) {
 192                                                         newfunc = kzalloc(sizeof(*newfunc), GFP_KERNEL);
 193                                                         if (!newfunc)
 194                                                                 return -ENOMEM;
 195
 196                                                         newfunc->busno = sec_number;
 197                                                         newfunc->device = (u8) i;
 198                                                         for (j = 0; j < 4; j++)
 199                                                                 newfunc->irq[j] = cur_func->irq[j];
 200
 201                                                         if (flag) {
 202                                                                 for (prev_func = cur_func; prev_func->next; prev_func = prev_func->next) ;
 203                                                                 prev_func->next = newfunc;
 204                                                         } else
 205                                                                 cur_func->next = newfunc;
 206
 207                                                         rc = ibmphp_configure_card(newfunc, slotno);
 208                                                         /* This could only happen if kmalloc failed */
 209                                                         if (rc) {
 210                                                                 /* We need to do this in case bridge itself got configured properly, but devices behind it failed */
 211                                                                 func->bus = 1; /* To indicate to the unconfigure function that this is a PPB */
 212                                                                 cleanup_count = 2;
 213                                                                 goto error;
 214                                                         }
 215                                                         flag = 1;
 216                                                 }
 217                                         }
 218
 219                                         newfunc = kzalloc(sizeof(*newfunc), GFP_KERNEL);
 220                                         if (!newfunc)
 221                                                 return -ENOMEM;
 222
 223                                         newfunc->busno = cur_func->busno;
 224                                         newfunc->device = device;
 225                                         for (j = 0; j < 4; j++)
 226                                                 newfunc->irq[j] = cur_func->irq[j];
 227                                         for (prev_func = cur_func; prev_func->next; prev_func = prev_func->next);
 228                                         prev_func->next = newfunc;
 229                                         cur_func = newfunc;
 230                                         break;
 231                                 case PCI_HEADER_TYPE_BRIDGE:
 232                                         class >>= 8;
 233                                         debug("class now is %x\n", class);
 234                                         if (class != PCI_CLASS_BRIDGE_PCI) {
 235                                                 err("This %x is not PCI-to-PCI bridge, and as is not supported for hot-plugging.  Please insert another card.\n",
 236                                                      cur_func->device);
 237                                                 return -ENODEV;
 238                                         }
 239
 240                                         assign_alt_irq(cur_func, class_code);
 241
 242                                         debug("cur_func->busno b4 configure_bridge is %x\n", cur_func->busno);
 243                                         rc = configure_bridge(&cur_func, slotno);
 244                                         if (rc == -ENODEV) {
 245                                                 err("You chose to insert Single Bridge, or nested bridges, this is not supported...\n");
 246                                                 err("Bus %x, devfunc %x\n", cur_func->busno, cur_func->device);
 247                                                 return rc;
 248                                         }
 249                                         if (rc) {
 250                                                 /* We need to do this in case some other BARs were properly inserted */
 251                                                 func->bus = 1; /* To indicate to the unconfigure function that this is a PPB */
 252                                                 err("was not able to hot-add PPB properly.\n");
 253                                                 cleanup_count = 2;
 254                                                 goto error;
 255                                         }
 256                                         debug("cur_func->busno = %x, device = %x, function = %x\n",
 257                                                 cur_func->busno, device, function);
 258                                         pci_bus_read_config_byte(ibmphp_pci_bus, devfn, PCI_SECONDARY_BUS, &sec_number);
 259                                         debug("after configuring bridge..., sec_number = %x\n", sec_number);
 260                                         flag = 0;
 261                                         for (i = 0; i < 32; i++) {
 262                                                 if (func->devices[i]) {
 263                                                         debug("inside for loop, device is %x\n", i);
 264                                                         newfunc = kzalloc(sizeof(*newfunc), GFP_KERNEL);
 265                                                         if (!newfunc)
 266                                                                 return -ENOMEM;
 267
 268                                                         newfunc->busno = sec_number;
 269                                                         newfunc->device = (u8) i;
 270                                                         for (j = 0; j < 4; j++)
 271                                                                 newfunc->irq[j] = cur_func->irq[j];
 272
 273                                                         if (flag) {
 274                                                                 for (prev_func = cur_func; prev_func->next; prev_func = prev_func->next);
 275                                                                 prev_func->next = newfunc;
 276                                                         } else
 277                                                                 cur_func->next = newfunc;
 278
 279                                                         rc = ibmphp_configure_card(newfunc, slotno);
 280
 281                                                         /* Again, this case should not happen... For complete paranoia, will need to call remove_bus */
 282                                                         if (rc) {
 283                                                                 /* We need to do this in case some other BARs were properly inserted */
 284                                                                 func->bus = 1; /* To indicate to the unconfigure function that this is a PPB */
 285                                                                 cleanup_count = 2;
 286                                                                 goto error;
 287                                                         }
 288                                                         flag = 1;
 289                                                 }
 290                                         }
 291
 292                                         function = 0x8;
 293                                         break;
 294                                 default:
 295                                         err("MAJOR PROBLEM!!!!, header type not supported? %x\n", hdr_type);
 296                                         return -ENXIO;
 297                         }       /* end of switch */
 298                 }       /* end of valid device */
 299         }       /* end of for */
 300
 301         if (!valid_device) {
 302                 err("Cannot find any valid devices on the card.  Or unable to read from card.\n");
 303                 return -ENODEV;
 304         }
 305
 306         return 0;
 307
 308 error:
 309         for (i = 0; i < cleanup_count; i++) {
 310                 if (cur_func->io[i]) {
 311                         ibmphp_remove_resource(cur_func->io[i]);
 312                         cur_func->io[i] = NULL;
 313                 } else if (cur_func->pfmem[i]) {
 314                         ibmphp_remove_resource(cur_func->pfmem[i]);
 315                         cur_func->pfmem[i] = NULL;
 316                 } else if (cur_func->mem[i]) {
 317                         ibmphp_remove_resource(cur_func->mem[i]);
 318                         cur_func->mem[i] = NULL;
 319                 }
 320         }
 321         return rc;
 322 }
 323
 324 /*
 325  * This function configures the pci BARs of a single device.
 326  * Input: pointer to the pci_func
 327  * Output: configured PCI, 0, or error
 328  */
 329 static int configure_device(struct pci_func *func)
 330 {
 331         u32 bar[6];
 332         u32 address[] = {
 333                 PCI_BASE_ADDRESS_0,
 334                 PCI_BASE_ADDRESS_1,
 335                 PCI_BASE_ADDRESS_2,
 336                 PCI_BASE_ADDRESS_3,
 337                 PCI_BASE_ADDRESS_4,
 338                 PCI_BASE_ADDRESS_5,
 339                 0
 340         };
 341         u8 irq;
 342         int count;
 343         int len[6];
 344         struct resource_node *io[6];
 345         struct resource_node *mem[6];
 346         struct resource_node *mem_tmp;
 347         struct resource_node *pfmem[6];
 348         unsigned int devfn;
 349
 350         debug("%s - inside\n", __func__);
 351
 352         devfn = PCI_DEVFN(func->device, func->function);
 353         ibmphp_pci_bus->number = func->busno;
 354
 355         for (count = 0; address[count]; count++) {      /* for 6 BARs */
 356
 357                 /* not sure if i need this.  per scott, said maybe need * something like this
 358                    if devices don't adhere 100% to the spec, so don't want to write
 359                    to the reserved bits
 360
 361                 pcibios_read_config_byte(cur_func->busno, cur_func->device,
 362                 PCI_BASE_ADDRESS_0 + 4 * count, &tmp);
 363                 if (tmp & 0x01) // IO
 364                         pcibios_write_config_dword(cur_func->busno, cur_func->device,
 365                         PCI_BASE_ADDRESS_0 + 4 * count, 0xFFFFFFFD);
 366                 else  // Memory
 367                         pcibios_write_config_dword(cur_func->busno, cur_func->device,
 368                         PCI_BASE_ADDRESS_0 + 4 * count, 0xFFFFFFFF);
 369                  */
 370                 pci_bus_write_config_dword(ibmphp_pci_bus, devfn, address[count], 0xFFFFFFFF);
 371                 pci_bus_read_config_dword(ibmphp_pci_bus, devfn, address[count], &bar[count]);
 372
 373                 if (!bar[count])        /* This BAR is not implemented */
 374                         continue;
 375
 376                 debug("Device %x BAR %d wants %x\n", func->device, count, bar[count]);
 377
 378                 if (bar[count] & PCI_BASE_ADDRESS_SPACE_IO) {
 379                         /* This is IO */
 380                         debug("inside IO SPACE\n");
 381
 382                         len[count] = bar[count] & 0xFFFFFFFC;
 383                         len[count] = ~len[count] + 1;
 384
 385                         debug("len[count] in IO %x, count %d\n", len[count], count);
 386
 387                         io[count] = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
 388
 389                         if (!io[count])
 390                                 return -ENOMEM;
 391
 392                         io[count]->type = IO;
 393                         io[count]->busno = func->busno;
 394                         io[count]->devfunc = PCI_DEVFN(func->device, func->function);
 395                         io[count]->len = len[count];
 396                         if (ibmphp_check_resource(io[count], 0) == 0) {
 397                                 ibmphp_add_resource(io[count]);
 398                                 func->io[count] = io[count];
 399                         } else {
 400                                 err("cannot allocate requested io for bus %x device %x function %x len %x\n",
 401                                      func->busno, func->device, func->function, len[count]);
 402                                 kfree(io[count]);
 403                                 return -EIO;
 404                         }
 405                         pci_bus_write_config_dword(ibmphp_pci_bus, devfn, address[count], func->io[count]->start);
 406
 407                         /* _______________This is for debugging purposes only_____________________ */
 408                         debug("b4 writing, the IO address is %x\n", func->io[count]->start);
 409                         pci_bus_read_config_dword(ibmphp_pci_bus, devfn, address[count], &bar[count]);
 410                         debug("after writing.... the start address is %x\n", bar[count]);
 411                         /* _________________________________________________________________________*/
 412
 413                 } else {
 414                         /* This is Memory */
 415                         if (bar[count] & PCI_BASE_ADDRESS_MEM_PREFETCH) {
 416                                 /* pfmem */
 417                                 debug("PFMEM SPACE\n");
 418
 419                                 len[count] = bar[count] & 0xFFFFFFF0;
 420                                 len[count] = ~len[count] + 1;
 421
 422                                 debug("len[count] in PFMEM %x, count %d\n", len[count], count);
 423
 424                                 pfmem[count] = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
 425                                 if (!pfmem[count])
 426                                         return -ENOMEM;
 427
 428                                 pfmem[count]->type = PFMEM;
 429                                 pfmem[count]->busno = func->busno;
 430                                 pfmem[count]->devfunc = PCI_DEVFN(func->device,
 431                                                         func->function);
 432                                 pfmem[count]->len = len[count];
 433                                 pfmem[count]->fromMem = 0;
 434                                 if (ibmphp_check_resource(pfmem[count], 0) == 0) {
 435                                         ibmphp_add_resource(pfmem[count]);
 436                                         func->pfmem[count] = pfmem[count];
 437                                 } else {
 438                                         mem_tmp = kzalloc(sizeof(*mem_tmp), GFP_KERNEL);
 439                                         if (!mem_tmp) {
 440                                                 kfree(pfmem[count]);
 441                                                 return -ENOMEM;
 442                                         }
 443                                         mem_tmp->type = MEM;
 444                                         mem_tmp->busno = pfmem[count]->busno;
 445                                         mem_tmp->devfunc = pfmem[count]->devfunc;
 446                                         mem_tmp->len = pfmem[count]->len;
 447                                         debug("there's no pfmem... going into mem.\n");
 448                                         if (ibmphp_check_resource(mem_tmp, 0) == 0) {
 449                                                 ibmphp_add_resource(mem_tmp);
 450                                                 pfmem[count]->fromMem = 1;
 451                                                 pfmem[count]->rangeno = mem_tmp->rangeno;
 452                                                 pfmem[count]->start = mem_tmp->start;
 453                                                 pfmem[count]->end = mem_tmp->end;
 454                                                 ibmphp_add_pfmem_from_mem(pfmem[count]);
 455                                                 func->pfmem[count] = pfmem[count];
 456                                         } else {
 457                                                 err("cannot allocate requested pfmem for bus %x, device %x, len %x\n",
 458                                                      func->busno, func->device, len[count]);
 459                                                 kfree(mem_tmp);
 460                                                 kfree(pfmem[count]);
 461                                                 return -EIO;
 462                                         }
 463                                 }
 464
 465                                 pci_bus_write_config_dword(ibmphp_pci_bus, devfn, address[count], func->pfmem[count]->start);
 466
 467                                 /*_______________This is for debugging purposes only______________________________*/
 468                                 debug("b4 writing, start address is %x\n", func->pfmem[count]->start);
 469                                 pci_bus_read_config_dword(ibmphp_pci_bus, devfn, address[count], &bar[count]);
 470                                 debug("after writing, start address is %x\n", bar[count]);
 471                                 /*_________________________________________________________________________________*/
 472
 473                                 if (bar[count] & PCI_BASE_ADDRESS_MEM_TYPE_64) {        /* takes up another dword */
 474                                         debug("inside the mem 64 case, count %d\n", count);
 475                                         count += 1;
 476                                         /* on the 2nd dword, write all 0s, since we can't handle them n.e.ways */
 477                                         pci_bus_write_config_dword(ibmphp_pci_bus, devfn, address[count], 0x00000000);
 478                                 }
 479                         } else {
 480                                 /* regular memory */
 481                                 debug("REGULAR MEM SPACE\n");
 482
 483                                 len[count] = bar[count] & 0xFFFFFFF0;
 484                                 len[count] = ~len[count] + 1;
 485
 486                                 debug("len[count] in Mem %x, count %d\n", len[count], count);
 487
 488                                 mem[count] = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
 489                                 if (!mem[count])
 490                                         return -ENOMEM;
 491
 492                                 mem[count]->type = MEM;
 493                                 mem[count]->busno = func->busno;
 494                                 mem[count]->devfunc = PCI_DEVFN(func->device,
 495                                                         func->function);
 496                                 mem[count]->len = len[count];
 497                                 if (ibmphp_check_resource(mem[count], 0) == 0) {
 498                                         ibmphp_add_resource(mem[count]);
 499                                         func->mem[count] = mem[count];
 500                                 } else {
 501                                         err("cannot allocate requested mem for bus %x, device %x, len %x\n",
 502                                              func->busno, func->device, len[count]);
 503                                         kfree(mem[count]);
 504                                         return -EIO;
 505                                 }
 506                                 pci_bus_write_config_dword(ibmphp_pci_bus, devfn, address[count], func->mem[count]->start);
 507                                 /* _______________________This is for debugging purposes only _______________________*/
 508                                 debug("b4 writing, start address is %x\n", func->mem[count]->start);
 509                                 pci_bus_read_config_dword(ibmphp_pci_bus, devfn, address[count], &bar[count]);
 510                                 debug("after writing, the address is %x\n", bar[count]);
 511                                 /* __________________________________________________________________________________*/
 512
 513                                 if (bar[count] & PCI_BASE_ADDRESS_MEM_TYPE_64) {
 514                                         /* takes up another dword */
 515                                         debug("inside mem 64 case, reg. mem, count %d\n", count);
 516                                         count += 1;
 517                                         /* on the 2nd dword, write all 0s, since we can't handle them n.e.ways */
 518                                         pci_bus_write_config_dword(ibmphp_pci_bus, devfn, address[count], 0x00000000);
 519                                 }
 520                         }
 521                 }               /* end of mem */
 522         }                       /* end of for */
 523
 524         func->bus = 0;          /* To indicate that this is not a PPB */
 525         pci_bus_read_config_byte(ibmphp_pci_bus, devfn, PCI_INTERRUPT_PIN, &irq);
 526         if ((irq > 0x00) && (irq < 0x05))
 527                 pci_bus_write_config_byte(ibmphp_pci_bus, devfn, PCI_INTERRUPT_LINE, func->irq[irq - 1]);
 528
 529         pci_bus_write_config_byte(ibmphp_pci_bus, devfn, PCI_CACHE_LINE_SIZE, CACHE);
 530         pci_bus_write_config_byte(ibmphp_pci_bus, devfn, PCI_LATENCY_TIMER, LATENCY);
 531
 532         pci_bus_write_config_dword(ibmphp_pci_bus, devfn, PCI_ROM_ADDRESS, 0x00L);
 533         pci_bus_write_config_word(ibmphp_pci_bus, devfn, PCI_COMMAND, DEVICEENABLE);
 534
 535         return 0;
 536 }
 537
 538 /******************************************************************************
 539  * This routine configures a PCI-2-PCI bridge and the functions behind it
 540  * Parameters: pci_func
 541  * Returns:
 542  ******************************************************************************/
 543 static int configure_bridge(struct pci_func **func_passed, u8 slotno)
 544 {
 545         int count;
 546         int i;
 547         int rc;
 548         u8 sec_number;
 549         u8 io_base;
 550         u16 pfmem_base;
 551         u32 bar[2];
 552         u32 len[2];
 553         u8 flag_io = 0;
 554         u8 flag_mem = 0;
 555         u8 flag_pfmem = 0;
 556         u8 need_io_upper = 0;
 557         u8 need_pfmem_upper = 0;
 558         struct res_needed *amount_needed = NULL;
 559         struct resource_node *io = NULL;
 560         struct resource_node *bus_io[2] = {NULL, NULL};
 561         struct resource_node *mem = NULL;
 562         struct resource_node *bus_mem[2] = {NULL, NULL};
 563         struct resource_node *mem_tmp = NULL;
 564         struct resource_node *pfmem = NULL;
 565         struct resource_node *bus_pfmem[2] = {NULL, NULL};
 566         struct bus_node *bus;
 567         u32 address[] = {
 568                 PCI_BASE_ADDRESS_0,
 569                 PCI_BASE_ADDRESS_1,
 570                 0
 571         };
 572         struct pci_func *func = *func_passed;
 573         unsigned int devfn;
 574         u8 irq;
 575         int retval;
 576
 577         debug("%s - enter\n", __func__);
 578
 579         devfn = PCI_DEVFN(func->function, func->device);
 580         ibmphp_pci_bus->number = func->busno;
 581
 582         /* Configuring necessary info for the bridge so that we could see the devices
 583          * behind it
 584          */
 585
 586         pci_bus_write_config_byte(ibmphp_pci_bus, devfn, PCI_PRIMARY_BUS, func->busno);
 587
 588         /* _____________________For debugging purposes only __________________________
 589         pci_bus_config_byte(ibmphp_pci_bus, devfn, PCI_PRIMARY_BUS, &pri_number);
 590         debug("primary # written into the bridge is %x\n", pri_number);
 591          ___________________________________________________________________________*/
 592
 593         /* in EBDA, only get allocated 1 additional bus # per slot */
 594         sec_number = find_sec_number(func->busno, slotno);
 595         if (sec_number == 0xff) {
 596                 err("cannot allocate secondary bus number for the bridged device\n");
 597                 return -EINVAL;
 598         }
 599
 600         debug("after find_sec_number, the number we got is %x\n", sec_number);
 601         debug("AFTER FIND_SEC_NUMBER, func->busno IS %x\n", func->busno);
 602
 603         pci_bus_write_config_byte(ibmphp_pci_bus, devfn, PCI_SECONDARY_BUS, sec_number);
 604
 605         /* __________________For debugging purposes only __________________________________
 606         pci_bus_read_config_byte(ibmphp_pci_bus, devfn, PCI_SECONDARY_BUS, &sec_number);
 607         debug("sec_number after write/read is %x\n", sec_number);
 608          ________________________________________________________________________________*/
 609
 610         pci_bus_write_config_byte(ibmphp_pci_bus, devfn, PCI_SUBORDINATE_BUS, sec_number);
 611
 612         /* __________________For debugging purposes only ____________________________________
 613         pci_bus_read_config_byte(ibmphp_pci_bus, devfn, PCI_SUBORDINATE_BUS, &sec_number);
 614         debug("subordinate number after write/read is %x\n", sec_number);
 615          __________________________________________________________________________________*/
 616
 617         pci_bus_write_config_byte(ibmphp_pci_bus, devfn, PCI_CACHE_LINE_SIZE, CACHE);
 618         pci_bus_write_config_byte(ibmphp_pci_bus, devfn, PCI_LATENCY_TIMER, LATENCY);
 619         pci_bus_write_config_byte(ibmphp_pci_bus, devfn, PCI_SEC_LATENCY_TIMER, LATENCY);
 620
 621         debug("func->busno is %x\n", func->busno);
 622         debug("sec_number after writing is %x\n", sec_number);
 623
 624
 625         /* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 626            !!!!!!!!!!!!!!!NEED TO ADD!!!  FAST BACK-TO-BACK ENABLE!!!!!!!!!!!!!!!!!!!!
 627            !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
 628
 629
 630         /* First we need to allocate mem/io for the bridge itself in case it needs it */
 631         for (count = 0; address[count]; count++) {      /* for 2 BARs */
 632                 pci_bus_write_config_dword(ibmphp_pci_bus, devfn, address[count], 0xFFFFFFFF);
 633                 pci_bus_read_config_dword(ibmphp_pci_bus, devfn, address[count], &bar[count]);
 634
 635                 if (!bar[count]) {
 636                         /* This BAR is not implemented */
 637                         debug("so we come here then, eh?, count = %d\n", count);
 638                         continue;
 639                 }
 640                 //  tmp_bar = bar[count];
 641
 642                 debug("Bar %d wants %x\n", count, bar[count]);
 643
 644                 if (bar[count] & PCI_BASE_ADDRESS_SPACE_IO) {
 645                         /* This is IO */
 646                         len[count] = bar[count] & 0xFFFFFFFC;
 647                         len[count] = ~len[count] + 1;
 648
 649                         debug("len[count] in IO = %x\n", len[count]);
 650
 651                         bus_io[count] = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
 652
 653                         if (!bus_io[count]) {
 654                                 retval = -ENOMEM;
 655                                 goto error;
 656                         }
 657                         bus_io[count]->type = IO;
 658                         bus_io[count]->busno = func->busno;
 659                         bus_io[count]->devfunc = PCI_DEVFN(func->device,
 660                                                         func->function);
 661                         bus_io[count]->len = len[count];
 662                         if (ibmphp_check_resource(bus_io[count], 0) == 0) {
 663                                 ibmphp_add_resource(bus_io[count]);
 664                                 func->io[count] = bus_io[count];
 665                         } else {
 666                                 err("cannot allocate requested io for bus %x, device %x, len %x\n",
 667                                      func->busno, func->device, len[count]);
 668                                 kfree(bus_io[count]);
 669                                 return -EIO;
 670                         }
 671
 672                         pci_bus_write_config_dword(ibmphp_pci_bus, devfn, address[count], func->io[count]->start);
 673
 674                 } else {
 675                         /* This is Memory */
 676                         if (bar[count] & PCI_BASE_ADDRESS_MEM_PREFETCH) {
 677                                 /* pfmem */
 678                                 len[count] = bar[count] & 0xFFFFFFF0;
 679                                 len[count] = ~len[count] + 1;
 680
 681                                 debug("len[count] in PFMEM = %x\n", len[count]);
 682
 683                                 bus_pfmem[count] = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
 684                                 if (!bus_pfmem[count]) {
 685                                         retval = -ENOMEM;
 686                                         goto error;
 687                                 }
 688                                 bus_pfmem[count]->type = PFMEM;
 689                                 bus_pfmem[count]->busno = func->busno;
 690                                 bus_pfmem[count]->devfunc = PCI_DEVFN(func->device,
 691                                                         func->function);
 692                                 bus_pfmem[count]->len = len[count];
 693                                 bus_pfmem[count]->fromMem = 0;
 694                                 if (ibmphp_check_resource(bus_pfmem[count], 0) == 0) {
 695                                         ibmphp_add_resource(bus_pfmem[count]);
 696                                         func->pfmem[count] = bus_pfmem[count];
 697                                 } else {
 698                                         mem_tmp = kzalloc(sizeof(*mem_tmp), GFP_KERNEL);
 699                                         if (!mem_tmp) {
 700                                                 retval = -ENOMEM;
 701                                                 goto error;
 702                                         }
 703                                         mem_tmp->type = MEM;
 704                                         mem_tmp->busno = bus_pfmem[count]->busno;
 705                                         mem_tmp->devfunc = bus_pfmem[count]->devfunc;
 706                                         mem_tmp->len = bus_pfmem[count]->len;
 707                                         if (ibmphp_check_resource(mem_tmp, 0) == 0) {
 708                                                 ibmphp_add_resource(mem_tmp);
 709                                                 bus_pfmem[count]->fromMem = 1;
 710                                                 bus_pfmem[count]->rangeno = mem_tmp->rangeno;
 711                                                 ibmphp_add_pfmem_from_mem(bus_pfmem[count]);
 712                                                 func->pfmem[count] = bus_pfmem[count];
 713                                         } else {
 714                                                 err("cannot allocate requested pfmem for bus %x, device %x, len %x\n",
 715                                                      func->busno, func->device, len[count]);
 716                                                 kfree(mem_tmp);
 717                                                 kfree(bus_pfmem[count]);
 718                                                 return -EIO;
 719                                         }
 720                                 }
 721
 722                                 pci_bus_write_config_dword(ibmphp_pci_bus, devfn, address[count], func->pfmem[count]->start);
 723
 724                                 if (bar[count] & PCI_BASE_ADDRESS_MEM_TYPE_64) {
 725                                         /* takes up another dword */
 726                                         count += 1;
 727                                         /* on the 2nd dword, write all 0s, since we can't handle them n.e.ways */
 728                                         pci_bus_write_config_dword(ibmphp_pci_bus, devfn, address[count], 0x00000000);
 729
 730                                 }
 731                         } else {
 732                                 /* regular memory */
 733                                 len[count] = bar[count] & 0xFFFFFFF0;
 734                                 len[count] = ~len[count] + 1;
 735
 736                                 debug("len[count] in Memory is %x\n", len[count]);
 737
 738                                 bus_mem[count] = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
 739                                 if (!bus_mem[count]) {
 740                                         retval = -ENOMEM;
 741                                         goto error;
 742                                 }
 743                                 bus_mem[count]->type = MEM;
 744                                 bus_mem[count]->busno = func->busno;
 745                                 bus_mem[count]->devfunc = PCI_DEVFN(func->device,
 746                                                         func->function);
 747                                 bus_mem[count]->len = len[count];
 748                                 if (ibmphp_check_resource(bus_mem[count], 0) == 0) {
 749                                         ibmphp_add_resource(bus_mem[count]);
 750                                         func->mem[count] = bus_mem[count];
 751                                 } else {
 752                                         err("cannot allocate requested mem for bus %x, device %x, len %x\n",
 753                                              func->busno, func->device, len[count]);
 754                                         kfree(bus_mem[count]);
 755                                         return -EIO;
 756                                 }
 757
 758                                 pci_bus_write_config_dword(ibmphp_pci_bus, devfn, address[count], func->mem[count]->start);
 759
 760                                 if (bar[count] & PCI_BASE_ADDRESS_MEM_TYPE_64) {
 761                                         /* takes up another dword */
 762                                         count += 1;
 763                                         /* on the 2nd dword, write all 0s, since we can't handle them n.e.ways */
 764                                         pci_bus_write_config_dword(ibmphp_pci_bus, devfn, address[count], 0x00000000);
 765
 766                                 }
 767                         }
 768                 }               /* end of mem */
 769         }                       /* end of for  */
 770
 771         /* Now need to see how much space the devices behind the bridge needed */
 772         amount_needed = scan_behind_bridge(func, sec_number);
 773         if (amount_needed == NULL)
 774                 return -ENOMEM;
 775
 776         ibmphp_pci_bus->number = func->busno;
 777         debug("after coming back from scan_behind_bridge\n");
 778         debug("amount_needed->not_correct = %x\n", amount_needed->not_correct);
 779         debug("amount_needed->io = %x\n", amount_needed->io);
 780         debug("amount_needed->mem = %x\n", amount_needed->mem);
 781         debug("amount_needed->pfmem =  %x\n", amount_needed->pfmem);
 782
 783         if (amount_needed->not_correct) {
 784                 debug("amount_needed is not correct\n");
 785                 for (count = 0; address[count]; count++) {
 786                         /* for 2 BARs */
 787                         if (bus_io[count]) {
 788                                 ibmphp_remove_resource(bus_io[count]);
 789                                 func->io[count] = NULL;
 790                         } else if (bus_pfmem[count]) {
 791                                 ibmphp_remove_resource(bus_pfmem[count]);
 792                                 func->pfmem[count] = NULL;
 793                         } else if (bus_mem[count]) {
 794                                 ibmphp_remove_resource(bus_mem[count]);
 795                                 func->mem[count] = NULL;
 796                         }
 797                 }
 798                 kfree(amount_needed);
 799                 return -ENODEV;
 800         }
 801
 802         if (!amount_needed->io) {
 803                 debug("it doesn't want IO?\n");
 804                 flag_io = 1;
 805         } else {
 806                 debug("it wants %x IO behind the bridge\n", amount_needed->io);
 807                 io = kzalloc(sizeof(*io), GFP_KERNEL);
 808
 809                 if (!io) {
 810                         retval = -ENOMEM;
 811                         goto error;
 812                 }
 813                 io->type = IO;
 814                 io->busno = func->busno;
 815                 io->devfunc = PCI_DEVFN(func->device, func->function);
 816                 io->len = amount_needed->io;
 817                 if (ibmphp_check_resource(io, 1) == 0) {
 818                         debug("were we able to add io\n");
 819                         ibmphp_add_resource(io);
 820                         flag_io = 1;
 821                 }
 822         }
 823
 824         if (!amount_needed->mem) {
 825                 debug("it doesn't want n.e.memory?\n");
 826                 flag_mem = 1;
 827         } else {
 828                 debug("it wants %x memory behind the bridge\n", amount_needed->mem);
 829                 mem = kzalloc(sizeof(*mem), GFP_KERNEL);
 830                 if (!mem) {
 831                         retval = -ENOMEM;
 832                         goto error;
 833                 }
 834                 mem->type = MEM;
 835                 mem->busno = func->busno;
 836                 mem->devfunc = PCI_DEVFN(func->device, func->function);
 837                 mem->len = amount_needed->mem;
 838                 if (ibmphp_check_resource(mem, 1) == 0) {
 839                         ibmphp_add_resource(mem);
 840                         flag_mem = 1;
 841                         debug("were we able to add mem\n");
 842                 }
 843         }
 844
 845         if (!amount_needed->pfmem) {
 846                 debug("it doesn't want n.e.pfmem mem?\n");
 847                 flag_pfmem = 1;
 848         } else {
 849                 debug("it wants %x pfmemory behind the bridge\n", amount_needed->pfmem);
 850                 pfmem = kzalloc(sizeof(*pfmem), GFP_KERNEL);
 851                 if (!pfmem) {
 852                         retval = -ENOMEM;
 853                         goto error;
 854                 }
 855                 pfmem->type = PFMEM;
 856                 pfmem->busno = func->busno;
 857                 pfmem->devfunc = PCI_DEVFN(func->device, func->function);
 858                 pfmem->len = amount_needed->pfmem;
 859                 pfmem->fromMem = 0;
 860                 if (ibmphp_check_resource(pfmem, 1) == 0) {
 861                         ibmphp_add_resource(pfmem);
 862                         flag_pfmem = 1;
 863                 } else {
 864                         mem_tmp = kzalloc(sizeof(*mem_tmp), GFP_KERNEL);
 865                         if (!mem_tmp) {
 866                                 retval = -ENOMEM;
 867                                 goto error;
 868                         }
 869                         mem_tmp->type = MEM;
 870                         mem_tmp->busno = pfmem->busno;
 871                         mem_tmp->devfunc = pfmem->devfunc;
 872                         mem_tmp->len = pfmem->len;
 873                         if (ibmphp_check_resource(mem_tmp, 1) == 0) {
 874                                 ibmphp_add_resource(mem_tmp);
 875                                 pfmem->fromMem = 1;
 876                                 pfmem->rangeno = mem_tmp->rangeno;
 877                                 ibmphp_add_pfmem_from_mem(pfmem);
 878                                 flag_pfmem = 1;
 879                         }
 880                 }
 881         }
 882
 883         debug("b4 if (flag_io && flag_mem && flag_pfmem)\n");
 884         debug("flag_io = %x, flag_mem = %x, flag_pfmem = %x\n", flag_io, flag_mem, flag_pfmem);
 885
 886         if (flag_io && flag_mem && flag_pfmem) {
 887                 /* If on bootup, there was a bridged card in this slot,
 888                  * then card was removed and ibmphp got unloaded and loaded
 889                  * back again, there's no way for us to remove the bus
 890                  * struct, so no need to kmalloc, can use existing node
 891                  */
 892                 bus = ibmphp_find_res_bus(sec_number);
 893                 if (!bus) {
 894                         bus = kzalloc(sizeof(*bus), GFP_KERNEL);
 895                         if (!bus) {
 896                                 retval = -ENOMEM;
 897                                 goto error;
 898                         }
 899                         bus->busno = sec_number;
 900                         debug("b4 adding new bus\n");
 901                         rc = add_new_bus(bus, io, mem, pfmem, func->busno);
 902                 } else if (!(bus->rangeIO) && !(bus->rangeMem) && !(bus->rangePFMem))
 903                         rc = add_new_bus(bus, io, mem, pfmem, 0xFF);
 904                 else {
 905                         err("expected bus structure not empty?\n");
 906                         retval = -EIO;
 907                         goto error;
 908                 }
 909                 if (rc) {
 910                         if (rc == -ENOMEM) {
 911                                 ibmphp_remove_bus(bus, func->busno);
 912                                 kfree(amount_needed);
 913                                 return rc;
 914                         }
 915                         retval = rc;
 916                         goto error;
 917                 }
 918                 pci_bus_read_config_byte(ibmphp_pci_bus, devfn, PCI_IO_BASE, &io_base);
 919                 pci_bus_read_config_word(ibmphp_pci_bus, devfn, PCI_PREF_MEMORY_BASE, &pfmem_base);
 920
 921                 if ((io_base & PCI_IO_RANGE_TYPE_MASK) == PCI_IO_RANGE_TYPE_32) {
 922                         debug("io 32\n");
 923                         need_io_upper = 1;
 924                 }
 925                 if ((pfmem_base & PCI_PREF_RANGE_TYPE_MASK) == PCI_PREF_RANGE_TYPE_64) {
 926                         debug("pfmem 64\n");
 927                         need_pfmem_upper = 1;
 928                 }
 929
 930                 if (bus->noIORanges) {
 931                         pci_bus_write_config_byte(ibmphp_pci_bus, devfn, PCI_IO_BASE, 0x00 | bus->rangeIO->start >> 8);
 932                         pci_bus_write_config_byte(ibmphp_pci_bus, devfn, PCI_IO_LIMIT, 0x00 | bus->rangeIO->end >> 8);
 933
 934                         /* _______________This is for debugging purposes only ____________________
 935                         pci_bus_read_config_byte(ibmphp_pci_bus, devfn, PCI_IO_BASE, &temp);
 936                         debug("io_base = %x\n", (temp & PCI_IO_RANGE_TYPE_MASK) << 8);
 937                         pci_bus_read_config_byte(ibmphp_pci_bus, devfn, PCI_IO_LIMIT, &temp);
 938                         debug("io_limit = %x\n", (temp & PCI_IO_RANGE_TYPE_MASK) << 8);
 939                          ________________________________________________________________________*/
 940
 941                         if (need_io_upper) {    /* since can't support n.e.ways */
 942                                 pci_bus_write_config_word(ibmphp_pci_bus, devfn, PCI_IO_BASE_UPPER16, 0x0000);
 943                                 pci_bus_write_config_word(ibmphp_pci_bus, devfn, PCI_IO_LIMIT_UPPER16, 0x0000);
 944                         }
 945                 } else {
 946                         pci_bus_write_config_byte(ibmphp_pci_bus, devfn, PCI_IO_BASE, 0x00);
 947                         pci_bus_write_config_byte(ibmphp_pci_bus, devfn, PCI_IO_LIMIT, 0x00);
 948                 }
 949
 950                 if (bus->noMemRanges) {
 951                         pci_bus_write_config_word(ibmphp_pci_bus, devfn, PCI_MEMORY_BASE, 0x0000 | bus->rangeMem->start >> 16);
 952                         pci_bus_write_config_word(ibmphp_pci_bus, devfn, PCI_MEMORY_LIMIT, 0x0000 | bus->rangeMem->end >> 16);
 953
 954                         /* ____________________This is for debugging purposes only ________________________
 955                         pci_bus_read_config_word(ibmphp_pci_bus, devfn, PCI_MEMORY_BASE, &temp);
 956                         debug("mem_base = %x\n", (temp & PCI_MEMORY_RANGE_TYPE_MASK) << 16);
 957                         pci_bus_read_config_word(ibmphp_pci_bus, devfn, PCI_MEMORY_LIMIT, &temp);
 958                         debug("mem_limit = %x\n", (temp & PCI_MEMORY_RANGE_TYPE_MASK) << 16);
 959                          __________________________________________________________________________________*/
 960
 961                 } else {
 962                         pci_bus_write_config_word(ibmphp_pci_bus, devfn, PCI_MEMORY_BASE, 0xffff);
 963                         pci_bus_write_config_word(ibmphp_pci_bus, devfn, PCI_MEMORY_LIMIT, 0x0000);
 964                 }
 965                 if (bus->noPFMemRanges) {
 966                         pci_bus_write_config_word(ibmphp_pci_bus, devfn, PCI_PREF_MEMORY_BASE, 0x0000 | bus->rangePFMem->start >> 16);
 967                         pci_bus_write_config_word(ibmphp_pci_bus, devfn, PCI_PREF_MEMORY_LIMIT, 0x0000 | bus->rangePFMem->end >> 16);
 968
 969                         /* __________________________This is for debugging purposes only _______________________
 970                         pci_bus_read_config_word(ibmphp_pci_bus, devfn, PCI_PREF_MEMORY_BASE, &temp);
 971                         debug("pfmem_base = %x", (temp & PCI_MEMORY_RANGE_TYPE_MASK) << 16);
 972                         pci_bus_read_config_word(ibmphp_pci_bus, devfn, PCI_PREF_MEMORY_LIMIT, &temp);
 973                         debug("pfmem_limit = %x\n", (temp & PCI_MEMORY_RANGE_TYPE_MASK) << 16);
 974                          ______________________________________________________________________________________*/
 975
 976                         if (need_pfmem_upper) { /* since can't support n.e.ways */
 977                                 pci_bus_write_config_dword(ibmphp_pci_bus, devfn, PCI_PREF_BASE_UPPER32, 0x00000000);
 978                                 pci_bus_write_config_dword(ibmphp_pci_bus, devfn, PCI_PREF_LIMIT_UPPER32, 0x00000000);
 979                         }
 980                 } else {
 981                         pci_bus_write_config_word(ibmphp_pci_bus, devfn, PCI_PREF_MEMORY_BASE, 0xffff);
 982                         pci_bus_write_config_word(ibmphp_pci_bus, devfn, PCI_PREF_MEMORY_LIMIT, 0x0000);
 983                 }
 984
 985                 debug("b4 writing control information\n");
 986
 987                 pci_bus_read_config_byte(ibmphp_pci_bus, devfn, PCI_INTERRUPT_PIN, &irq);
 988                 if ((irq > 0x00) && (irq < 0x05))
 989                         pci_bus_write_config_byte(ibmphp_pci_bus, devfn, PCI_INTERRUPT_LINE, func->irq[irq - 1]);
 990                 /*
 991                 pci_bus_write_config_byte(ibmphp_pci_bus, devfn, PCI_BRIDGE_CONTROL, ctrl);
 992                 pci_bus_write_config_byte(ibmphp_pci_bus, devfn, PCI_BRIDGE_CONTROL, PCI_BRIDGE_CTL_PARITY);
 993                 pci_bus_write_config_byte(ibmphp_pci_bus, devfn, PCI_BRIDGE_CONTROL, PCI_BRIDGE_CTL_SERR);
 994                  */
 995
 996                 pci_bus_write_config_word(ibmphp_pci_bus, devfn, PCI_COMMAND, DEVICEENABLE);
 997                 pci_bus_write_config_word(ibmphp_pci_bus, devfn, PCI_BRIDGE_CONTROL, 0x07);
 998                 for (i = 0; i < 32; i++) {
 999                         if (amount_needed->devices[i]) {
1000                                 debug("device where devices[i] is 1 = %x\n", i);
1001                                 func->devices[i] = 1;
1002                         }
1003                 }
1004                 func->bus = 1;  /* For unconfiguring, to indicate it's PPB */
1005                 func_passed = &func;
1006                 debug("func->busno b4 returning is %x\n", func->busno);
1007                 debug("func->busno b4 returning in the other structure is %x\n", (*func_passed)->busno);
1008                 kfree(amount_needed);
1009                 return 0;
1010         } else {
1011                 err("Configuring bridge was unsuccessful...\n");
1012                 mem_tmp = NULL;
1013                 retval = -EIO;
1014                 goto error;
1015         }
1016
1017 error:
1018         kfree(amount_needed);
1019         if (pfmem)
1020                 ibmphp_remove_resource(pfmem);
1021         if (io)
1022                 ibmphp_remove_resource(io);
1023         if (mem)
1024                 ibmphp_remove_resource(mem);
1025         for (i = 0; i < 2; i++) {       /* for 2 BARs */
1026                 if (bus_io[i]) {
1027                         ibmphp_remove_resource(bus_io[i]);
1028                         func->io[i] = NULL;
1029                 } else if (bus_pfmem[i]) {
1030                         ibmphp_remove_resource(bus_pfmem[i]);
1031                         func->pfmem[i] = NULL;
1032                 } else if (bus_mem[i]) {
1033                         ibmphp_remove_resource(bus_mem[i]);
1034                         func->mem[i] = NULL;
1035                 }
1036         }
1037         return retval;
1038 }
1039
1040 /*****************************************************************************
1041  * This function adds up the amount of resources needed behind the PPB bridge
1042  * and passes it to the configure_bridge function
1043  * Input: bridge function
1044  * Output: amount of resources needed
1045  *****************************************************************************/
1046 static struct res_needed *scan_behind_bridge(struct pci_func *func, u8 busno)
1047 {
1048         int count, len[6];
1049         u16 vendor_id;
1050         u8 hdr_type;
1051         u8 device, function;
1052         unsigned int devfn;
1053         int howmany = 0;        /*this is to see if there are any devices behind the bridge */
1054
1055         u32 bar[6], class;
1056         u32 address[] = {
1057                 PCI_BASE_ADDRESS_0,
1058                 PCI_BASE_ADDRESS_1,
1059                 PCI_BASE_ADDRESS_2,
1060                 PCI_BASE_ADDRESS_3,
1061                 PCI_BASE_ADDRESS_4,
1062                 PCI_BASE_ADDRESS_5,
1063                 0
1064         };
1065         struct res_needed *amount;
1066
1067         amount = kzalloc(sizeof(*amount), GFP_KERNEL);
1068         if (amount == NULL)
1069                 return NULL;
1070
1071         ibmphp_pci_bus->number = busno;
1072
1073         debug("the bus_no behind the bridge is %x\n", busno);
1074         debug("scanning devices behind the bridge...\n");
1075         for (device = 0; device < 32; device++) {
1076                 amount->devices[device] = 0;
1077                 for (function = 0; function < 8; function++) {
1078                         devfn = PCI_DEVFN(device, function);
1079
1080                         pci_bus_read_config_word(ibmphp_pci_bus, devfn, PCI_VENDOR_ID, &vendor_id);
1081
1082                         if (vendor_id != PCI_VENDOR_ID_NOTVALID) {
1083                                 /* found correct device!!! */
1084                                 howmany++;
1085
1086                                 pci_bus_read_config_byte(ibmphp_pci_bus, devfn, PCI_HEADER_TYPE, &hdr_type);
1087                                 pci_bus_read_config_dword(ibmphp_pci_bus, devfn, PCI_CLASS_REVISION, &class);
1088
1089                                 debug("hdr_type behind the bridge is %x\n", hdr_type);
1090                                 if ((hdr_type & 0x7f) == PCI_HEADER_TYPE_BRIDGE) {
1091                                         err("embedded bridges not supported for hot-plugging.\n");
1092                                         amount->not_correct = 1;
1093                                         return amount;
1094                                 }
1095
1096                                 class >>= 8;    /* to take revision out, class = class.subclass.prog i/f */
1097                                 if (class == PCI_CLASS_NOT_DEFINED_VGA) {
1098                                         err("The device %x is VGA compatible and as is not supported for hot plugging.  Please choose another device.\n", device);
1099                                         amount->not_correct = 1;
1100                                         return amount;
1101                                 } else if (class == PCI_CLASS_DISPLAY_VGA) {
1102                                         err("The device %x is not supported for hot plugging.  Please choose another device.\n", device);
1103                                         amount->not_correct = 1;
1104                                         return amount;
1105                                 }
1106
1107                                 amount->devices[device] = 1;
1108
1109                                 for (count = 0; address[count]; count++) {
1110                                         /* for 6 BARs */
1111                                         /*
1112                                         pci_bus_read_config_byte(ibmphp_pci_bus, devfn, address[count], &tmp);
1113                                         if (tmp & 0x01) // IO
1114                                                 pci_bus_write_config_dword(ibmphp_pci_bus, devfn, address[count], 0xFFFFFFFD);
1115                                         else // MEMORY
1116                                                 pci_bus_write_config_dword(ibmphp_pci_bus, devfn, address[count], 0xFFFFFFFF);
1117                                         */
1118                                         pci_bus_write_config_dword(ibmphp_pci_bus, devfn, address[count], 0xFFFFFFFF);
1119                                         pci_bus_read_config_dword(ibmphp_pci_bus, devfn, address[count], &bar[count]);
1120
1121                                         debug("what is bar[count]? %x, count = %d\n", bar[count], count);
1122
1123                                         if (!bar[count])        /* This BAR is not implemented */
1124                                                 continue;
1125
1126                                         //tmp_bar = bar[count];
1127
1128                                         debug("count %d device %x function %x wants %x resources\n", count, device, function, bar[count]);
1129
1130                                         if (bar[count] & PCI_BASE_ADDRESS_SPACE_IO) {
1131                                                 /* This is IO */
1132                                                 len[count] = bar[count] & 0xFFFFFFFC;
1133                                                 len[count] = ~len[count] + 1;
1134                                                 amount->io += len[count];
1135                                         } else {
1136                                                 /* This is Memory */
1137                                                 if (bar[count] & PCI_BASE_ADDRESS_MEM_PREFETCH) {
1138                                                         /* pfmem */
1139                                                         len[count] = bar[count] & 0xFFFFFFF0;
1140                                                         len[count] = ~len[count] + 1;
1141                                                         amount->pfmem += len[count];
1142                                                         if (bar[count] & PCI_BASE_ADDRESS_MEM_TYPE_64)
1143                                                                 /* takes up another dword */
1144                                                                 count += 1;
1145
1146                                                 } else {
1147                                                         /* regular memory */
1148                                                         len[count] = bar[count] & 0xFFFFFFF0;
1149                                                         len[count] = ~len[count] + 1;
1150                                                         amount->mem += len[count];
1151                                                         if (bar[count] & PCI_BASE_ADDRESS_MEM_TYPE_64) {
1152                                                                 /* takes up another dword */
1153                                                                 count += 1;
1154                                                         }
1155                                                 }
1156                                         }
1157                                 }       /* end for */
1158                         }       /* end if (valid) */
1159                 }       /* end for */
1160         }       /* end for */
1161
1162         if (!howmany)
1163                 amount->not_correct = 1;
1164         else
1165                 amount->not_correct = 0;
1166         if ((amount->io) && (amount->io < IOBRIDGE))
1167                 amount->io = IOBRIDGE;
1168         if ((amount->mem) && (amount->mem < MEMBRIDGE))
1169                 amount->mem = MEMBRIDGE;
1170         if ((amount->pfmem) && (amount->pfmem < MEMBRIDGE))
1171                 amount->pfmem = MEMBRIDGE;
1172         return amount;
1173 }
1174
1175 /* The following 3 unconfigure_boot_ routines deal with the case when we had the card
1176  * upon bootup in the system, since we don't allocate func to such case, we need to read
1177  * the start addresses from pci config space and then find the corresponding entries in
1178  * our resource lists.  The functions return either 0, -ENODEV, or -1 (general failure)
1179  * Change: we also call these functions even if we configured the card ourselves (i.e., not
1180  * the bootup case), since it should work same way
1181  */
1182 static int unconfigure_boot_device(u8 busno, u8 device, u8 function)
1183 {
1184         u32 start_address;
1185         u32 address[] = {
1186                 PCI_BASE_ADDRESS_0,
1187                 PCI_BASE_ADDRESS_1,
1188                 PCI_BASE_ADDRESS_2,
1189                 PCI_BASE_ADDRESS_3,
1190                 PCI_BASE_ADDRESS_4,
1191                 PCI_BASE_ADDRESS_5,
1192                 0
1193         };
1194         int count;
1195         struct resource_node *io;
1196         struct resource_node *mem;
1197         struct resource_node *pfmem;
1198         struct bus_node *bus;
1199         u32 end_address;
1200         u32 temp_end;
1201         u32 size;
1202         u32 tmp_address;
1203         unsigned int devfn;
1204
1205         debug("%s - enter\n", __func__);
1206
1207         bus = ibmphp_find_res_bus(busno);
1208         if (!bus) {
1209                 debug("cannot find corresponding bus.\n");
1210                 return -EINVAL;
1211         }
1212
1213         devfn = PCI_DEVFN(device, function);
1214         ibmphp_pci_bus->number = busno;
1215         for (count = 0; address[count]; count++) {      /* for 6 BARs */
1216                 pci_bus_read_config_dword(ibmphp_pci_bus, devfn, address[count], &start_address);
1217
1218                 /* We can do this here, b/c by that time the device driver of the card has been stopped */
1219
1220                 pci_bus_write_config_dword(ibmphp_pci_bus, devfn, address[count], 0xFFFFFFFF);
1221                 pci_bus_read_config_dword(ibmphp_pci_bus, devfn, address[count], &size);
1222                 pci_bus_write_config_dword(ibmphp_pci_bus, devfn, address[count], start_address);
1223
1224                 debug("start_address is %x\n", start_address);
1225                 debug("busno, device, function %x %x %x\n", busno, device, function);
1226                 if (!size) {
1227                         /* This BAR is not implemented */
1228                         debug("is this bar no implemented?, count = %d\n", count);
1229                         continue;
1230                 }
1231                 tmp_address = start_address;
1232                 if (start_address & PCI_BASE_ADDRESS_SPACE_IO) {
1233                         /* This is IO */
1234                         start_address &= PCI_BASE_ADDRESS_IO_MASK;
1235                         size = size & 0xFFFFFFFC;
1236                         size = ~size + 1;
1237                         end_address = start_address + size - 1;
1238                         if (ibmphp_find_resource(bus, start_address, &io, IO))
1239                                 goto report_search_failure;
1240
1241                         debug("io->start = %x\n", io->start);
1242                         temp_end = io->end;
1243                         start_address = io->end + 1;
1244                         ibmphp_remove_resource(io);
1245                         /* This is needed b/c of the old I/O restrictions in the BIOS */
1246                         while (temp_end < end_address) {
1247                                 if (ibmphp_find_resource(bus, start_address,
1248                                                          &io, IO))
1249                                         goto report_search_failure;
1250
1251                                 debug("io->start = %x\n", io->start);
1252                                 temp_end = io->end;
1253                                 start_address = io->end + 1;
1254                                 ibmphp_remove_resource(io);
1255                         }
1256
1257                         /* ????????? DO WE NEED TO WRITE ANYTHING INTO THE PCI CONFIG SPACE BACK ?????????? */
1258                 } else {
1259                         /* This is Memory */
1260                         if (start_address & PCI_BASE_ADDRESS_MEM_PREFETCH) {
1261                                 /* pfmem */
1262                                 debug("start address of pfmem is %x\n", start_address);
1263                                 start_address &= PCI_BASE_ADDRESS_MEM_MASK;
1264
1265                                 if (ibmphp_find_resource(bus, start_address, &pfmem, PFMEM) < 0) {
1266                                         err("cannot find corresponding PFMEM resource to remove\n");
1267                                         return -EIO;
1268                                 }
1269                                 if (pfmem) {
1270                                         debug("pfmem->start = %x\n", pfmem->start);
1271
1272                                         ibmphp_remove_resource(pfmem);
1273                                 }
1274                         } else {
1275                                 /* regular memory */
1276                                 debug("start address of mem is %x\n", start_address);
1277                                 start_address &= PCI_BASE_ADDRESS_MEM_MASK;
1278
1279                                 if (ibmphp_find_resource(bus, start_address, &mem, MEM) < 0) {
1280                                         err("cannot find corresponding MEM resource to remove\n");
1281                                         return -EIO;
1282                                 }
1283                                 if (mem) {
1284                                         debug("mem->start = %x\n", mem->start);
1285
1286                                         ibmphp_remove_resource(mem);
1287                                 }
1288                         }
1289                         if (tmp_address & PCI_BASE_ADDRESS_MEM_TYPE_64) {
1290                                 /* takes up another dword */
1291                                 count += 1;
1292                         }
1293                 }       /* end of mem */
1294         }       /* end of for */
1295
1296         return 0;
1297
1298 report_search_failure:
1299         err("cannot find corresponding IO resource to remove\n");
1300         return -EIO;
1301 }
1302
1303 static int unconfigure_boot_bridge(u8 busno, u8 device, u8 function)
1304 {
1305         int count;
1306         int bus_no, pri_no, sub_no, sec_no = 0;
1307         u32 start_address, tmp_address;
1308         u8 sec_number, sub_number, pri_number;
1309         struct resource_node *io = NULL;
1310         struct resource_node *mem = NULL;
1311         struct resource_node *pfmem = NULL;
1312         struct bus_node *bus;
1313         u32 address[] = {
1314                 PCI_BASE_ADDRESS_0,
1315                 PCI_BASE_ADDRESS_1,
1316                 0
1317         };
1318         unsigned int devfn;
1319
1320         devfn = PCI_DEVFN(device, function);
1321         ibmphp_pci_bus->number = busno;
1322         bus_no = (int) busno;
1323         debug("busno is %x\n", busno);
1324         pci_bus_read_config_byte(ibmphp_pci_bus, devfn, PCI_PRIMARY_BUS, &pri_number);
1325         debug("%s - busno = %x, primary_number = %x\n", __func__, busno, pri_number);
1326
1327         pci_bus_read_config_byte(ibmphp_pci_bus, devfn, PCI_SECONDARY_BUS, &sec_number);
1328         debug("sec_number is %x\n", sec_number);
1329         sec_no = (int) sec_number;
1330         pri_no = (int) pri_number;
1331         if (pri_no != bus_no) {
1332                 err("primary numbers in our structures and pci config space don't match.\n");
1333                 return -EINVAL;
1334         }
1335
1336         pci_bus_read_config_byte(ibmphp_pci_bus, devfn, PCI_SUBORDINATE_BUS, &sub_number);
1337         sub_no = (int) sub_number;
1338         debug("sub_no is %d, sec_no is %d\n", sub_no, sec_no);
1339         if (sec_no != sub_number) {
1340                 err("there're more buses behind this bridge.  Hot removal is not supported.  Please choose another card\n");
1341                 return -ENODEV;
1342         }
1343
1344         bus = ibmphp_find_res_bus(sec_number);
1345         if (!bus) {
1346                 err("cannot find Bus structure for the bridged device\n");
1347                 return -EINVAL;
1348         }
1349         debug("bus->busno is %x\n", bus->busno);
1350         debug("sec_number is %x\n", sec_number);
1351
1352         ibmphp_remove_bus(bus, busno);
1353
1354         for (count = 0; address[count]; count++) {
1355                 /* for 2 BARs */
1356                 pci_bus_read_config_dword(ibmphp_pci_bus, devfn, address[count], &start_address);
1357
1358                 if (!start_address) {
1359                         /* This BAR is not implemented */
1360                         continue;
1361                 }
1362
1363                 tmp_address = start_address;
1364
1365                 if (start_address & PCI_BASE_ADDRESS_SPACE_IO) {
1366                         /* This is IO */
1367                         start_address &= PCI_BASE_ADDRESS_IO_MASK;
1368                         if (ibmphp_find_resource(bus, start_address, &io, IO) < 0) {
1369                                 err("cannot find corresponding IO resource to remove\n");
1370                                 return -EIO;
1371                         }
1372                         if (io)
1373                                 debug("io->start = %x\n", io->start);
1374
1375                         ibmphp_remove_resource(io);
1376
1377                         /* ????????? DO WE NEED TO WRITE ANYTHING INTO THE PCI CONFIG SPACE BACK ?????????? */
1378                 } else {
1379                         /* This is Memory */
1380                         if (start_address & PCI_BASE_ADDRESS_MEM_PREFETCH) {
1381                                 /* pfmem */
1382                                 start_address &= PCI_BASE_ADDRESS_MEM_MASK;
1383                                 if (ibmphp_find_resource(bus, start_address, &pfmem, PFMEM) < 0) {
1384                                         err("cannot find corresponding PFMEM resource to remove\n");
1385                                         return -EINVAL;
1386                                 }
1387                                 if (pfmem) {
1388                                         debug("pfmem->start = %x\n", pfmem->start);
1389
1390                                         ibmphp_remove_resource(pfmem);
1391                                 }
1392                         } else {
1393                                 /* regular memory */
1394                                 start_address &= PCI_BASE_ADDRESS_MEM_MASK;
1395                                 if (ibmphp_find_resource(bus, start_address, &mem, MEM) < 0) {
1396                                         err("cannot find corresponding MEM resource to remove\n");
1397                                         return -EINVAL;
1398                                 }
1399                                 if (mem) {
1400                                         debug("mem->start = %x\n", mem->start);
1401
1402                                         ibmphp_remove_resource(mem);
1403                                 }
1404                         }
1405                         if (tmp_address & PCI_BASE_ADDRESS_MEM_TYPE_64) {
1406                                 /* takes up another dword */
1407                                 count += 1;
1408                         }
1409                 }       /* end of mem */
1410         }       /* end of for */
1411         debug("%s - exiting, returning success\n", __func__);
1412         return 0;
1413 }
1414
1415 static int unconfigure_boot_card(struct slot *slot_cur)
1416 {
1417         u16 vendor_id;
1418         u32 class;
1419         u8 hdr_type;
1420         u8 device;
1421         u8 busno;
1422         u8 function;
1423         int rc;
1424         unsigned int devfn;
1425         u8 valid_device = 0x00; /* To see if we are ever able to find valid device and read it */
1426
1427         debug("%s - enter\n", __func__);
1428
1429         device = slot_cur->device;
1430         busno = slot_cur->bus;
1431
1432         debug("b4 for loop, device is %x\n", device);
1433         /* For every function on the card */
1434         for (function = 0x0; function < 0x08; function++) {
1435                 devfn = PCI_DEVFN(device, function);
1436                 ibmphp_pci_bus->number = busno;
1437
1438                 pci_bus_read_config_word(ibmphp_pci_bus, devfn, PCI_VENDOR_ID, &vendor_id);
1439
1440                 if (vendor_id != PCI_VENDOR_ID_NOTVALID) {
1441                         /* found correct device!!! */
1442                         ++valid_device;
1443
1444                         debug("%s - found correct device\n", __func__);
1445
1446                         /* header: x x x x x x x x
1447                          *         | |___________|=> 1=PPB bridge, 0=normal device, 2=CardBus Bridge
1448                          *         |_=> 0 = single function device, 1 = multi-function device
1449                          */
1450
1451                         pci_bus_read_config_byte(ibmphp_pci_bus, devfn, PCI_HEADER_TYPE, &hdr_type);
1452                         pci_bus_read_config_dword(ibmphp_pci_bus, devfn, PCI_CLASS_REVISION, &class);
1453
1454                         debug("hdr_type %x, class %x\n", hdr_type, class);
1455                         class >>= 8;    /* to take revision out, class = class.subclass.prog i/f */
1456                         if (class == PCI_CLASS_NOT_DEFINED_VGA) {
1457                                 err("The device %x function %x is VGA compatible and is not supported for hot removing.  Please choose another device.\n", device, function);
1458                                 return -ENODEV;
1459                         } else if (class == PCI_CLASS_DISPLAY_VGA) {
1460                                 err("The device %x function %x is not supported for hot removing.  Please choose another device.\n", device, function);
1461                                 return -ENODEV;
1462                         }
1463
1464                         switch (hdr_type) {
1465                                 case PCI_HEADER_TYPE_NORMAL:
1466                                         rc = unconfigure_boot_device(busno, device, function);
1467                                         if (rc) {
1468                                                 err("was not able to unconfigure device %x func %x on bus %x. bailing out...\n",
1469                                                      device, function, busno);
1470                                                 return rc;
1471                                         }
1472                                         function = 0x8;
1473                                         break;
1474                                 case PCI_HEADER_TYPE_MULTIDEVICE:
1475                                         rc = unconfigure_boot_device(busno, device, function);
1476                                         if (rc) {
1477                                                 err("was not able to unconfigure device %x func %x on bus %x. bailing out...\n",
1478                                                      device, function, busno);
1479                                                 return rc;
1480                                         }
1481                                         break;
1482                                 case PCI_HEADER_TYPE_BRIDGE:
1483                                         class >>= 8;
1484                                         if (class != PCI_CLASS_BRIDGE_PCI) {
1485                                                 err("This device %x function %x is not PCI-to-PCI bridge, and is not supported for hot-removing.  Please try another card.\n", device, function);
1486                                                 return -ENODEV;
1487                                         }
1488                                         rc = unconfigure_boot_bridge(busno, device, function);
1489                                         if (rc != 0) {
1490                                                 err("was not able to hot-remove PPB properly.\n");
1491                                                 return rc;
1492                                         }
1493
1494                                         function = 0x8;
1495                                         break;
1496                                 case PCI_HEADER_TYPE_MULTIBRIDGE:
1497                                         class >>= 8;
1498                                         if (class != PCI_CLASS_BRIDGE_PCI) {
1499                                                 err("This device %x function %x is not PCI-to-PCI bridge,  and is not supported for hot-removing.  Please try another card.\n", device, function);
1500                                                 return -ENODEV;
1501                                         }
1502                                         rc = unconfigure_boot_bridge(busno, device, function);
1503                                         if (rc != 0) {
1504                                                 err("was not able to hot-remove PPB properly.\n");
1505                                                 return rc;
1506                                         }
1507                                         break;
1508                                 default:
1509                                         err("MAJOR PROBLEM!!!! Cannot read device's header\n");
1510                                         return -1;
1511                         }       /* end of switch */
1512                 }       /* end of valid device */
1513         }       /* end of for */
1514
1515         if (!valid_device) {
1516                 err("Could not find device to unconfigure.  Or could not read the card.\n");
1517                 return -1;
1518         }
1519         return 0;
1520 }
1521
1522 /*
1523  * free the resources of the card (multi, single, or bridged)
1524  * Parameters: slot, flag to say if this is for removing entire module or just
1525  * unconfiguring the device
1526  * TO DO:  will probably need to add some code in case there was some resource,
1527  * to remove it... this is from when we have errors in the configure_card...
1528  *                      !!!!!!!!!!!!!!!!!!!!!!!!!FOR BUSES!!!!!!!!!!!!
1529  * Returns: 0, -1, -ENODEV
1530  */
1531 int ibmphp_unconfigure_card(struct slot **slot_cur, int the_end)
1532 {
1533         int i;
1534         int count;
1535         int rc;
1536         struct slot *sl = *slot_cur;
1537         struct pci_func *cur_func = NULL;
1538         struct pci_func *temp_func;
1539
1540         debug("%s - enter\n", __func__);
1541
1542         if (!the_end) {
1543                 /* Need to unconfigure the card */
1544                 rc = unconfigure_boot_card(sl);
1545                 if ((rc == -ENODEV) || (rc == -EIO) || (rc == -EINVAL)) {
1546                         /* In all other cases, will still need to get rid of func structure if it exists */
1547                         return rc;
1548                 }
1549         }
1550
1551         if (sl->func) {
1552                 cur_func = sl->func;
1553                 while (cur_func) {
1554                         /* TO DO: WILL MOST LIKELY NEED TO GET RID OF THE BUS STRUCTURE FROM RESOURCES AS WELL */
1555                         if (cur_func->bus) {
1556                                 /* in other words, it's a PPB */
1557                                 count = 2;
1558                         } else {
1559                                 count = 6;
1560                         }
1561
1562                         for (i = 0; i < count; i++) {
1563                                 if (cur_func->io[i]) {
1564                                         debug("io[%d] exists\n", i);
1565                                         if (the_end > 0)
1566                                                 ibmphp_remove_resource(cur_func->io[i]);
1567                                         cur_func->io[i] = NULL;
1568                                 }
1569                                 if (cur_func->mem[i]) {
1570                                         debug("mem[%d] exists\n", i);
1571                                         if (the_end > 0)
1572                                                 ibmphp_remove_resource(cur_func->mem[i]);
1573                                         cur_func->mem[i] = NULL;
1574                                 }
1575                                 if (cur_func->pfmem[i]) {
1576                                         debug("pfmem[%d] exists\n", i);
1577                                         if (the_end > 0)
1578                                                 ibmphp_remove_resource(cur_func->pfmem[i]);
1579                                         cur_func->pfmem[i] = NULL;
1580                                 }
1581                         }
1582
1583                         temp_func = cur_func->next;
1584                         kfree(cur_func);
1585                         cur_func = temp_func;
1586                 }
1587         }
1588
1589         sl->func = NULL;
1590         *slot_cur = sl;
1591         debug("%s - exit\n", __func__);
1592         return 0;
1593 }
1594
1595 /*
1596  * add a new bus resulting from hot-plugging a PPB bridge with devices
1597  *
1598  * Input: bus and the amount of resources needed (we know we can assign those,
1599  *        since they've been checked already
1600  * Output: bus added to the correct spot
1601  *         0, -1, error
1602  */
1603 static int add_new_bus(struct bus_node *bus, struct resource_node *io, struct resource_node *mem, struct resource_node *pfmem, u8 parent_busno)
1604 {
1605         struct range_node *io_range = NULL;
1606         struct range_node *mem_range = NULL;
1607         struct range_node *pfmem_range = NULL;
1608         struct bus_node *cur_bus = NULL;
1609
1610         /* Trying to find the parent bus number */
1611         if (parent_busno != 0xFF) {
1612                 cur_bus = ibmphp_find_res_bus(parent_busno);
1613                 if (!cur_bus) {
1614                         err("strange, cannot find bus which is supposed to be at the system... something is terribly wrong...\n");
1615                         return -ENODEV;
1616                 }
1617
1618                 list_add(&bus->bus_list, &cur_bus->bus_list);
1619         }
1620         if (io) {
1621                 io_range = kzalloc(sizeof(*io_range), GFP_KERNEL);
1622                 if (!io_range)
1623                         return -ENOMEM;
1624
1625                 io_range->start = io->start;
1626                 io_range->end = io->end;
1627                 io_range->rangeno = 1;
1628                 bus->noIORanges = 1;
1629                 bus->rangeIO = io_range;
1630         }
1631         if (mem) {
1632                 mem_range = kzalloc(sizeof(*mem_range), GFP_KERNEL);
1633                 if (!mem_range)
1634                         return -ENOMEM;
1635
1636                 mem_range->start = mem->start;
1637                 mem_range->end = mem->end;
1638                 mem_range->rangeno = 1;
1639                 bus->noMemRanges = 1;
1640                 bus->rangeMem = mem_range;
1641         }
1642         if (pfmem) {
1643                 pfmem_range = kzalloc(sizeof(*pfmem_range), GFP_KERNEL);
1644                 if (!pfmem_range)
1645                         return -ENOMEM;
1646
1647                 pfmem_range->start = pfmem->start;
1648                 pfmem_range->end = pfmem->end;
1649                 pfmem_range->rangeno = 1;
1650                 bus->noPFMemRanges = 1;
1651                 bus->rangePFMem = pfmem_range;
1652         }
1653         return 0;
1654 }
1655
1656 /*
1657  * find the 1st available bus number for PPB to set as its secondary bus
1658  * Parameters: bus_number of the primary bus
1659  * Returns: bus_number of the secondary bus or 0xff in case of failure
1660  */
1661 static u8 find_sec_number(u8 primary_busno, u8 slotno)
1662 {
1663         int min, max;
1664         u8 busno;
1665         struct bus_info *bus;
1666         struct bus_node *bus_cur;
1667
1668         bus = ibmphp_find_same_bus_num(primary_busno);
1669         if (!bus) {
1670                 err("cannot get slot range of the bus from the BIOS\n");
1671                 return 0xff;
1672         }
1673         max = bus->slot_max;
1674         min = bus->slot_min;
1675         if ((slotno > max) || (slotno < min)) {
1676                 err("got the wrong range\n");
1677                 return 0xff;
1678         }
1679         busno = (u8) (slotno - (u8) min);
1680         busno += primary_busno + 0x01;
1681         bus_cur = ibmphp_find_res_bus(busno);
1682         /* either there is no such bus number, or there are no ranges, which
1683          * can only happen if we removed the bridged device in previous load
1684          * of the driver, and now only have the skeleton bus struct
1685          */
1686         if ((!bus_cur) || (!(bus_cur->rangeIO) && !(bus_cur->rangeMem) && !(bus_cur->rangePFMem)))
1687                 return busno;
1688         return 0xff;
1689 }