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

// 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;
}
Commit	Line	Data
736759ef	1	// SPDX-License-Identifier: GPL-2.0+
1da177e4 LT	2	/*
	3	* Compaq Hot Plug Controller Driver
	4	*
	5	* Copyright (C) 1995,2001 Compaq Computer Corporation
	6	* Copyright (C) 2001 Greg Kroah-Hartman (greg@kroah.com)
	7	* Copyright (C) 2001 IBM Corp.
	8	*
	9	* All rights reserved.
	10	*
1da177e4 LT	11	* Send feedback to <greg@kroah.com>
	12	*
	13	*/
	14
1da177e4 LT	15	#include <linux/module.h>
	16	#include <linux/kernel.h>
	17	#include <linux/types.h>
	18	#include <linux/proc_fs.h>
	19	#include <linux/slab.h>
	20	#include <linux/workqueue.h>
	21	#include <linux/pci.h>
7a54f25c	22	#include <linux/pci_hotplug.h>
7c0f6ba6	23	#include <linux/uaccess.h>
1da177e4 LT	24	#include "cpqphp.h"
	25	#include "cpqphp_nvram.h"
	26
	27
	28	#define ROM_INT15_PHY_ADDR 0x0FF859
	29	#define READ_EV 0xD8A4
	30	#define WRITE_EV 0xD8A5
	31
	32	struct register_foo {
	33	union {
	34	unsigned long lword; /* eax */
	35	unsigned short word; /* ax */
	36
	37	struct {
	38	unsigned char low; /* al */
	39	unsigned char high; /* ah */
	40	} byte;
	41	} data;
	42
	43	unsigned char opcode; /* see below */
	44	unsigned long length; /* if the reg. is a pointer, how much data */
	45	} __attribute__ ((packed));
	46
	47	struct all_reg {
	48	struct register_foo eax_reg;
	49	struct register_foo ebx_reg;
	50	struct register_foo ecx_reg;
	51	struct register_foo edx_reg;
	52	struct register_foo edi_reg;
	53	struct register_foo esi_reg;
	54	struct register_foo eflags_reg;
	55	} __attribute__ ((packed));
	56
	57
	58	struct ev_hrt_header {
	59	u8 Version;
	60	u8 num_of_ctrl;
	61	u8 next;
	62	};
	63
	64	struct ev_hrt_ctrl {
	65	u8 bus;
	66	u8 device;
	67	u8 function;
	68	u8 mem_avail;
	69	u8 p_mem_avail;
	70	u8 io_avail;
	71	u8 bus_avail;
	72	u8 next;
	73	};
	74
	75
	76	static u8 evbuffer_init;
	77	static u8 evbuffer_length;
	78	static u8 evbuffer[1024];
	79
	80	static void __iomem *compaq_int15_entry_point;
	81
427438c6 AC	82	/* lock for ordering int15_bios_call() */
427438c6 AC	83	static spinlock_t int15_lock;
1da177e4 LT	84
	85
	86	/* This is a series of function that deals with
427438c6 AC	87	* setting & getting the hotplug resource table in some environment variable.
427438c6 AC	88	*/
1da177e4 LT	89
	90	/*
	91	* We really shouldn't be doing this unless there is a _very_ good reason to!!!
	92	* greg k-h
	93	*/
	94
	95
3c78bc61	96	static u32 add_byte(u32 *p_buffer, u8 value, u32 used, u32 *avail)
1da177e4 LT	97	{
	98	u8 **tByte;
	99
	100	if ((used + 1) > avail)
	101	return(1);
861fefbf	102
ff3ce480 BS	103	((u8 )*p_buffer) = value;
ff3ce480 BS	104	tByte = (u8 **)p_buffer;
1da177e4	105	(*tByte)++;
ff3ce480	106	*used += 1;
1da177e4 LT	107	return(0);
	108	}
	109
	110
3c78bc61	111	static u32 add_dword(u32 *p_buffer, u32 value, u32 used, u32 *avail)
1da177e4 LT	112	{
	113	if ((used + 4) > avail)
	114	return(1);
	115
	116	**p_buffer = value;
	117	(*p_buffer)++;
ff3ce480	118	*used += 4;
1da177e4 LT	119	return(0);
	120	}
	121
	122
	123	/*
	124	* check_for_compaq_ROM
	125	*
	126	* this routine verifies that the ROM OEM string is 'COMPAQ'
	127	*
	128	* returns 0 for non-Compaq ROM, 1 for Compaq ROM
	129	*/
