[PATCH] W1: w1_netlink: New init/fini netlink callbacks.

[linux-2.6/verdex.git] / drivers / pci / hotplug / cpqphp_nvram.c

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