git.oblomov.eu Git - linux-2.6/blob - drivers/pci/hotplug/ibmphp_pci.c

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