ff3ce480	130	static int check_for_compaq_ROM(void __iomem *rom_start)
1da177e4 LT	131	{
	132	u8 temp1, temp2, temp3, temp4, temp5, temp6;
	133	int result = 0;
	134
	135	temp1 = readb(rom_start + 0xffea + 0);
	136	temp2 = readb(rom_start + 0xffea + 1);
	137	temp3 = readb(rom_start + 0xffea + 2);
	138	temp4 = readb(rom_start + 0xffea + 3);
	139	temp5 = readb(rom_start + 0xffea + 4);
	140	temp6 = readb(rom_start + 0xffea + 5);
	141	if ((temp1 == 'C') &&
	142	(temp2 == 'O') &&
	143	(temp3 == 'M') &&
	144	(temp4 == 'P') &&
	145	(temp5 == 'A') &&
	146	(temp6 == 'Q')) {
	147	result = 1;
	148	}
ff3ce480	149	dbg("%s - returned %d\n", __func__, result);
1da177e4 LT	150	return result;
	151	}
	152
	153
ff3ce480	154	static u32 access_EV(u16 operation, u8 ev_name, u8 buffer, u32 *buf_size)
1da177e4 LT	155	{
	156	unsigned long flags;
	157	int op = operation;
	158	int ret_val;
861fefbf	159
1da177e4 LT	160	if (!compaq_int15_entry_point)
1da177e4 LT	161	return -ENODEV;
861fefbf	162
1da177e4 LT	163	spin_lock_irqsave(&int15_lock, flags);
	164	__asm__ (
	165	"xorl %%ebx,%%ebx\n" \
	166	"xorl %%edx,%%edx\n" \
	167	"pushf\n" \
	168	"push %%cs\n" \
	169	"cli\n" \
	170	"call *%6\n"
	171	: "=c" (*buf_size), "=a" (ret_val)
	172	: "a" (op), "c" (*buf_size), "S" (ev_name),
	173	"D" (buffer), "m" (compaq_int15_entry_point)
	174	: "%ebx", "%edx");
	175	spin_unlock_irqrestore(&int15_lock, flags);
861fefbf	176
1da177e4 LT	177	return((ret_val & 0xFF00) >> 8);
	178	}
	179
	180
	181	/*
	182	* load_HRT
	183	*
	184	* Read the hot plug Resource Table from NVRAM
	185	*/
ff3ce480	186	static int load_HRT(void __iomem *rom_start)
1da177e4 LT	187	{
	188	u32 available;
	189	u32 temp_dword;
	190	u8 temp_byte = 0xFF;
	191	u32 rc;
	192
656f978f	193	if (!check_for_compaq_ROM(rom_start))
1da177e4	194	return -ENODEV;
1da177e4 LT	195
	196	available = 1024;
	197
427438c6	198	/* Now load the EV */
1da177e4 LT	199	temp_dword = available;
	200
	201	rc = access_EV(READ_EV, "CQTHPS", evbuffer, &temp_dword);
	202
	203	evbuffer_length = temp_dword;
	204
427438c6 AC	205	/* We're maintaining the resource lists so write FF to invalidate old
	206	* info
	207	*/
1da177e4 LT	208	temp_dword = 1;
	209
	210	rc = access_EV(WRITE_EV, "CQTHPS", &temp_byte, &temp_dword);
	211
	212	return rc;
	213	}
	214
	215
	216	/*
	217	* store_HRT
	218	*
	219	* Save the hot plug Resource Table in NVRAM
	220	*/
