[people/ms/linux.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/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 <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;

/* 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)
{
#ifndef CONFIG_PAX_KERNEXEC
	if (rom_start)
		compaq_int15_entry_point = (rom_start + ROM_INT15_PHY_ADDR - ROM_PHY_ADDR);
#endif

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