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