ff3ce480	221	static u32 store_HRT(void __iomem *rom_start)
1da177e4 LT	222	{
	223	u32 *buffer;
	224	u32 *pFill;
	225	u32 usedbytes;
	226	u32 available;
	227	u32 temp_dword;
	228	u32 rc;
	229	u8 loop;
	230	u8 numCtrl = 0;
	231	struct controller *ctrl;
	232	struct pci_resource *resNode;
	233	struct ev_hrt_header *p_EV_header;
	234	struct ev_hrt_ctrl *p_ev_ctrl;
	235
	236	available = 1024;
	237
656f978f	238	if (!check_for_compaq_ROM(rom_start))
1da177e4	239	return(1);
1da177e4	240
ff3ce480	241	buffer = (u32 *) evbuffer;
1da177e4 LT	242
	243	if (!buffer)
	244	return(1);
	245
	246	pFill = buffer;
	247	usedbytes = 0;
	248
	249	p_EV_header = (struct ev_hrt_header *) pFill;
	250
	251	ctrl = cpqhp_ctrl_list;
861fefbf	252
427438c6	253	/* The revision of this structure */
3c78bc61	254	rc = add_byte(&pFill, 1 + ctrl->push_flag, &usedbytes, &available);
1da177e4 LT	255	if (rc)
	256	return(rc);
	257
427438c6	258	/* The number of controllers */
3c78bc61	259	rc = add_byte(&pFill, 1, &usedbytes, &available);
1da177e4 LT	260	if (rc)
	261	return(rc);
	262
	263	while (ctrl) {
	264	p_ev_ctrl = (struct ev_hrt_ctrl *) pFill;
	265
	266	numCtrl++;
	267
427438c6	268	/* The bus number */
3c78bc61	269	rc = add_byte(&pFill, ctrl->bus, &usedbytes, &available);
1da177e4 LT	270	if (rc)
	271	return(rc);
	272
427438c6	273	/* The device Number */
3c78bc61	274	rc = add_byte(&pFill, PCI_SLOT(ctrl->pci_dev->devfn), &usedbytes, &available);
1da177e4 LT	275	if (rc)
	276	return(rc);
	277
427438c6	278	/* The function Number */
3c78bc61	279	rc = add_byte(&pFill, PCI_FUNC(ctrl->pci_dev->devfn), &usedbytes, &available);
1da177e4 LT	280	if (rc)
	281	return(rc);
	282
427438c6	283	/* Skip the number of available entries */
3c78bc61	284	rc = add_dword(&pFill, 0, &usedbytes, &available);
1da177e4 LT	285	if (rc)
	286	return(rc);
	287
427438c6	288	/* Figure out memory Available */
1da177e4 LT	289
	290	resNode = ctrl->mem_head;
	291
	292	loop = 0;
	293
	294	while (resNode) {
ff3ce480	295	loop++;
1da177e4	296
427438c6	297	/* base */
3c78bc61	298	rc = add_dword(&pFill, resNode->base, &usedbytes, &available);
1da177e4 LT	299	if (rc)
	300	return(rc);
	301
427438c6	302	/* length */
3c78bc61	303	rc = add_dword(&pFill, resNode->length, &usedbytes, &available);
1da177e4 LT	304	if (rc)
	305	return(rc);
	306
	307	resNode = resNode->next;
	308	}
	309
427438c6	310	/* Fill in the number of entries */
1da177e4 LT	311	p_ev_ctrl->mem_avail = loop;
1da177e4 LT	312
427438c6	313	/* Figure out prefetchable memory Available */
1da177e4 LT	314
	315	resNode = ctrl->p_mem_head;
	316
	317	loop = 0;
	318
	319	while (resNode) {
ff3ce480	320	loop++;
1da177e4	321
427438c6	322	/* base */
3c78bc61	323	rc = add_dword(&pFill, resNode->base, &usedbytes, &available);
1da177e4 LT	324	if (rc)
	325	return(rc);
	326
427438c6	327	/* length */
3c78bc61	328	rc = add_dword(&pFill, resNode->length, &usedbytes, &available);
1da177e4 LT	329	if (rc)
	330	return(rc);
	331
	332	resNode = resNode->next;
	333	}
	334
427438c6	335	/* Fill in the number of entries */
1da177e4 LT	336	p_ev_ctrl->p_mem_avail = loop;
1da177e4 LT	337
427438c6	338	/* Figure out IO Available */
1da177e4 LT	339
	340	resNode = ctrl->io_head;
	341
	342	loop = 0;
	343
	344	while (resNode) {
ff3ce480	345	loop++;
1da177e4	346
427438c6	347	/* base */
3c78bc61	348	rc = add_dword(&pFill, resNode->base, &usedbytes, &available);
1da177e4 LT	349	if (rc)
	350	return(rc);
	351
427438c6	352	/* length */
3c78bc61	353	rc = add_dword(&pFill, resNode->length, &usedbytes, &available);
1da177e4 LT	354	if (rc)
	355	return(rc);
	356
	357	resNode = resNode->next;
	358	}
	359
427438c6	360	/* Fill in the number of entries */
1da177e4 LT	361	p_ev_ctrl->io_avail = loop;
1da177e4 LT	362
427438c6	363	/* Figure out bus Available */
1da177e4 LT	364
	365	resNode = ctrl->bus_head;
	366
	367	loop = 0;
	368
	369	while (resNode) {
ff3ce480	370	loop++;
1da177e4	371
427438c6	372	/* base */
3c78bc61	373	rc = add_dword(&pFill, resNode->base, &usedbytes, &available);
1da177e4 LT	374	if (rc)
	375	return(rc);
	376
427438c6	377	/* length */
3c78bc61	378	rc = add_dword(&pFill, resNode->length, &usedbytes, &available);
1da177e4 LT	379	if (rc)
	380	return(rc);
	381
	382	resNode = resNode->next;
	383	}
	384
427438c6	385	/* Fill in the number of entries */
1da177e4 LT	386	p_ev_ctrl->bus_avail = loop;
	387
	388	ctrl = ctrl->next;
	389	}
861fefbf	390
1da177e4 LT	391	p_EV_header->num_of_ctrl = numCtrl;
1da177e4 LT	392
427438c6	393	/* Now store the EV */
1da177e4 LT	394
	395	temp_dword = usedbytes;
	396
ff3ce480	397	rc = access_EV(WRITE_EV, "CQTHPS", (u8 *) buffer, &temp_dword);
1da177e4 LT	398
	399	dbg("usedbytes = 0x%x, length = 0x%x\n", usedbytes, temp_dword);
	400
	401	evbuffer_length = temp_dword;
	402
	403	if (rc) {
	404	err(msg_unable_to_save);
	405	return(1);
	406	}
	407
	408	return(0);
	409	}
	410
	411
