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