arch/ia64/sn/kernel/io_acpi_init.c - arm/linux-arm64-legacy - Git at Google

 /*
  * This file is subject to the terms and conditions of the GNU General Public
  * License.  See the file "COPYING" in the main directory of this archive
  * for more details.
  *
  * Copyright (C) 2006 Silicon Graphics, Inc. All rights reserved.
  */

 #include <asm/sn/types.h>
 #include <asm/sn/addrs.h>
 #include <asm/sn/pcidev.h>
 #include <asm/sn/pcibus_provider_defs.h>
 #include <asm/sn/sn_sal.h>
 #include "xtalk/hubdev.h"
 #include <linux/acpi.h>
 #include <acpi/acnamesp.h>


 /*
  * The code in this file will only be executed when running with
  * a PROM that has ACPI IO support. (i.e., SN_ACPI_BASE_SUPPORT() == 1)
  */


 /*
  * This value must match the UUID the PROM uses
  * (io/acpi/defblk.c) when building a vendor descriptor.
  */
 struct acpi_vendor_uuid sn_uuid = {
 	.subtype = 0,
 	.data	= { 0x2c, 0xc6, 0xa6, 0xfe, 0x9c, 0x44, 0xda, 0x11,
 		    0xa2, 0x7c, 0x08, 0x00, 0x69, 0x13, 0xea, 0x51 },
 };

 struct sn_pcidev_match {
 	u8 bus;
 	unsigned int devfn;
 	acpi_handle handle;
 };

 /*
  * Perform the early IO init in PROM.
  */
 static s64
 sal_ioif_init(u64 *result)
 {
 	struct ia64_sal_retval isrv = {0,0,0,0};

 	SAL_CALL_NOLOCK(isrv,
 			SN_SAL_IOIF_INIT, 0, 0, 0, 0, 0, 0, 0);
 	*result = isrv.v0;
 	return isrv.status;
 }

 /*
  * sn_acpi_hubdev_init() - This function is called by acpi_ns_get_device_callback()
  *			   for all SGIHUB and SGITIO acpi devices defined in the
  *			   DSDT. It obtains the hubdev_info pointer from the
  *			   ACPI vendor resource, which the PROM setup, and sets up the
  *			   hubdev_info in the pda.
  */

 static acpi_status __init
 sn_acpi_hubdev_init(acpi_handle handle, u32 depth, void *context, void **ret)
 {
 	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 	u64 addr;
 	struct hubdev_info *hubdev;
 	struct hubdev_info *hubdev_ptr;
 	int i;
 	u64 nasid;
 	struct acpi_resource *resource;
 	acpi_status status;
 	struct acpi_resource_vendor_typed *vendor;
 	extern void sn_common_hubdev_init(struct hubdev_info *);

 	status = acpi_get_vendor_resource(handle, METHOD_NAME__CRS,
 					  &sn_uuid, &buffer);
 	if (ACPI_FAILURE(status)) {
 		printk(KERN_ERR
 		       "sn_acpi_hubdev_init: acpi_get_vendor_resource() "
 		       "(0x%x) failed for: ", status);
 		acpi_ns_print_node_pathname(handle, NULL);
 		printk("\n");
 		return AE_OK;		/* Continue walking namespace */
 	}

 	resource = buffer.pointer;
 	vendor = &resource->data.vendor_typed;
 	if ((vendor->byte_length - sizeof(struct acpi_vendor_uuid)) !=
 	    sizeof(struct hubdev_info *)) {
 		printk(KERN_ERR
 		       "sn_acpi_hubdev_init: Invalid vendor data length: %d for: ",
 		        vendor->byte_length);
 		acpi_ns_print_node_pathname(handle, NULL);
 		printk("\n");
 		goto exit;
 	}

 	memcpy(&addr, vendor->byte_data, sizeof(struct hubdev_info *));
 	hubdev_ptr = __va((struct hubdev_info *) addr);

 	nasid = hubdev_ptr->hdi_nasid;
 	i = nasid_to_cnodeid(nasid);
 	hubdev = (struct hubdev_info *)(NODEPDA(i)->pdinfo);
 	*hubdev = *hubdev_ptr;
 	sn_common_hubdev_init(hubdev);

 exit:
 	kfree(buffer.pointer);
 	return AE_OK;		/* Continue walking namespace */
 }

 /*
  * sn_get_bussoft_ptr() - The pcibus_bussoft pointer is found in
  *			  the ACPI Vendor resource for this bus.
  */
 static struct pcibus_bussoft *
 sn_get_bussoft_ptr(struct pci_bus *bus)
 {
 	u64 addr;
 	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 	acpi_handle handle;
 	struct pcibus_bussoft *prom_bussoft_ptr;
 	struct acpi_resource *resource;
 	acpi_status status;
 	struct acpi_resource_vendor_typed *vendor;


 	handle = PCI_CONTROLLER(bus)->acpi_handle;
 	status = acpi_get_vendor_resource(handle, METHOD_NAME__CRS,
 					  &sn_uuid, &buffer);
 	if (ACPI_FAILURE(status)) {
 		printk(KERN_ERR "%s: "
 		       "acpi_get_vendor_resource() failed (0x%x) for: ",
 		       __func__, status);
 		acpi_ns_print_node_pathname(handle, NULL);
 		printk("\n");
 		return NULL;
 	}
 	resource = buffer.pointer;
 	vendor = &resource->data.vendor_typed;

 	if ((vendor->byte_length - sizeof(struct acpi_vendor_uuid)) !=
 	     sizeof(struct pcibus_bussoft *)) {
 		printk(KERN_ERR
 		       "%s: Invalid vendor data length %d\n",
 			__func__, vendor->byte_length);
 		kfree(buffer.pointer);
 		return NULL;
 	}
 	memcpy(&addr, vendor->byte_data, sizeof(struct pcibus_bussoft *));
 	prom_bussoft_ptr = __va((struct pcibus_bussoft *) addr);
 	kfree(buffer.pointer);

 	return prom_bussoft_ptr;
 }

 /*
  * sn_extract_device_info - Extract the pcidev_info and the sn_irq_info
  *			    pointers from the vendor resource using the
  *			    provided acpi handle, and copy the structures
  *			    into the argument buffers.
  */
 static int
 sn_extract_device_info(acpi_handle handle, struct pcidev_info **pcidev_info,
 		    struct sn_irq_info **sn_irq_info)
 {
 	u64 addr;
 	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 	struct sn_irq_info *irq_info, *irq_info_prom;
 	struct pcidev_info *pcidev_ptr, *pcidev_prom_ptr;
 	struct acpi_resource *resource;
 	int ret = 0;
 	acpi_status status;
 	struct acpi_resource_vendor_typed *vendor;

 	/*
 	 * The pointer to this device's pcidev_info structure in
 	 * the PROM, is in the vendor resource.
 	 */
 	status = acpi_get_vendor_resource(handle, METHOD_NAME__CRS,
 					  &sn_uuid, &buffer);
 	if (ACPI_FAILURE(status)) {
 		printk(KERN_ERR
 		       "%s: acpi_get_vendor_resource() failed (0x%x) for: ",
 		        __func__, status);
 		acpi_ns_print_node_pathname(handle, NULL);
 		printk("\n");
 		return 1;
 	}

 	resource = buffer.pointer;
 	vendor = &resource->data.vendor_typed;
 	if ((vendor->byte_length - sizeof(struct acpi_vendor_uuid)) !=
 	    sizeof(struct pci_devdev_info *)) {
 		printk(KERN_ERR
 		       "%s: Invalid vendor data length: %d for: ",
 		        __func__, vendor->byte_length);
 		acpi_ns_print_node_pathname(handle, NULL);
 		printk("\n");
 		ret = 1;
 		goto exit;
 	}

 	pcidev_ptr = kzalloc(sizeof(struct pcidev_info), GFP_KERNEL);
 	if (!pcidev_ptr)
 		panic("%s: Unable to alloc memory for pcidev_info", __func__);

 	memcpy(&addr, vendor->byte_data, sizeof(struct pcidev_info *));
 	pcidev_prom_ptr = __va(addr);
 	memcpy(pcidev_ptr, pcidev_prom_ptr, sizeof(struct pcidev_info));

 	/* Get the IRQ info */
 	irq_info = kzalloc(sizeof(struct sn_irq_info), GFP_KERNEL);
 	if (!irq_info)
 		 panic("%s: Unable to alloc memory for sn_irq_info", __func__);

 	if (pcidev_ptr->pdi_sn_irq_info) {
 		irq_info_prom = __va(pcidev_ptr->pdi_sn_irq_info);
 		memcpy(irq_info, irq_info_prom, sizeof(struct sn_irq_info));
 	}

 	*pcidev_info = pcidev_ptr;
 	*sn_irq_info = irq_info;

 exit:
 	kfree(buffer.pointer);
 	return ret;
 }

 static unsigned int
 get_host_devfn(acpi_handle device_handle, acpi_handle rootbus_handle)
 {
 	unsigned long adr;
 	acpi_handle child;
 	unsigned int devfn;
 	int function;
 	acpi_handle parent;
 	int slot;
 	acpi_status status;

 	/*
 	 * Do an upward search to find the root bus device, and
 	 * obtain the host devfn from the previous child device.
 	 */
 	child = device_handle;
 	while (child) {
 		status = acpi_get_parent(child, &parent);
 		if (ACPI_FAILURE(status)) {
 			printk(KERN_ERR "%s: acpi_get_parent() failed "
 			       "(0x%x) for: ", __func__, status);
 			acpi_ns_print_node_pathname(child, NULL);
 			printk("\n");
 			panic("%s: Unable to find host devfn\n", __func__);
 		}
 		if (parent == rootbus_handle)
 			break;
 		child = parent;
 	}
 	if (!child) {
 		printk(KERN_ERR "%s: Unable to find root bus for: ",
 		       __func__);
 		acpi_ns_print_node_pathname(device_handle, NULL);
 		printk("\n");
 		BUG();
 	}

 	status = acpi_evaluate_integer(child, METHOD_NAME__ADR, NULL, &adr);
 	if (ACPI_FAILURE(status)) {
 		printk(KERN_ERR "%s: Unable to get _ADR (0x%x) for: ",
 		       __func__, status);
 		acpi_ns_print_node_pathname(child, NULL);
 		printk("\n");
 		panic("%s: Unable to find host devfn\n", __func__);
 	}

 	slot = (adr >> 16) & 0xffff;
 	function = adr & 0xffff;
 	devfn = PCI_DEVFN(slot, function);
 	return devfn;
 }

 /*
  * find_matching_device - Callback routine to find the ACPI device
  *			  that matches up with our pci_dev device.
  *			  Matching is done on bus number and devfn.
  *			  To find the bus number for a particular
  *			  ACPI device, we must look at the _BBN method
  *			  of its parent.
  */
 static acpi_status
 find_matching_device(acpi_handle handle, u32 lvl, void *context, void **rv)
 {
 	unsigned long bbn = -1;
 	unsigned long adr;
 	acpi_handle parent = NULL;
 	acpi_status status;
 	unsigned int devfn;
 	int function;
 	int slot;
 	struct sn_pcidev_match *info = context;

         status = acpi_evaluate_integer(handle, METHOD_NAME__ADR, NULL,
                                        &adr);
         if (ACPI_SUCCESS(status)) {
 		status = acpi_get_parent(handle, &parent);
 		if (ACPI_FAILURE(status)) {
 			printk(KERN_ERR
 			       "%s: acpi_get_parent() failed (0x%x) for: ",
 					__func__, status);
 			acpi_ns_print_node_pathname(handle, NULL);
 			printk("\n");
 			return AE_OK;
 		}
 		status = acpi_evaluate_integer(parent, METHOD_NAME__BBN,
 					       NULL, &bbn);
 		if (ACPI_FAILURE(status)) {
 			printk(KERN_ERR
 			  "%s: Failed to find _BBN in parent of: ",
 					__func__);
 			acpi_ns_print_node_pathname(handle, NULL);
 			printk("\n");
 			return AE_OK;
 		}

                 slot = (adr >> 16) & 0xffff;
                 function = adr & 0xffff;
                 devfn = PCI_DEVFN(slot, function);
                 if ((info->devfn == devfn) && (info->bus == bbn)) {
 			/* We have a match! */
 			info->handle = handle;
 			return 1;
 		}
 	}
 	return AE_OK;
 }

 /*
  * sn_acpi_get_pcidev_info - Search ACPI namespace for the acpi
  *			     device matching the specified pci_dev,
  *			     and return the pcidev info and irq info.
  */
 int
 sn_acpi_get_pcidev_info(struct pci_dev *dev, struct pcidev_info **pcidev_info,
 			struct sn_irq_info **sn_irq_info)
 {
 	unsigned int host_devfn;
 	struct sn_pcidev_match pcidev_match;
 	acpi_handle rootbus_handle;
 	unsigned long segment;
 	acpi_status status;

 	rootbus_handle = PCI_CONTROLLER(dev)->acpi_handle;
         status = acpi_evaluate_integer(rootbus_handle, METHOD_NAME__SEG, NULL,
                                        &segment);
         if (ACPI_SUCCESS(status)) {
 		if (segment != pci_domain_nr(dev)) {
 			printk(KERN_ERR
 			       "%s: Segment number mismatch, 0x%lx vs 0x%x for: ",
 			       __func__, segment, pci_domain_nr(dev));
 			acpi_ns_print_node_pathname(rootbus_handle, NULL);
 			printk("\n");
 			return 1;
 		}
 	} else {
 		printk(KERN_ERR "%s: Unable to get __SEG from: ",
 		       __func__);
 		acpi_ns_print_node_pathname(rootbus_handle, NULL);
 		printk("\n");
 		return 1;
 	}

 	/*
 	 * We want to search all devices in this segment/domain
 	 * of the ACPI namespace for the matching ACPI device,
 	 * which holds the pcidev_info pointer in its vendor resource.
 	 */
 	pcidev_match.bus = dev->bus->number;
 	pcidev_match.devfn = dev->devfn;
 	pcidev_match.handle = NULL;

 	acpi_walk_namespace(ACPI_TYPE_DEVICE, rootbus_handle, ACPI_UINT32_MAX,
 			    find_matching_device, &pcidev_match, NULL);

 	if (!pcidev_match.handle) {
 		printk(KERN_ERR
 		       "%s: Could not find matching ACPI device for %s.\n",
 		       __func__, pci_name(dev));
 		return 1;
 	}

 	if (sn_extract_device_info(pcidev_match.handle, pcidev_info, sn_irq_info))
 		return 1;

 	/* Build up the pcidev_info.pdi_slot_host_handle */
 	host_devfn = get_host_devfn(pcidev_match.handle, rootbus_handle);
 	(*pcidev_info)->pdi_slot_host_handle =
 			((unsigned long) pci_domain_nr(dev) << 40) |
 					/* bus == 0 */
 					host_devfn;
 	return 0;
 }

 /*
  * sn_acpi_slot_fixup - Obtain the pcidev_info and sn_irq_info.
  *			Perform any SN specific slot fixup.
  *			At present there does not appear to be
  *			any generic way to handle a ROM image
  *			that has been shadowed by the PROM, so
  *			we pass a pointer to it	within the
  *			pcidev_info structure.
  */

 void
 sn_acpi_slot_fixup(struct pci_dev *dev)
 {
 	void __iomem *addr;
 	struct pcidev_info *pcidev_info = NULL;
 	struct sn_irq_info *sn_irq_info = NULL;
 	size_t image_size, size;

 	if (sn_acpi_get_pcidev_info(dev, &pcidev_info, &sn_irq_info)) {
 		panic("%s:  Failure obtaining pcidev_info for %s\n",
 		      __func__, pci_name(dev));
 	}

 	if (pcidev_info->pdi_pio_mapped_addr[PCI_ROM_RESOURCE]) {
 		/*
 		 * A valid ROM image exists and has been shadowed by the
 		 * PROM. Setup the pci_dev ROM resource with the address
 		 * of the shadowed copy, and the actual length of the ROM image.
 		 */
 		size = pci_resource_len(dev, PCI_ROM_RESOURCE);
 		addr = ioremap(pcidev_info->pdi_pio_mapped_addr[PCI_ROM_RESOURCE],
 			       size);
 		image_size = pci_get_rom_size(addr, size);
 		dev->resource[PCI_ROM_RESOURCE].start = (unsigned long) addr;
 		dev->resource[PCI_ROM_RESOURCE].end =
 					(unsigned long) addr + image_size - 1;
 		dev->resource[PCI_ROM_RESOURCE].flags |= IORESOURCE_ROM_BIOS_COPY;
 	}
 	sn_pci_fixup_slot(dev, pcidev_info, sn_irq_info);
 }

 EXPORT_SYMBOL(sn_acpi_slot_fixup);


 /*
  * sn_acpi_bus_fixup -  Perform SN specific setup of software structs
  *			(pcibus_bussoft, pcidev_info) and hardware
  *			registers, for the specified bus and devices under it.
  */
 void
 sn_acpi_bus_fixup(struct pci_bus *bus)
 {
 	struct pci_dev *pci_dev = NULL;
 	struct pcibus_bussoft *prom_bussoft_ptr;

 	if (!bus->parent) {	/* If root bus */
 		prom_bussoft_ptr = sn_get_bussoft_ptr(bus);
 		if (prom_bussoft_ptr == NULL) {
 			printk(KERN_ERR
 			       "%s: 0x%04x:0x%02x Unable to "
 			       "obtain prom_bussoft_ptr\n",
 			       __func__, pci_domain_nr(bus), bus->number);
 			return;
 		}
 		sn_common_bus_fixup(bus, prom_bussoft_ptr);
 	}
 	list_for_each_entry(pci_dev, &bus->devices, bus_list) {
 		sn_acpi_slot_fixup(pci_dev);
 	}
 }

 /*
  * sn_io_acpi_init - PROM has ACPI support for IO, defining at a minimum the
  *		     nodes and root buses in the DSDT. As a result, bus scanning
  *		     will be initiated by the Linux ACPI code.
  */

 void __init
 sn_io_acpi_init(void)
 {
 	u64 result;
 	s64 status;

 	/* SN Altix does not follow the IOSAPIC IRQ routing model */
 	acpi_irq_model = ACPI_IRQ_MODEL_PLATFORM;

 	/* Setup hubdev_info for all SGIHUB/SGITIO devices */
 	acpi_get_devices("SGIHUB", sn_acpi_hubdev_init, NULL, NULL);
 	acpi_get_devices("SGITIO", sn_acpi_hubdev_init, NULL, NULL);

 	status = sal_ioif_init(&result);
 	if (status || result)
 		panic("sal_ioif_init failed: [%lx] %s\n",
 		      status, ia64_sal_strerror(status));
 }
	/*
	* This file is subject to the terms and conditions of the GNU General Public
	* License. See the file "COPYING" in the main directory of this archive
	* for more details.
	*
	* Copyright (C) 2006 Silicon Graphics, Inc. All rights reserved.
	*/

	#include <asm/sn/types.h>
	#include <asm/sn/addrs.h>
	#include <asm/sn/pcidev.h>
	#include <asm/sn/pcibus_provider_defs.h>
	#include <asm/sn/sn_sal.h>
	#include "xtalk/hubdev.h"
	#include <linux/acpi.h>
	#include <acpi/acnamesp.h>


	/*
	* The code in this file will only be executed when running with
	* a PROM that has ACPI IO support. (i.e., SN_ACPI_BASE_SUPPORT() == 1)
	*/


	/*
	* This value must match the UUID the PROM uses
	* (io/acpi/defblk.c) when building a vendor descriptor.
	*/
	struct acpi_vendor_uuid sn_uuid = {
	.subtype = 0,
	.data = { 0x2c, 0xc6, 0xa6, 0xfe, 0x9c, 0x44, 0xda, 0x11,
	0xa2, 0x7c, 0x08, 0x00, 0x69, 0x13, 0xea, 0x51 },
	};

	struct sn_pcidev_match {
	u8 bus;
	unsigned int devfn;
	acpi_handle handle;
	};

	/*
	* Perform the early IO init in PROM.
	*/
	static s64
	sal_ioif_init(u64 *result)
	{
	struct ia64_sal_retval isrv = {0,0,0,0};

	SAL_CALL_NOLOCK(isrv,
	SN_SAL_IOIF_INIT, 0, 0, 0, 0, 0, 0, 0);
	*result = isrv.v0;
	return isrv.status;
	}

	/*
	* sn_acpi_hubdev_init() - This function is called by acpi_ns_get_device_callback()
	* for all SGIHUB and SGITIO acpi devices defined in the
	* DSDT. It obtains the hubdev_info pointer from the
	* ACPI vendor resource, which the PROM setup, and sets up the
	* hubdev_info in the pda.
	*/

	static acpi_status __init
	sn_acpi_hubdev_init(acpi_handle handle, u32 depth, void context, void *ret)
	{
	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
	u64 addr;
	struct hubdev_info *hubdev;
	struct hubdev_info *hubdev_ptr;
	int i;
	u64 nasid;
	struct acpi_resource *resource;
	acpi_status status;
	struct acpi_resource_vendor_typed *vendor;
	extern void sn_common_hubdev_init(struct hubdev_info *);

	status = acpi_get_vendor_resource(handle, METHOD_NAME__CRS,
	&sn_uuid, &buffer);
	if (ACPI_FAILURE(status)) {
	printk(KERN_ERR
	"sn_acpi_hubdev_init: acpi_get_vendor_resource() "
	"(0x%x) failed for: ", status);
	acpi_ns_print_node_pathname(handle, NULL);
	printk("\n");
	return AE_OK; /* Continue walking namespace */
	}

	resource = buffer.pointer;
	vendor = &resource->data.vendor_typed;
	if ((vendor->byte_length - sizeof(struct acpi_vendor_uuid)) !=
	sizeof(struct hubdev_info *)) {
	printk(KERN_ERR
	"sn_acpi_hubdev_init: Invalid vendor data length: %d for: ",
	vendor->byte_length);
	acpi_ns_print_node_pathname(handle, NULL);
	printk("\n");
	goto exit;
	}

	memcpy(&addr, vendor->byte_data, sizeof(struct hubdev_info *));
	hubdev_ptr = __va((struct hubdev_info *) addr);

	nasid = hubdev_ptr->hdi_nasid;
	i = nasid_to_cnodeid(nasid);
	hubdev = (struct hubdev_info *)(NODEPDA(i)->pdinfo);
	hubdev = hubdev_ptr;
	sn_common_hubdev_init(hubdev);

	exit:
	kfree(buffer.pointer);
	return AE_OK; /* Continue walking namespace */
	}

	/*
	* sn_get_bussoft_ptr() - The pcibus_bussoft pointer is found in
	* the ACPI Vendor resource for this bus.
	*/
	static struct pcibus_bussoft *
	sn_get_bussoft_ptr(struct pci_bus *bus)
	{
	u64 addr;
	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
	acpi_handle handle;
	struct pcibus_bussoft *prom_bussoft_ptr;
	struct acpi_resource *resource;
	acpi_status status;
	struct acpi_resource_vendor_typed *vendor;


	handle = PCI_CONTROLLER(bus)->acpi_handle;
	status = acpi_get_vendor_resource(handle, METHOD_NAME__CRS,
	&sn_uuid, &buffer);
	if (ACPI_FAILURE(status)) {
	printk(KERN_ERR "%s: "
	"acpi_get_vendor_resource() failed (0x%x) for: ",
	__func__, status);
	acpi_ns_print_node_pathname(handle, NULL);
	printk("\n");
	return NULL;
	}
	resource = buffer.pointer;
	vendor = &resource->data.vendor_typed;

	if ((vendor->byte_length - sizeof(struct acpi_vendor_uuid)) !=
	sizeof(struct pcibus_bussoft *)) {
	printk(KERN_ERR
	"%s: Invalid vendor data length %d\n",
	__func__, vendor->byte_length);
	kfree(buffer.pointer);
	return NULL;
	}
	memcpy(&addr, vendor->byte_data, sizeof(struct pcibus_bussoft *));
	prom_bussoft_ptr = __va((struct pcibus_bussoft *) addr);
	kfree(buffer.pointer);

	return prom_bussoft_ptr;
	}

	/*
	* sn_extract_device_info - Extract the pcidev_info and the sn_irq_info
	* pointers from the vendor resource using the
	* provided acpi handle, and copy the structures
	* into the argument buffers.
	*/
	static int
	sn_extract_device_info(acpi_handle handle, struct pcidev_info **pcidev_info,
	struct sn_irq_info **sn_irq_info)
	{
	u64 addr;
	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
	struct sn_irq_info irq_info, irq_info_prom;
	struct pcidev_info pcidev_ptr, pcidev_prom_ptr;
	struct acpi_resource *resource;
	int ret = 0;
	acpi_status status;
	struct acpi_resource_vendor_typed *vendor;

	/*
	* The pointer to this device's pcidev_info structure in
	* the PROM, is in the vendor resource.
	*/
	status = acpi_get_vendor_resource(handle, METHOD_NAME__CRS,
	&sn_uuid, &buffer);
	if (ACPI_FAILURE(status)) {
	printk(KERN_ERR
	"%s: acpi_get_vendor_resource() failed (0x%x) for: ",
	__func__, status);
	acpi_ns_print_node_pathname(handle, NULL);
	printk("\n");
	return 1;
	}

	resource = buffer.pointer;
	vendor = &resource->data.vendor_typed;
	if ((vendor->byte_length - sizeof(struct acpi_vendor_uuid)) !=
	sizeof(struct pci_devdev_info *)) {
	printk(KERN_ERR
	"%s: Invalid vendor data length: %d for: ",
	__func__, vendor->byte_length);
	acpi_ns_print_node_pathname(handle, NULL);
	printk("\n");
	ret = 1;
	goto exit;
	}

	pcidev_ptr = kzalloc(sizeof(struct pcidev_info), GFP_KERNEL);
	if (!pcidev_ptr)
	panic("%s: Unable to alloc memory for pcidev_info", __func__);

	memcpy(&addr, vendor->byte_data, sizeof(struct pcidev_info *));
	pcidev_prom_ptr = __va(addr);
	memcpy(pcidev_ptr, pcidev_prom_ptr, sizeof(struct pcidev_info));

	/* Get the IRQ info */
	irq_info = kzalloc(sizeof(struct sn_irq_info), GFP_KERNEL);
	if (!irq_info)
	panic("%s: Unable to alloc memory for sn_irq_info", __func__);

	if (pcidev_ptr->pdi_sn_irq_info) {
	irq_info_prom = __va(pcidev_ptr->pdi_sn_irq_info);
	memcpy(irq_info, irq_info_prom, sizeof(struct sn_irq_info));
	}

	*pcidev_info = pcidev_ptr;
	*sn_irq_info = irq_info;

	exit:
	kfree(buffer.pointer);
	return ret;
	}

	static unsigned int
	get_host_devfn(acpi_handle device_handle, acpi_handle rootbus_handle)
	{
	unsigned long adr;
	acpi_handle child;
	unsigned int devfn;
	int function;
	acpi_handle parent;
	int slot;
	acpi_status status;

	/*
	* Do an upward search to find the root bus device, and
	* obtain the host devfn from the previous child device.
	*/
	child = device_handle;
	while (child) {
	status = acpi_get_parent(child, &parent);
	if (ACPI_FAILURE(status)) {
	printk(KERN_ERR "%s: acpi_get_parent() failed "
	"(0x%x) for: ", __func__, status);
	acpi_ns_print_node_pathname(child, NULL);
	printk("\n");
	panic("%s: Unable to find host devfn\n", __func__);
	}
	if (parent == rootbus_handle)
	break;
	child = parent;
	}
	if (!child) {
	printk(KERN_ERR "%s: Unable to find root bus for: ",
	__func__);
	acpi_ns_print_node_pathname(device_handle, NULL);
	printk("\n");
	BUG();
	}

	status = acpi_evaluate_integer(child, METHOD_NAME__ADR, NULL, &adr);
	if (ACPI_FAILURE(status)) {
	printk(KERN_ERR "%s: Unable to get _ADR (0x%x) for: ",
	__func__, status);
	acpi_ns_print_node_pathname(child, NULL);
	printk("\n");
	panic("%s: Unable to find host devfn\n", __func__);
	}

	slot = (adr >> 16) & 0xffff;
	function = adr & 0xffff;
	devfn = PCI_DEVFN(slot, function);
	return devfn;
	}

	/*
	* find_matching_device - Callback routine to find the ACPI device
	* that matches up with our pci_dev device.
	* Matching is done on bus number and devfn.
	* To find the bus number for a particular
	* ACPI device, we must look at the _BBN method
	* of its parent.
	*/
	static acpi_status
	find_matching_device(acpi_handle handle, u32 lvl, void context, void *rv)
	{
	unsigned long bbn = -1;
	unsigned long adr;
	acpi_handle parent = NULL;
	acpi_status status;
	unsigned int devfn;
	int function;
	int slot;
	struct sn_pcidev_match *info = context;

	status = acpi_evaluate_integer(handle, METHOD_NAME__ADR, NULL,
	&adr);
	if (ACPI_SUCCESS(status)) {
	status = acpi_get_parent(handle, &parent);
	if (ACPI_FAILURE(status)) {
	printk(KERN_ERR
	"%s: acpi_get_parent() failed (0x%x) for: ",
	__func__, status);
	acpi_ns_print_node_pathname(handle, NULL);
	printk("\n");
	return AE_OK;
	}
	status = acpi_evaluate_integer(parent, METHOD_NAME__BBN,
	NULL, &bbn);
	if (ACPI_FAILURE(status)) {
	printk(KERN_ERR
	"%s: Failed to find _BBN in parent of: ",
	__func__);
	acpi_ns_print_node_pathname(handle, NULL);
	printk("\n");
	return AE_OK;
	}

	slot = (adr >> 16) & 0xffff;
	function = adr & 0xffff;
	devfn = PCI_DEVFN(slot, function);
	if ((info->devfn == devfn) && (info->bus == bbn)) {
	/* We have a match! */
	info->handle = handle;
	return 1;
	}
	}
	return AE_OK;
	}

	/*
	* sn_acpi_get_pcidev_info - Search ACPI namespace for the acpi
	* device matching the specified pci_dev,
	* and return the pcidev info and irq info.
	*/
	int
	sn_acpi_get_pcidev_info(struct pci_dev dev, struct pcidev_info *pcidev_info,
	struct sn_irq_info **sn_irq_info)
	{
	unsigned int host_devfn;
	struct sn_pcidev_match pcidev_match;
	acpi_handle rootbus_handle;
	unsigned long segment;
	acpi_status status;

	rootbus_handle = PCI_CONTROLLER(dev)->acpi_handle;
	status = acpi_evaluate_integer(rootbus_handle, METHOD_NAME__SEG, NULL,
	&segment);
	if (ACPI_SUCCESS(status)) {
	if (segment != pci_domain_nr(dev)) {
	printk(KERN_ERR
	"%s: Segment number mismatch, 0x%lx vs 0x%x for: ",
	__func__, segment, pci_domain_nr(dev));
	acpi_ns_print_node_pathname(rootbus_handle, NULL);
	printk("\n");
	return 1;
	}
	} else {
	printk(KERN_ERR "%s: Unable to get __SEG from: ",
	__func__);
	acpi_ns_print_node_pathname(rootbus_handle, NULL);
	printk("\n");
	return 1;
	}

	/*
	* We want to search all devices in this segment/domain
	* of the ACPI namespace for the matching ACPI device,
	* which holds the pcidev_info pointer in its vendor resource.
	*/
	pcidev_match.bus = dev->bus->number;
	pcidev_match.devfn = dev->devfn;
	pcidev_match.handle = NULL;

	acpi_walk_namespace(ACPI_TYPE_DEVICE, rootbus_handle, ACPI_UINT32_MAX,
	find_matching_device, &pcidev_match, NULL);

	if (!pcidev_match.handle) {
	printk(KERN_ERR
	"%s: Could not find matching ACPI device for %s.\n",
	__func__, pci_name(dev));
	return 1;
	}

	if (sn_extract_device_info(pcidev_match.handle, pcidev_info, sn_irq_info))
	return 1;

	/* Build up the pcidev_info.pdi_slot_host_handle */
	host_devfn = get_host_devfn(pcidev_match.handle, rootbus_handle);
	(*pcidev_info)->pdi_slot_host_handle =
	((unsigned long) pci_domain_nr(dev) << 40) \|
	/* bus == 0 */
	host_devfn;
	return 0;
	}

	/*
	* sn_acpi_slot_fixup - Obtain the pcidev_info and sn_irq_info.
	* Perform any SN specific slot fixup.
	* At present there does not appear to be
	* any generic way to handle a ROM image
	* that has been shadowed by the PROM, so
	* we pass a pointer to it within the
	* pcidev_info structure.
	*/

	void
	sn_acpi_slot_fixup(struct pci_dev *dev)
	{
	void __iomem *addr;
	struct pcidev_info *pcidev_info = NULL;
	struct sn_irq_info *sn_irq_info = NULL;
	size_t image_size, size;

	if (sn_acpi_get_pcidev_info(dev, &pcidev_info, &sn_irq_info)) {
	panic("%s: Failure obtaining pcidev_info for %s\n",
	__func__, pci_name(dev));
	}

	if (pcidev_info->pdi_pio_mapped_addr[PCI_ROM_RESOURCE]) {
	/*
	* A valid ROM image exists and has been shadowed by the
	* PROM. Setup the pci_dev ROM resource with the address
	* of the shadowed copy, and the actual length of the ROM image.
	*/
	size = pci_resource_len(dev, PCI_ROM_RESOURCE);
	addr = ioremap(pcidev_info->pdi_pio_mapped_addr[PCI_ROM_RESOURCE],
	size);
	image_size = pci_get_rom_size(addr, size);
	dev->resource[PCI_ROM_RESOURCE].start = (unsigned long) addr;
	dev->resource[PCI_ROM_RESOURCE].end =
	(unsigned long) addr + image_size - 1;
	dev->resource[PCI_ROM_RESOURCE].flags \|= IORESOURCE_ROM_BIOS_COPY;
	}
	sn_pci_fixup_slot(dev, pcidev_info, sn_irq_info);
	}

	EXPORT_SYMBOL(sn_acpi_slot_fixup);


	/*
	* sn_acpi_bus_fixup - Perform SN specific setup of software structs
	* (pcibus_bussoft, pcidev_info) and hardware
	* registers, for the specified bus and devices under it.
	*/
	void
	sn_acpi_bus_fixup(struct pci_bus *bus)
	{
	struct pci_dev *pci_dev = NULL;
	struct pcibus_bussoft *prom_bussoft_ptr;

	if (!bus->parent) { /* If root bus */
	prom_bussoft_ptr = sn_get_bussoft_ptr(bus);
	if (prom_bussoft_ptr == NULL) {
	printk(KERN_ERR
	"%s: 0x%04x:0x%02x Unable to "
	"obtain prom_bussoft_ptr\n",
	__func__, pci_domain_nr(bus), bus->number);
	return;
	}
	sn_common_bus_fixup(bus, prom_bussoft_ptr);
	}
	list_for_each_entry(pci_dev, &bus->devices, bus_list) {
	sn_acpi_slot_fixup(pci_dev);
	}
	}

	/*
	* sn_io_acpi_init - PROM has ACPI support for IO, defining at a minimum the
	* nodes and root buses in the DSDT. As a result, bus scanning
	* will be initiated by the Linux ACPI code.
	*/

	void __init
	sn_io_acpi_init(void)
	{
	u64 result;
	s64 status;

	/* SN Altix does not follow the IOSAPIC IRQ routing model */
	acpi_irq_model = ACPI_IRQ_MODEL_PLATFORM;

	/* Setup hubdev_info for all SGIHUB/SGITIO devices */
	acpi_get_devices("SGIHUB", sn_acpi_hubdev_init, NULL, NULL);
	acpi_get_devices("SGITIO", sn_acpi_hubdev_init, NULL, NULL);

	status = sal_ioif_init(&result);
	if (status \|\| result)
	panic("sal_ioif_init failed: [%lx] %s\n",
	status, ia64_sal_strerror(status));
	}