ff3ce480	412	void compaq_nvram_init(void __iomem *rom_start)
1da177e4	413	{
656f978f	414	if (rom_start)
1da177e4	415	compaq_int15_entry_point = (rom_start + ROM_INT15_PHY_ADDR - ROM_PHY_ADDR);
656f978f	416
1da177e4 LT	417	dbg("int15 entry = %p\n", compaq_int15_entry_point);
	418
	419	/* initialize our int15 lock */
	420	spin_lock_init(&int15_lock);
	421	}
	422
	423
ff3ce480	424	int compaq_nvram_load(void __iomem rom_start, struct controller ctrl)
1da177e4 LT	425	{
	426	u8 bus, device, function;
	427	u8 nummem, numpmem, numio, numbus;
	428	u32 rc;
	429	u8 *p_byte;
	430	struct pci_resource *mem_node;
	431	struct pci_resource *p_mem_node;
	432	struct pci_resource *io_node;
	433	struct pci_resource *bus_node;
	434	struct ev_hrt_ctrl *p_ev_ctrl;
	435	struct ev_hrt_header *p_EV_header;
	436
	437	if (!evbuffer_init) {
427438c6	438	/* Read the resource list information in from NVRAM */
1da177e4	439	if (load_HRT(rom_start))
ff3ce480	440	memset(evbuffer, 0, 1024);
1da177e4 LT	441
	442	evbuffer_init = 1;
	443	}
	444
427438c6	445	/* If we saved information in NVRAM, use it now */
1da177e4 LT	446	p_EV_header = (struct ev_hrt_header *) evbuffer;
1da177e4 LT	447
427438c6 AC	448	/* The following code is for systems where version 1.0 of this
	449	* driver has been loaded, but doesn't support the hardware.
	450	* In that case, the driver would incorrectly store something
	451	* in NVRAM.
	452	*/
1da177e4 LT	453	if ((p_EV_header->Version == 2) \|\|
	454	((p_EV_header->Version == 1) && !ctrl->push_flag)) {
	455	p_byte = &(p_EV_header->next);
	456
	457	p_ev_ctrl = (struct ev_hrt_ctrl *) &(p_EV_header->next);
	458
	459	p_byte += 3;
	460
ff3ce480	461	if (p_byte > ((u8 *)p_EV_header + evbuffer_length))
1da177e4 LT	462	return 2;
	463
	464	bus = p_ev_ctrl->bus;
	465	device = p_ev_ctrl->device;
	466	function = p_ev_ctrl->function;
	467
	468	while ((bus != ctrl->bus) \|\|
861fefbf	469	(device != PCI_SLOT(ctrl->pci_dev->devfn)) \|\|
1da177e4 LT	470	(function != PCI_FUNC(ctrl->pci_dev->devfn))) {
	471	nummem = p_ev_ctrl->mem_avail;
	472	numpmem = p_ev_ctrl->p_mem_avail;
	473	numio = p_ev_ctrl->io_avail;
	474	numbus = p_ev_ctrl->bus_avail;
	475
	476	p_byte += 4;
	477
ff3ce480	478	if (p_byte > ((u8 *)p_EV_header + evbuffer_length))
1da177e4 LT	479	return 2;
1da177e4 LT	480
427438c6	481	/* Skip forward to the next entry */
1da177e4 LT	482	p_byte += (nummem + numpmem + numio + numbus) * 8;
1da177e4 LT	483
ff3ce480	484	if (p_byte > ((u8 *)p_EV_header + evbuffer_length))
1da177e4 LT	485	return 2;
	486
	487	p_ev_ctrl = (struct ev_hrt_ctrl *) p_byte;
	488
	489	p_byte += 3;
	490
ff3ce480	491	if (p_byte > ((u8 *)p_EV_header + evbuffer_length))
1da177e4 LT	492	return 2;
	493
	494	bus = p_ev_ctrl->bus;
	495	device = p_ev_ctrl->device;
	496	function = p_ev_ctrl->function;
	497	}
	498
	499	nummem = p_ev_ctrl->mem_avail;
	500	numpmem = p_ev_ctrl->p_mem_avail;
	501	numio = p_ev_ctrl->io_avail;
	502	numbus = p_ev_ctrl->bus_avail;
	503
	504	p_byte += 4;
	505
ff3ce480	506	if (p_byte > ((u8 *)p_EV_header + evbuffer_length))
1da177e4 LT	507	return 2;
	508
	509	while (nummem--) {
5cbded58	510	mem_node = kmalloc(sizeof(struct pci_resource), GFP_KERNEL);
1da177e4 LT	511
	512	if (!mem_node)
	513	break;
	514
ff3ce480 BS	515	mem_node->base = (u32 )p_byte;
ff3ce480 BS	516	dbg("mem base = %8.8x\n", mem_node->base);
1da177e4 LT	517	p_byte += 4;
1da177e4 LT	518
ff3ce480	519	if (p_byte > ((u8 *)p_EV_header + evbuffer_length)) {
1da177e4 LT	520	kfree(mem_node);
	521	return 2;
	522	}
	523
ff3ce480 BS	524	mem_node->length = (u32 )p_byte;
ff3ce480 BS	525	dbg("mem length = %8.8x\n", mem_node->length);
1da177e4 LT	526	p_byte += 4;
1da177e4 LT	527
ff3ce480	528	if (p_byte > ((u8 *)p_EV_header + evbuffer_length)) {
1da177e4 LT	529	kfree(mem_node);
	530	return 2;
	531	}
	532
	533	mem_node->next = ctrl->mem_head;
	534	ctrl->mem_head = mem_node;
	535	}
	536
	537	while (numpmem--) {
5cbded58	538	p_mem_node = kmalloc(sizeof(struct pci_resource), GFP_KERNEL);
1da177e4 LT	539
	540	if (!p_mem_node)
	541	break;
	542
ff3ce480 BS	543	p_mem_node->base = (u32 )p_byte;
ff3ce480 BS	544	dbg("pre-mem base = %8.8x\n", p_mem_node->base);
1da177e4 LT	545	p_byte += 4;
1da177e4 LT	546
ff3ce480	547	if (p_byte > ((u8 *)p_EV_header + evbuffer_length)) {
1da177e4 LT	548	kfree(p_mem_node);
	549	return 2;
	550	}
	551
ff3ce480 BS	552	p_mem_node->length = (u32 )p_byte;
ff3ce480 BS	553	dbg("pre-mem length = %8.8x\n", p_mem_node->length);
1da177e4 LT	554	p_byte += 4;
1da177e4 LT	555
ff3ce480	556	if (p_byte > ((u8 *)p_EV_header + evbuffer_length)) {
1da177e4 LT	557	kfree(p_mem_node);
	558	return 2;
	559	}
	560
	561	p_mem_node->next = ctrl->p_mem_head;
	562	ctrl->p_mem_head = p_mem_node;
	563	}
	564
	565	while (numio--) {
5cbded58	566	io_node = kmalloc(sizeof(struct pci_resource), GFP_KERNEL);
1da177e4 LT	567
	568	if (!io_node)
	569	break;
	570
ff3ce480 BS	571	io_node->base = (u32 )p_byte;
ff3ce480 BS	572	dbg("io base = %8.8x\n", io_node->base);
1da177e4 LT	573	p_byte += 4;
1da177e4 LT	574
ff3ce480	575	if (p_byte > ((u8 *)p_EV_header + evbuffer_length)) {
1da177e4 LT	576	kfree(io_node);
	577	return 2;
	578	}
	579
ff3ce480 BS	580	io_node->length = (u32 )p_byte;
ff3ce480 BS	581	dbg("io length = %8.8x\n", io_node->length);
1da177e4 LT	582	p_byte += 4;
1da177e4 LT	583
ff3ce480	584	if (p_byte > ((u8 *)p_EV_header + evbuffer_length)) {
1da177e4 LT	585	kfree(io_node);
	586	return 2;
	587	}
	588
	589	io_node->next = ctrl->io_head;
	590	ctrl->io_head = io_node;
	591	}
	592
	593	while (numbus--) {
5cbded58	594	bus_node = kmalloc(sizeof(struct pci_resource), GFP_KERNEL);
1da177e4 LT	595
	596	if (!bus_node)
	597	break;
	598
ff3ce480	599	bus_node->base = (u32 )p_byte;
1da177e4 LT	600	p_byte += 4;
1da177e4 LT	601
ff3ce480	602	if (p_byte > ((u8 *)p_EV_header + evbuffer_length)) {
1da177e4 LT	603	kfree(bus_node);
	604	return 2;
	605	}
	606
ff3ce480	607	bus_node->length = (u32 )p_byte;
1da177e4 LT	608	p_byte += 4;
1da177e4 LT	609
ff3ce480	610	if (p_byte > ((u8 *)p_EV_header + evbuffer_length)) {
1da177e4 LT	611	kfree(bus_node);
	612	return 2;
	613	}
	614
	615	bus_node->next = ctrl->bus_head;
	616	ctrl->bus_head = bus_node;
	617	}
	618
427438c6 AC	619	/* If all of the following fail, we don't have any resources for
	620	* hot plug add
	621	*/
1da177e4 LT	622	rc = 1;
	623	rc &= cpqhp_resource_sort_and_combine(&(ctrl->mem_head));
	624	rc &= cpqhp_resource_sort_and_combine(&(ctrl->p_mem_head));
	625	rc &= cpqhp_resource_sort_and_combine(&(ctrl->io_head));
	626	rc &= cpqhp_resource_sort_and_combine(&(ctrl->bus_head));
	627
	628	if (rc)
	629	return(rc);
	630	} else {
861fefbf	631	if ((evbuffer[0] != 0) && (!ctrl->push_flag))
1da177e4 LT	632	return 1;
	633	}
	634
	635	return 0;
	636	}
	637
861fefbf	638
ff3ce480	639	int compaq_nvram_store(void __iomem *rom_start)
1da177e4 LT	640	{
	641	int rc = 1;
	642
	643	if (rom_start == NULL)
	644	return -ENODEV;
	645
	646	if (evbuffer_init) {
	647	rc = store_HRT(rom_start);
656f978f	648	if (rc)
1da177e4	649	err(msg_unable_to_save);
1da177e4 LT	650	}
	651	return rc;
	652	}
	653