// SPDX-License-Identifier: GPL-2.0+
/*
 * 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.
 *
 * Send feedback to <greg@kroah.com>
 *
 */

#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/pci_hotplug.h>
#include <linux/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;

/* lock for ordering int15_bios_call() */
static spinlock_t int15_lock;


/* 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", __func__, 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 = 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 = 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 = 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 = 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;
}