PRCM: 34XX: Fix wrong shift value used in dpll4_m4x2_ck enable bit

[linux-ginger.git] / arch / ia64 / sn / kernel / io_acpi_init.c

/*
 * 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));
}