Linux-2.6.12-rc2v2.6.12-rc2

Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.

Let it rip!

1 files changed, 666 insertions, 0 deletions

diff --git a/drivers/pci/hotplug/cpqphp_nvram.c b/drivers/pci/hotplug/cpqphp_nvram.c
new file mode 100644
index 000000000000..ac98a11bd1eb
--- /dev/null
+++ b/drivers/pci/hotplug/cpqphp_nvram.c
@@ -0,0 +1,666 @@
+/*
+ * Compaq Hot Plug Controller Driver
+ *
+ * Copyright (C) 1995,2001 Compaq Computer Corporation
+ * Copyright (C) 2001 Greg Kroah-Hartman (greg@kroah.com)
+ * Copyright (C) 2001 IBM Corp.
+ *
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
+ * NON INFRINGEMENT.  See the GNU General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Send feedback to <greg@kroah.com>
+ *
+ */
+
+#include <linux/config.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/proc_fs.h>
+#include <linux/slab.h>
+#include <linux/workqueue.h>
+#include <linux/pci.h>
+#include <linux/init.h>
+#include <asm/uaccess.h>
+#include "cpqphp.h"
+#include "cpqphp_nvram.h"
+
+
+#define ROM_INT15_PHY_ADDR              0x0FF859
+#define READ_EV                         0xD8A4
+#define WRITE_EV                        0xD8A5
+
+struct register_foo {
+        union {
+                unsigned long lword;            /* eax */
+                unsigned short word;            /* ax */
+
+                struct {
+                        unsigned char low;      /* al */
+                        unsigned char high;     /* ah */
+                } byte;
+        } data;
+
+        unsigned char opcode;   /* see below */
+        unsigned long length;   /* if the reg. is a pointer, how much data */
+} __attribute__ ((packed));
+
+struct all_reg {
+        struct register_foo eax_reg;
+        struct register_foo ebx_reg;
+        struct register_foo ecx_reg;
+        struct register_foo edx_reg;
+        struct register_foo edi_reg;
+        struct register_foo esi_reg;
+        struct register_foo eflags_reg;
+} __attribute__ ((packed));
+
+
+struct ev_hrt_header {
+        u8 Version;
+        u8 num_of_ctrl;
+        u8 next;
+};
+
+struct ev_hrt_ctrl {
+        u8 bus;
+        u8 device;
+        u8 function;
+        u8 mem_avail;
+        u8 p_mem_avail;
+        u8 io_avail;
+        u8 bus_avail;
+        u8 next;
+};
+
+
+static u8 evbuffer_init;
+static u8 evbuffer_length;
+static u8 evbuffer[1024];
+
+static void __iomem *compaq_int15_entry_point;
+
+static spinlock_t int15_lock;           /* lock for ordering int15_bios_call() */
+
+
+/* This is a series of function that deals with
+   setting & getting the hotplug resource table in some environment variable.
+*/
+
+/*
+ * We really shouldn't be doing this unless there is a _very_ good reason to!!!
+ * greg k-h
+ */
+
+
+static u32 add_byte( u32 **p_buffer, u8 value, u32 *used, u32 *avail)
+{
+        u8 **tByte;
+
+        if ((*used + 1) > *avail)
+                return(1);
+        
+        *((u8*)*p_buffer) = value;
+        tByte = (u8**)p_buffer;
+        (*tByte)++;
+        *used+=1;
+        return(0);
+}
+
+
+static u32 add_dword( u32 **p_buffer, u32 value, u32 *used, u32 *avail)
+{
+        if ((*used + 4) > *avail)
+                return(1);
+
+        **p_buffer = value;
+        (*p_buffer)++;
+        *used+=4;
+        return(0);
+}
+
+
+/*
+ * check_for_compaq_ROM
+ *
+ * this routine verifies that the ROM OEM string is 'COMPAQ'
+ *
+ * returns 0 for non-Compaq ROM, 1 for Compaq ROM
+ */
+static int check_for_compaq_ROM (void __iomem *rom_start)
+{
+        u8 temp1, temp2, temp3, temp4, temp5, temp6;
+        int result = 0;
+
+        temp1 = readb(rom_start + 0xffea + 0);
+        temp2 = readb(rom_start + 0xffea + 1);
+        temp3 = readb(rom_start + 0xffea + 2);
+        temp4 = readb(rom_start + 0xffea + 3);
+        temp5 = readb(rom_start + 0xffea + 4);
+        temp6 = readb(rom_start + 0xffea + 5);
+        if ((temp1 == 'C') &&
+            (temp2 == 'O') &&
+            (temp3 == 'M') &&
+            (temp4 == 'P') &&
+            (temp5 == 'A') &&
+            (temp6 == 'Q')) {
+                result = 1;
+        }
+        dbg ("%s - returned %d\n", __FUNCTION__, result);
+        return result;
+}
+
+
+static u32 access_EV (u16 operation, u8 *ev_name, u8 *buffer, u32 *buf_size)
+{
+        unsigned long flags;
+        int op = operation;
+        int ret_val;
+        
+        if (!compaq_int15_entry_point)
+                return -ENODEV;
+        
+        spin_lock_irqsave(&int15_lock, flags);
+        __asm__ (
+                "xorl   %%ebx,%%ebx\n" \
+                "xorl    %%edx,%%edx\n" \
+                "pushf\n" \
+                "push %%cs\n" \
+                "cli\n" \
+                "call *%6\n"
+                : "=c" (*buf_size), "=a" (ret_val)
+                : "a" (op), "c" (*buf_size), "S" (ev_name),
+                "D" (buffer), "m" (compaq_int15_entry_point)
+                : "%ebx", "%edx");
+        spin_unlock_irqrestore(&int15_lock, flags);
+        
+        return((ret_val & 0xFF00) >> 8);
+}
+
+
+/*
+ * load_HRT
+ *
+ * Read the hot plug Resource Table from NVRAM
+ */
+static int load_HRT (void __iomem *rom_start)
+{
+        u32 available;
+        u32 temp_dword;
+        u8 temp_byte = 0xFF;
+        u32 rc;
+
+        if (!check_for_compaq_ROM(rom_start)) {
+                return -ENODEV;
+        }
+
+        available = 1024;
+
+        // Now load the EV
+        temp_dword = available;
+
+        rc = access_EV(READ_EV, "CQTHPS", evbuffer, &temp_dword);
+
+        evbuffer_length = temp_dword;
+
+        // We're maintaining the resource lists so write FF to invalidate old info
+        temp_dword = 1;
+
+        rc = access_EV(WRITE_EV, "CQTHPS", &temp_byte, &temp_dword);
+
+        return rc;
+}
+
+
+/*
+ * store_HRT
+ *
+ * Save the hot plug Resource Table in NVRAM
+ */
+static u32 store_HRT (void __iomem *rom_start)
+{
+        u32 *buffer;
+        u32 *pFill;
+        u32 usedbytes;
+        u32 available;
+        u32 temp_dword;
+        u32 rc;
+        u8 loop;
+        u8 numCtrl = 0;
+        struct controller *ctrl;
+        struct pci_resource *resNode;
+        struct ev_hrt_header *p_EV_header;
+        struct ev_hrt_ctrl *p_ev_ctrl;
+
+        available = 1024;
+
+        if (!check_for_compaq_ROM(rom_start)) {
+                return(1);
+        }
+
+        buffer = (u32*) evbuffer;
+
+        if (!buffer)
+                return(1);
+
+        pFill = buffer;
+        usedbytes = 0;
+
+        p_EV_header = (struct ev_hrt_header *) pFill;
+
+        ctrl = cpqhp_ctrl_list;
+        
+        // The revision of this structure
+        rc = add_byte( &pFill, 1 + ctrl->push_flag, &usedbytes, &available);
+        if (rc)
+                return(rc);
+
+        // The number of controllers
+        rc = add_byte( &pFill, 1, &usedbytes, &available);
+        if (rc)
+                return(rc);
+
+        while (ctrl) {
+                p_ev_ctrl = (struct ev_hrt_ctrl *) pFill;
+
+                numCtrl++;
+
+                // The bus number
+                rc = add_byte( &pFill, ctrl->bus, &usedbytes, &available);
+                if (rc)
+                        return(rc);
+
+                // The device Number
+                rc = add_byte( &pFill, PCI_SLOT(ctrl->pci_dev->devfn), &usedbytes, &available);
+                if (rc)
+                        return(rc);
+
+                // The function Number
+                rc = add_byte( &pFill, PCI_FUNC(ctrl->pci_dev->devfn), &usedbytes, &available);
+                if (rc)
+                        return(rc);
+
+                // Skip the number of available entries
+                rc = add_dword( &pFill, 0, &usedbytes, &available);
+                if (rc)
+                        return(rc);
+
+                // Figure out memory Available
+
+                resNode = ctrl->mem_head;
+
+                loop = 0;
+
+                while (resNode) {
+                        loop ++;
+
+                        // base
+                        rc = add_dword( &pFill, resNode->base, &usedbytes, &available);
+                        if (rc)
+                                return(rc);
+
+                        // length
+                        rc = add_dword( &pFill, resNode->length, &usedbytes, &available);
+                        if (rc)
+                                return(rc);
+
+                        resNode = resNode->next;
+                }
+
+                // Fill in the number of entries
+                p_ev_ctrl->mem_avail = loop;
+
+                // Figure out prefetchable memory Available
+
+                resNode = ctrl->p_mem_head;
+
+                loop = 0;
+
+                while (resNode) {
+                        loop ++;
+
+                        // base
+                        rc = add_dword( &pFill, resNode->base, &usedbytes, &available);
+                        if (rc)
+                                return(rc);
+
+                        // length
+                        rc = add_dword( &pFill, resNode->length, &usedbytes, &available);
+                        if (rc)
+                                return(rc);
+
+                        resNode = resNode->next;
+                }
+
+                // Fill in the number of entries
+                p_ev_ctrl->p_mem_avail = loop;
+
+                // Figure out IO Available
+
+                resNode = ctrl->io_head;
+
+                loop = 0;
+
+                while (resNode) {
+                        loop ++;
+
+                        // base
+                        rc = add_dword( &pFill, resNode->base, &usedbytes, &available);
+                        if (rc)
+                                return(rc);
+
+                        // length
+                        rc = add_dword( &pFill, resNode->length, &usedbytes, &available);
+                        if (rc)
+                                return(rc);
+
+                        resNode = resNode->next;
+                }
+
+                // Fill in the number of entries
+                p_ev_ctrl->io_avail = loop;
+
+                // Figure out bus Available
+
+                resNode = ctrl->bus_head;
+
+                loop = 0;
+
+                while (resNode) {
+                        loop ++;
+
+                        // base
+                        rc = add_dword( &pFill, resNode->base, &usedbytes, &available);
+                        if (rc)
+                                return(rc);
+
+                        // length
+                        rc = add_dword( &pFill, resNode->length, &usedbytes, &available);
+                        if (rc)
+                                return(rc);
+
+                        resNode = resNode->next;
+                }
+
+                // Fill in the number of entries
+                p_ev_ctrl->bus_avail = loop;
+
+                ctrl = ctrl->next;
+        }
+        
+        p_EV_header->num_of_ctrl = numCtrl;
+
+        // Now store the EV
+
+        temp_dword = usedbytes;
+
+        rc = access_EV(WRITE_EV, "CQTHPS", (u8*) buffer, &temp_dword);
+
+        dbg("usedbytes = 0x%x, length = 0x%x\n", usedbytes, temp_dword);
+
+        evbuffer_length = temp_dword;
+
+        if (rc) {
+                err(msg_unable_to_save);
+                return(1);
+        }
+
+        return(0);
+}
+
+
+void compaq_nvram_init (void __iomem *rom_start)
+{
+        if (rom_start) {
+                compaq_int15_entry_point = (rom_start + ROM_INT15_PHY_ADDR - ROM_PHY_ADDR);
+        }
+        dbg("int15 entry  = %p\n", compaq_int15_entry_point);
+
+        /* initialize our int15 lock */
+        spin_lock_init(&int15_lock);
+}
+
+
+int compaq_nvram_load (void __iomem *rom_start, struct controller *ctrl)
+{
+        u8 bus, device, function;
+        u8 nummem, numpmem, numio, numbus;
+        u32 rc;
+        u8 *p_byte;
+        struct pci_resource *mem_node;
+        struct pci_resource *p_mem_node;
+        struct pci_resource *io_node;
+        struct pci_resource *bus_node;
+        struct ev_hrt_ctrl *p_ev_ctrl;
+        struct ev_hrt_header *p_EV_header;
+
+        if (!evbuffer_init) {
+                // Read the resource list information in from NVRAM
+                if (load_HRT(rom_start))
+                        memset (evbuffer, 0, 1024);
+
+                evbuffer_init = 1;
+        }
+
+        // If we saved information in NVRAM, use it now
+        p_EV_header = (struct ev_hrt_header *) evbuffer;
+
+        // The following code is for systems where version 1.0 of this
+        // driver has been loaded, but doesn't support the hardware.
+        // In that case, the driver would incorrectly store something
+        // in NVRAM.
+        if ((p_EV_header->Version == 2) ||
+            ((p_EV_header->Version == 1) && !ctrl->push_flag)) {
+                p_byte = &(p_EV_header->next);
+
+                p_ev_ctrl = (struct ev_hrt_ctrl *) &(p_EV_header->next);
+
+                p_byte += 3;
+
+                if (p_byte > ((u8*)p_EV_header + evbuffer_length))
+                        return 2;
+
+                bus = p_ev_ctrl->bus;
+                device = p_ev_ctrl->device;
+                function = p_ev_ctrl->function;
+
+                while ((bus != ctrl->bus) ||
+                       (device != PCI_SLOT(ctrl->pci_dev->devfn)) || 
+                       (function != PCI_FUNC(ctrl->pci_dev->devfn))) {
+                        nummem = p_ev_ctrl->mem_avail;
+                        numpmem = p_ev_ctrl->p_mem_avail;
+                        numio = p_ev_ctrl->io_avail;
+                        numbus = p_ev_ctrl->bus_avail;
+
+                        p_byte += 4;
+
+                        if (p_byte > ((u8*)p_EV_header + evbuffer_length))
+                                return 2;
+
+                        // Skip forward to the next entry
+                        p_byte += (nummem + numpmem + numio + numbus) * 8;
+
+                        if (p_byte > ((u8*)p_EV_header + evbuffer_length))
+                                return 2;
+
+                        p_ev_ctrl = (struct ev_hrt_ctrl *) p_byte;
+
+                        p_byte += 3;
+
+                        if (p_byte > ((u8*)p_EV_header + evbuffer_length))
+                                return 2;
+
+                        bus = p_ev_ctrl->bus;
+                        device = p_ev_ctrl->device;
+                        function = p_ev_ctrl->function;
+                }
+
+                nummem = p_ev_ctrl->mem_avail;
+                numpmem = p_ev_ctrl->p_mem_avail;
+                numio = p_ev_ctrl->io_avail;
+                numbus = p_ev_ctrl->bus_avail;
+
+                p_byte += 4;
+
+                if (p_byte > ((u8*)p_EV_header + evbuffer_length))
+                        return 2;
+
+                while (nummem--) {
+                        mem_node = (struct pci_resource*) kmalloc(sizeof(struct pci_resource), GFP_KERNEL);
+
+                        if (!mem_node)
+                                break;
+
+                        mem_node->base = *(u32*)p_byte;
+                        dbg("mem base = %8.8x\n",mem_node->base);
+                        p_byte += 4;
+
+                        if (p_byte > ((u8*)p_EV_header + evbuffer_length)) {
+                                kfree(mem_node);
+                                return 2;
+                        }
+
+                        mem_node->length = *(u32*)p_byte;
+                        dbg("mem length = %8.8x\n",mem_node->length);
+                        p_byte += 4;
+
+                        if (p_byte > ((u8*)p_EV_header + evbuffer_length)) {
+                                kfree(mem_node);
+                                return 2;
+                        }
+
+                        mem_node->next = ctrl->mem_head;
+                        ctrl->mem_head = mem_node;
+                }
+
+                while (numpmem--) {
+                        p_mem_node = (struct pci_resource*) kmalloc(sizeof(struct pci_resource), GFP_KERNEL);
+
+                        if (!p_mem_node)
+                                break;
+
+                        p_mem_node->base = *(u32*)p_byte;
+                        dbg("pre-mem base = %8.8x\n",p_mem_node->base);
+                        p_byte += 4;
+
+                        if (p_byte > ((u8*)p_EV_header + evbuffer_length)) {
+                                kfree(p_mem_node);
+                                return 2;
+                        }
+
+                        p_mem_node->length = *(u32*)p_byte;
+                        dbg("pre-mem length = %8.8x\n",p_mem_node->length);
+                        p_byte += 4;
+
+                        if (p_byte > ((u8*)p_EV_header + evbuffer_length)) {
+                                kfree(p_mem_node);
+                                return 2;
+                        }
+
+                        p_mem_node->next = ctrl->p_mem_head;
+                        ctrl->p_mem_head = p_mem_node;
+                }
+
+                while (numio--) {
+                        io_node = (struct pci_resource*) kmalloc(sizeof(struct pci_resource), GFP_KERNEL);
+
+                        if (!io_node)
+                                break;
+
+                        io_node->base = *(u32*)p_byte;
+                        dbg("io base = %8.8x\n",io_node->base);
+                        p_byte += 4;
+
+                        if (p_byte > ((u8*)p_EV_header + evbuffer_length)) {
+                                kfree(io_node);
+                                return 2;
+                        }
+
+                        io_node->length = *(u32*)p_byte;
+                        dbg("io length = %8.8x\n",io_node->length);
+                        p_byte += 4;
+
+                        if (p_byte > ((u8*)p_EV_header + evbuffer_length)) {
+                                kfree(io_node);
+                                return 2;
+                        }
+
+                        io_node->next = ctrl->io_head;
+                        ctrl->io_head = io_node;
+                }
+
+                while (numbus--) {
+                        bus_node = (struct pci_resource*) kmalloc(sizeof(struct pci_resource), GFP_KERNEL);
+
+                        if (!bus_node)
+                                break;
+
+                        bus_node->base = *(u32*)p_byte;
+                        p_byte += 4;
+
+                        if (p_byte > ((u8*)p_EV_header + evbuffer_length)) {
+                                kfree(bus_node);
+                                return 2;
+                        }
+
+                        bus_node->length = *(u32*)p_byte;
+                        p_byte += 4;
+
+                        if (p_byte > ((u8*)p_EV_header + evbuffer_length)) {
+                                kfree(bus_node);
+                                return 2;
+                        }
+
+                        bus_node->next = ctrl->bus_head;
+                        ctrl->bus_head = bus_node;
+                }
+
+                // If all of the following fail, we don't have any resources for
+                // hot plug add
+                rc = 1;
+                rc &= cpqhp_resource_sort_and_combine(&(ctrl->mem_head));
+                rc &= cpqhp_resource_sort_and_combine(&(ctrl->p_mem_head));
+                rc &= cpqhp_resource_sort_and_combine(&(ctrl->io_head));
+                rc &= cpqhp_resource_sort_and_combine(&(ctrl->bus_head));
+
+                if (rc)
+                        return(rc);
+        } else {
+                if ((evbuffer[0] != 0) && (!ctrl->push_flag)) 
+                        return 1;
+        }
+
+        return 0;
+}
+
+        
+int compaq_nvram_store (void __iomem *rom_start)
+{
+        int rc = 1;
+
+        if (rom_start == NULL)
+                return -ENODEV;
+
+        if (evbuffer_init) {
+                rc = store_HRT(rom_start);
+                if (rc) {
+                        err(msg_unable_to_save);
+                }
+        }
+        return rc;
+}
+