patch-2.4.21 linux-2.4.21/drivers/net/sk98lin/skvpd.c

Next file: linux-2.4.21/drivers/net/sk98lin/skxmac2.c
Previous file: linux-2.4.21/drivers/net/sk98lin/sktimer.c
Back to the patch index
Back to the overall index

diff -urN linux-2.4.20/drivers/net/sk98lin/skvpd.c linux-2.4.21/drivers/net/sk98lin/skvpd.c
@@ -2,16 +2,15 @@
  *
  * Name:	skvpd.c
  * Project:	GEnesis, PCI Gigabit Ethernet Adapter
- * Version:	$Revision: 1.26 $
- * Date:	$Date: 2000/06/13 08:00:01 $
+ * Version:	$Revision: 1.32 $
+ * Date:	$Date: 2002/10/14 16:04:29 $
  * Purpose:	Shared software to read and write VPD data
  *
  ******************************************************************************/
 
 /******************************************************************************
  *
- *	(C)Copyright 1998,1999 SysKonnect,
- *	a business unit of Schneider & Koch & Co. Datensysteme GmbH.
+ *	(C)Copyright 1998-2002 SysKonnect GmbH.
  *
  *	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
@@ -27,6 +26,32 @@
  * History:
  *
  *	$Log: skvpd.c,v $
+ *	Revision 1.32  2002/10/14 16:04:29  rschmidt
+ *	Added saving of VPD ROM Size from PCI_OUR_REG_2
+ *	Avoid reading of PCI_OUR_REG_2 in VpdTransferBlock()
+ *	Editorial changes
+ *	
+ *	Revision 1.31  2002/09/10 09:21:32  mkarl
+ *	Replaced all if(GIChipId == CHIP_ID_GENESIS) with new entry GIGenesis
+ *	
+ *	Revision 1.30  2002/09/09 14:43:03  mkarl
+ *	changes for diagnostics in order to read VPD data before the adapter
+ *	has been initialized
+ *	editorial changes
+ *	
+ *	Revision 1.29  2002/07/26 13:20:43  mkarl
+ *	added Yukon support
+ *	save size of VPD in pAC->vpd.vpd_size
+ *	
+ *	Revision 1.28  2002/04/02 15:31:47  afischer
+ *	Bug fix in VpdWait()
+ *	
+ *	Revision 1.27  2000/08/10 11:29:06  rassmann
+ *	Editorial changes.
+ *	Preserving 32-bit alignment in structs for the adapter context.
+ *	Removed unused function VpdWriteDword() (#if 0).
+ *	Made VpdReadKeyword() available for SKDIAG only.
+ *	
  *	Revision 1.26  2000/06/13 08:00:01  mkarl
  *	additional cast to avoid compile problems in 64 bit environment
  *	
@@ -66,7 +91,7 @@
  *	
  *	Revision 1.14  1998/10/28 07:20:38  gklug
  *	chg: Interface functions to use IoC as parameter as well
- *	fix: VpdRead/WriteDWord now return SK_U32
+ *	fix: VpdRead/WriteDWord now returns SK_U32
  *	chg: VPD_IN/OUT names conform to SK_IN/OUT
  *	add: usage of VPD_IN/OUT8 macros
  *	add: VpdRead/Write Stream functions to r/w a stream of data
@@ -88,7 +113,7 @@
  *	Revision 1.9  1998/09/16 07:33:52  malthoff
  *	remove memcmp() by SK_MEMCMP and
  *	memcpy() by SK_MEMCPY() to be
- *	independant from the 'C' Standard Library.
+ *	independent from the 'C' Standard Library.
  *	
  *	Revision 1.8  1998/08/19 12:52:35  malthoff
  *	compiler fix: use SK_VPD_KEY instead of S_VPD.
@@ -124,7 +149,7 @@
 	Please refer skvpd.txt for infomation how to include this module
  */
 static const char SysKonnectFileId[] =
-	"@(#)$Id: skvpd.c,v 1.26 2000/06/13 08:00:01 mkarl Exp $ (C) SK" ;
+	"@(#)$Id: skvpd.c,v 1.32 2002/10/14 16:04:29 rschmidt Exp $ (C) SK";
 
 #include "h/skdrv1st.h"
 #include "h/sktypes.h"
@@ -137,46 +162,58 @@
 #ifndef SK_KR_PROTO
 static SK_VPD_PARA	*vpd_find_para(
 	SK_AC	*pAC,
-	char		*key,
-	SK_VPD_PARA *p) ;
+	char	*key,
+	SK_VPD_PARA *p);
 #else	/* SK_KR_PROTO */
-static SK_VPD_PARA	*vpd_find_para() ;
+static SK_VPD_PARA	*vpd_find_para();
 #endif	/* SK_KR_PROTO */
 
 /*
- * waits for a completetion of a VPD transfer
+ * waits for a completion of a VPD transfer
  * The VPD transfer must complete within SK_TICKS_PER_SEC/16
  *
  * returns	0:	success, transfer completes
  *		error	exit(9) with a error message
  */
 static int	VpdWait(
-SK_AC		*pAC,	/* Adapters context */
-SK_IOC		IoC,	/* IO Context */
+SK_AC	*pAC,	/* Adapters context */
+SK_IOC	IoC,	/* IO Context */
 int		event)	/* event to wait for (VPD_READ / VPD_write) completion*/
 {
-	SK_U64	start_time ;
-	SK_U16	state ;
+	SK_U64	start_time;
+	SK_U16	state;
 
-	SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_CTRL,
-		("vpd wait for %s\n",event?"Write":"Read")) ;
-	start_time = SkOsGetTime(pAC) ;
+	SK_DBG_MSG(pAC,SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
+		("VPD wait for %s\n", event?"Write":"Read"));
+	start_time = SkOsGetTime(pAC);
 	do {
 		if (SkOsGetTime(pAC) - start_time > SK_TICKS_PER_SEC/16) {
-			VPD_STOP(pAC,IoC) ;
-			SK_DBG_MSG(pAC,SK_DBGMOD_VPD,
-				SK_DBGCAT_FATAL|SK_DBGCAT_ERR,
-				("ERROR:vpd wait timeout\n")) ;
-			return(1) ;
-		}
-		VPD_IN16(pAC,IoC,PCI_VPD_ADR_REG,&state) ;
-		SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_CTRL,
-			("state = %x, event %x\n",state,event)) ;
-	} while((int)(state & PCI_VPD_FLAG) == event) ;
 
-	return(0) ;
+			/* Bug fix AF: Thu Mar 28 2002
+			 * Do not call: VPD_STOP(pAC, IoC);
+			 * A pending VPD read cycle can not be aborted by writing
+			 * VPD_WRITE to the PCI_VPD_ADR_REG (VPD address register).
+			 * Although the write threshold in the OUR-register protects
+			 * VPD read only space from being overwritten this does not
+			 * protect a VPD read from being `converted` into a VPD write
+			 * operation (on the fly). As a consequence the VPD_STOP would
+			 * delete VPD read only data. In case of any problems with the
+			 * I2C bus we exit the loop here. The I2C read operation can
+			 * not be aborted except by a reset (->LR).
+			 */
+			SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_FATAL | SK_DBGCAT_ERR,
+				("ERROR:VPD wait timeout\n"));
+			return(1);
+		}
+		VPD_IN16(pAC, IoC, PCI_VPD_ADR_REG, &state);
+		SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
+			("state = %x, event %x\n",state,event));
+	} while((int)(state & PCI_VPD_FLAG) == event);
+
+	return(0);
 }
 
+#ifdef SKDIAG
 
 /*
  * Read the dword at address 'addr' from the VPD EEPROM.
@@ -188,32 +225,37 @@
  *
  * Returns the data read.
  */
-SK_U32		VpdReadDWord(
-SK_AC		*pAC,	/* Adapters context */
-SK_IOC		IoC,	/* IO Context */
+SK_U32 VpdReadDWord(
+SK_AC	*pAC,	/* Adapters context */
+SK_IOC	IoC,	/* IO Context */
 int		addr)	/* VPD address */
 {
-	SK_U32	Rtv ;
+	SK_U32	Rtv;
 
 	/* start VPD read */
-	SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_CTRL,
-		("vpd read dword at 0x%x\n",addr)) ;
-	addr &= ~VPD_WRITE ;		/* ensure the R/W bit is set to read */
+	SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
+		("VPD read dword at 0x%x\n",addr));
+	addr &= ~VPD_WRITE;		/* ensure the R/W bit is set to read */
 
-	VPD_OUT16(pAC,IoC,PCI_VPD_ADR_REG, (SK_U16) addr) ;
+	VPD_OUT16(pAC, IoC, PCI_VPD_ADR_REG, (SK_U16)addr);
 
 	/* ignore return code here */
-	(void)VpdWait(pAC,IoC,VPD_READ) ;
+	(void)VpdWait(pAC, IoC, VPD_READ);
 
 	/* Don't swap here, it's a data stream of bytes */
-	Rtv = 0 ;
+	Rtv = 0;
 
-	VPD_IN32(pAC,IoC,PCI_VPD_DAT_REG,&Rtv) ;
-	SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_CTRL,
-		("vpd read dword data = 0x%x\n",Rtv)) ;
-	return (Rtv) ;
+	VPD_IN32(pAC, IoC, PCI_VPD_DAT_REG, &Rtv);
+	
+	SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
+		("VPD read dword data = 0x%x\n",Rtv));
+	return(Rtv);
 }
 
+#endif	/* SKDIAG */
+
+#if 0
+
 /*
 	Write the dword 'data' at address 'addr' into the VPD EEPROM, and
 	verify that the data is written.
@@ -233,43 +275,43 @@
 
 
  Returns	0:	success
-		1:	error,	I2C transfer does not terminate
-		2:	error,	data verify error
+			1:	error,	I2C transfer does not terminate
+			2:	error,	data verify error
 
  */
-#if 0 /* Unused at the moment */
-static int	VpdWriteDWord(
-SK_AC		*pAC,	/* pAC pointer */
-SK_IOC		IoC,	/* IO Context */
+static int VpdWriteDWord(
+SK_AC	*pAC,	/* pAC pointer */
+SK_IOC	IoC,	/* IO Context */
 int		addr,	/* VPD address */
-SK_U32		data)	/* VPD data to write */
+SK_U32	data)	/* VPD data to write */
 {
 	/* start VPD write */
 	/* Don't swap here, it's a data stream of bytes */
-	SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_CTRL,
-		("vpd write dword at addr 0x%x, data = 0x%x\n",addr,data)) ;
-	VPD_OUT32(pAC,IoC,PCI_VPD_DAT_REG, (SK_U32)data) ;
+	SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
+		("VPD write dword at addr 0x%x, data = 0x%x\n",addr,data));
+	VPD_OUT32(pAC, IoC, PCI_VPD_DAT_REG, (SK_U32)data);
 	/* But do it here */
-	addr |= VPD_WRITE ;
+	addr |= VPD_WRITE;
 
-	VPD_OUT16(pAC,IoC,PCI_VPD_ADR_REG, (SK_U16)(addr | VPD_WRITE)) ;
+	VPD_OUT16(pAC, IoC, PCI_VPD_ADR_REG, (SK_U16)(addr | VPD_WRITE));
 
 	/* this may take up to 10,6 ms */
-	if (VpdWait(pAC,IoC,VPD_WRITE)) {
-		SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR,
-			("Write Timed Out\n")) ;
-		return(1) ;
-	} ;
+	if (VpdWait(pAC, IoC, VPD_WRITE)) {
+		SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
+			("Write Timed Out\n"));
+		return(1);
+	};
 
 	/* verify data */
-	if (VpdReadDWord(pAC,IoC,addr) != data) {
-		SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR|SK_DBGCAT_FATAL,
-			("Data Verify Error\n")) ;
-		return(2) ;
+	if (VpdReadDWord(pAC, IoC, addr) != data) {
+		SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
+			("Data Verify Error\n"));
+		return(2);
 	}
-	return(0) ;
-}
-#endif
+	return(0);
+}	/* VpdWriteDWord */
+
+#endif	/* 0 */
 
 /*
  *	Read one Stream of 'len' bytes of VPD data, starting at 'addr' from
@@ -278,88 +320,85 @@
  * Returns number of bytes read / written.
  */
 static int	VpdWriteStream(
-SK_AC		*pAC,	/* Adapters context */
-SK_IOC		IoC,	/* IO Context */
-char		*buf,	/* data buffer */
+SK_AC	*pAC,	/* Adapters context */
+SK_IOC	IoC,	/* IO Context */
+char	*buf,	/* data buffer */
 int		Addr,	/* VPD start address */
 int		Len)	/* number of bytes to read / to write */
 {
-	int		i ;
-	int		j ;
-	SK_U16		AdrReg ;
-	int		Rtv ;
-	SK_U8		* pComp;	/* Compare pointer */
-	SK_U8		Data ;		/* Input Data for Compare */
+	int		i;
+	int		j;
+	SK_U16	AdrReg;
+	int		Rtv;
+	SK_U8	* pComp;	/* Compare pointer */
+	SK_U8	Data;		/* Input Data for Compare */
 
 	/* Init Compare Pointer */
 	pComp = (SK_U8 *) buf;
 
-	for (i=0; i < Len; i ++, buf++) {
+	for (i = 0; i < Len; i++, buf++) {
 		if ((i%sizeof(SK_U32)) == 0) {
 			/*
 			 * At the begin of each cycle read the Data Reg
 			 * So it is initialized even if only a few bytes
 			 * are written.
 			 */
-			AdrReg = (SK_U16) Addr ;
-			AdrReg &= ~VPD_WRITE ;	/* READ operation */
+			AdrReg = (SK_U16) Addr;
+			AdrReg &= ~VPD_WRITE;	/* READ operation */
 
-			VPD_OUT16(pAC,IoC,PCI_VPD_ADR_REG, AdrReg) ;
+			VPD_OUT16(pAC, IoC, PCI_VPD_ADR_REG, AdrReg);
 
-			/* ignore return code here */
-			Rtv = VpdWait(pAC,IoC,VPD_READ) ;
+			/* Wait for termination */
+			Rtv = VpdWait(pAC, IoC, VPD_READ);
 			if (Rtv != 0) {
-				return(i) ;
+				return(i);
 			}
 		}
 
 		/* Write current Byte */
-		VPD_OUT8(pAC,IoC,PCI_VPD_DAT_REG+(i%sizeof(SK_U32)),
-				*(SK_U8*)buf) ;
+		VPD_OUT8(pAC, IoC, PCI_VPD_DAT_REG + (i%sizeof(SK_U32)),
+				*(SK_U8*)buf);
 
 		if (((i%sizeof(SK_U32)) == 3) || (i == (Len - 1))) {
 			/* New Address needs to be written to VPD_ADDR reg */
-			AdrReg = (SK_U16) Addr ;
+			AdrReg = (SK_U16) Addr;
 			Addr += sizeof(SK_U32);
-			AdrReg |= VPD_WRITE ;	/* WRITE operation */
+			AdrReg |= VPD_WRITE;	/* WRITE operation */
 
-			VPD_OUT16(pAC,IoC,PCI_VPD_ADR_REG, AdrReg) ;
+			VPD_OUT16(pAC, IoC, PCI_VPD_ADR_REG, AdrReg);
 
 			/* Wait for termination */
-			Rtv = VpdWait(pAC,IoC,VPD_WRITE) ;
+			Rtv = VpdWait(pAC, IoC, VPD_WRITE);
 			if (Rtv != 0) {
-				SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR,
-					("Write Timed Out\n")) ;
-				return(i - (i%sizeof(SK_U32))) ;
+				SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
+					("Write Timed Out\n"));
+				return(i - (i%sizeof(SK_U32)));
 			}
 
 			/*
 			 * Now re-read to verify
 			 */
-			AdrReg &= ~VPD_WRITE ;	/* READ operation */
+			AdrReg &= ~VPD_WRITE;	/* READ operation */
 
-			VPD_OUT16(pAC,IoC,PCI_VPD_ADR_REG, AdrReg) ;
+			VPD_OUT16(pAC, IoC, PCI_VPD_ADR_REG, AdrReg);
 
 			/* Wait for termination */
-			Rtv = VpdWait(pAC,IoC,VPD_READ) ;
+			Rtv = VpdWait(pAC, IoC, VPD_READ);
 			if (Rtv != 0) {
-				SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR,
-					("Verify Timed Out\n")) ;
-				return(i - (i%sizeof(SK_U32))) ;
+				SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
+					("Verify Timed Out\n"));
+				return(i - (i%sizeof(SK_U32)));
 			}
 
-			for (j = 0; j <= (int) (i%sizeof(SK_U32));
-				j ++, pComp ++ ) {
-				VPD_IN8(pAC,IoC,PCI_VPD_DAT_REG+j, &Data) ;
+			for (j = 0; j <= (int)(i%sizeof(SK_U32)); j++, pComp++) {
+				VPD_IN8(pAC, IoC, PCI_VPD_DAT_REG + j, &Data);
 				if (Data != *pComp) {
 					/* Verify Error */
-					SK_DBG_MSG(pAC,SK_DBGMOD_VPD,
-						SK_DBGCAT_ERR,
+					SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
 						("WriteStream Verify Error\n"));
 					return(i - (i%sizeof(SK_U32)) + j);
 				}
 			}
-
 		}
 	}
 
@@ -374,85 +413,85 @@
  * Returns number of bytes read / written.
  */
 static int	VpdReadStream(
-SK_AC		*pAC,	/* Adapters context */
-SK_IOC		IoC,	/* IO Context */
-char		*buf,	/* data buffer */
+SK_AC	*pAC,	/* Adapters context */
+SK_IOC	IoC,	/* IO Context */
+char	*buf,	/* data buffer */
 int		Addr,	/* VPD start address */
 int		Len)	/* number of bytes to read / to write */
 {
-	int		i ;
-	SK_U16		AdrReg ;
-	int		Rtv ;
+	int		i;
+	SK_U16	AdrReg;
+	int		Rtv;
 
-	for (i=0; i < Len; i ++, buf++) {
+	for (i = 0; i < Len; i++, buf++) {
 		if ((i%sizeof(SK_U32)) == 0) {
 			/* New Address needs to be written to VPD_ADDR reg */
-			AdrReg = (SK_U16) Addr ;
+			AdrReg = (SK_U16) Addr;
 			Addr += sizeof(SK_U32);
-			AdrReg &= ~VPD_WRITE ;	/* READ operation */
+			AdrReg &= ~VPD_WRITE;	/* READ operation */
 
-			VPD_OUT16(pAC,IoC,PCI_VPD_ADR_REG, AdrReg) ;
+			VPD_OUT16(pAC, IoC, PCI_VPD_ADR_REG, AdrReg);
 
-			/* ignore return code here */
-			Rtv = VpdWait(pAC,IoC,VPD_READ) ;
+			/* Wait for termination */
+			Rtv = VpdWait(pAC, IoC, VPD_READ);
 			if (Rtv != 0) {
-				return(i) ;
+				return(i);
 			}
-
 		}
-		VPD_IN8(pAC,IoC,PCI_VPD_DAT_REG+(i%sizeof(SK_U32)),
-			(SK_U8 *)buf) ;
+		VPD_IN8(pAC, IoC, PCI_VPD_DAT_REG + (i%sizeof(SK_U32)),
+			(SK_U8 *)buf);
 	}
 
-	return(Len) ;
+	return(Len);
 }
 
 /*
- *	Read ore wirtes 'len' bytes of VPD data, starting at 'addr' from
+ *	Read ore writes 'len' bytes of VPD data, starting at 'addr' from
  *	or to the I2C EEPROM.
  *
  * Returns number of bytes read / written.
  */
 static int	VpdTransferBlock(
-SK_AC		*pAC,	/* Adapters context */
-SK_IOC		IoC,	/* IO Context */
-char		*buf,	/* data buffer */
+SK_AC	*pAC,	/* Adapters context */
+SK_IOC	IoC,	/* IO Context */
+char	*buf,	/* data buffer */
 int		addr,	/* VPD start address */
 int		len,	/* number of bytes to read / to write */
 int		dir)	/* transfer direction may be VPD_READ or VPD_WRITE */
 {
-	int		Rtv ;	/* Return value */
-	int		vpd_rom_size ;
-	SK_U32		our_reg2 ;
-
-	SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_CTRL,
-		("vpd %s block, addr = 0x%x, len = %d\n",
-		dir?"write":"read",addr,len)) ;
+	int		Rtv;	/* Return value */
+	int		vpd_rom_size;
+
+	SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
+		("VPD %s block, addr = 0x%x, len = %d\n",
+		dir ? "write" : "read", addr, len));
 
 	if (len == 0)
-		return (0) ;
+		return(0);
 
-	VPD_IN32(pAC,IoC,PCI_OUR_REG_2,&our_reg2) ;
-	vpd_rom_size = 256 << ((our_reg2 & PCI_VPD_ROM_SZ) >> 14);
+	vpd_rom_size = pAC->vpd.rom_size;
+	
 	if (addr > vpd_rom_size - 4) {
-		SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR|SK_DBGCAT_FATAL,
+		SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
 			("Address error: 0x%x, exp. < 0x%x\n",
-			addr, vpd_rom_size - 4)) ;
-		return (0) ;
+			addr, vpd_rom_size - 4));
+		return(0);
 	}
+	
 	if (addr + len > vpd_rom_size) {
-		len = vpd_rom_size - addr ;
-		SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR,
-			("Warning: len was cut to %d\n",len)) ;
+		len = vpd_rom_size - addr;
+		SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
+			("Warning: len was cut to %d\n", len));
 	}
 
 	if (dir == VPD_READ) {
 		Rtv = VpdReadStream(pAC, IoC, buf, addr, len);
-	} else {
+	}
+	else {
 		Rtv = VpdWriteStream(pAC, IoC, buf, addr, len);
 	}
 
-	return (Rtv) ;
+	return(Rtv);
 }
 
 #ifdef SKDIAG
@@ -463,13 +502,13 @@
  * Returns number of bytes read.
  */
 int		VpdReadBlock(
-SK_AC		*pAC,	/* pAC pointer */
-SK_IOC		IoC,	/* IO Context */
-char		*buf,	/* buffer were the data should be stored */
+SK_AC	*pAC,	/* pAC pointer */
+SK_IOC	IoC,	/* IO Context */
+char	*buf,	/* buffer were the data should be stored */
 int		addr,	/* start reading at the VPD address */
 int		len)	/* number of bytes to read */
 {
-	return (VpdTransferBlock(pAC, IoC, buf, addr, len, VPD_READ)) ;
+	return(VpdTransferBlock(pAC, IoC, buf, addr, len, VPD_READ));
 }
 
 /*
@@ -478,13 +517,13 @@
  * Returns number of bytes writes.
  */
 int		VpdWriteBlock(
-SK_AC		*pAC,	/* pAC pointer */
-SK_IOC		IoC,	/* IO Context */
-char		*buf,	/* buffer, holds the data to write */
+SK_AC	*pAC,	/* pAC pointer */
+SK_IOC	IoC,	/* IO Context */
+char	*buf,	/* buffer, holds the data to write */
 int		addr,	/* start writing at the VPD address */
 int		len)	/* number of bytes to write */
 {
-	return (VpdTransferBlock(pAC, IoC, buf, addr, len, VPD_WRITE)) ;
+	return(VpdTransferBlock(pAC, IoC, buf, addr, len, VPD_WRITE));
 }
 #endif	/* SKDIAG */
 
@@ -498,72 +537,112 @@
  *		1:	fatal VPD error
  */
 static int	VpdInit(
-SK_AC		*pAC,	/* Adapters context */
-SK_IOC		IoC)	/* IO Context */
+SK_AC	*pAC,	/* Adapters context */
+SK_IOC	IoC)	/* IO Context */
 {
-	SK_VPD_PARA *r, rp ;	/* RW or RV */
-	int		i ;
-	unsigned char	x ;
+	SK_VPD_PARA *r, rp;	/* RW or RV */
+	int		i;
+	unsigned char	x;
+	int		vpd_size;
+	SK_U16	word;
+	SK_U32	our_reg2;
+
+	SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_INIT, ("VpdInit .. "));
+	
+	VPD_IN16(pAC, IoC, PCI_DEVICE_ID, &word);
+	
+	VPD_IN32(pAC, IoC, PCI_OUR_REG_2, &our_reg2);
+	
+	pAC->vpd.rom_size = 256 << ((our_reg2 & PCI_VPD_ROM_SZ) >> 14);
+	
+	/*
+	 * this function might get used before the hardware is initialized
+	 * therefore we cannot always trust in GIChipId
+	 */
+	if (((pAC->vpd.v.vpd_status & VPD_VALID) == 0 &&
+		word == VPD_PCI_ID_YUKON) ||
+		((pAC->vpd.v.vpd_status & VPD_VALID) != 0 &&
+		!(pAC->GIni.GIGenesis))) {
+
+		/* for Yukon the VPD size is always 256 */
+		vpd_size = VPD_SIZE_YUKON;
+	}
+	else {
+		/* Genesis uses the maximum ROM size up to 512 for VPD */
+		if (pAC->vpd.rom_size > VPD_SIZE_GENESIS) {
+			vpd_size = VPD_SIZE_GENESIS;
+		}
+		else {
+			vpd_size = pAC->vpd.rom_size;
+		}
+	}
 
-	SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_INIT,("VpdInit .. ")) ;
 	/* read the VPD data into the VPD buffer */
-	if (VpdTransferBlock(pAC,IoC,pAC->vpd.vpd_buf,0,VPD_SIZE,VPD_READ)
-		!= VPD_SIZE) {
+	if (VpdTransferBlock(pAC, IoC, pAC->vpd.vpd_buf, 0, vpd_size, VPD_READ)
+		!= vpd_size) {
 
-		SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR,
-			("Block Read Error\n")) ;
-		return(1) ;
+		SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
+			("Block Read Error\n"));
+		return(1);
 	}
+	
+	pAC->vpd.vpd_size = vpd_size;
 
 	/* find the end tag of the RO area */
-	if (!(r = vpd_find_para(pAC,VPD_RV,&rp))) {
-		SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
-			("Encoding Error: RV Tag not found\n")) ;
-		return (1) ;
+	if (!(r = vpd_find_para(pAC, VPD_RV, &rp))) {
+		SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
+			("Encoding Error: RV Tag not found\n"));
+		return(1);
 	}
-	if (r->p_val + r->p_len > pAC->vpd.vpd_buf + VPD_SIZE/2) {
+	
+	if (r->p_val + r->p_len > pAC->vpd.vpd_buf + vpd_size/2) {
 		SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
-			("Encoding Error: Invalid VPD struct size\n")) ;
-		return (1) ;
+			("Encoding Error: Invalid VPD struct size\n"));
+		return(1);
 	}
-	pAC->vpd.v.vpd_free_ro = r->p_len - 1 ;
+	pAC->vpd.v.vpd_free_ro = r->p_len - 1;
 
 	/* test the checksum */
-	for (i = 0, x = 0; (unsigned)i<=(unsigned)VPD_SIZE/2 - r->p_len; i++) {
-		x += pAC->vpd.vpd_buf[i] ;
+	for (i = 0, x = 0; (unsigned)i<=(unsigned)vpd_size/2 - r->p_len; i++) {
+		x += pAC->vpd.vpd_buf[i];
 	}
+	
 	if (x != 0) {
 		/* checksum error */
-		SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
-			("VPD Checksum Error\n")) ;
-		return (1) ;
+		SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
+			("VPD Checksum Error\n"));
+		return(1);
 	}
 
 	/* find and check the end tag of the RW area */
-	if (!(r = vpd_find_para(pAC,VPD_RW,&rp))) {
-		SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
-			("Encoding Error: RV Tag not found\n")) ;
-		return (1) ;
+	if (!(r = vpd_find_para(pAC, VPD_RW, &rp))) {
+		SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
+			("Encoding Error: RV Tag not found\n"));
+		return(1);
 	}
-	if (r->p_val < pAC->vpd.vpd_buf + VPD_SIZE/2) {
-		SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
-			("Encoding Error: Invalid VPD struct size\n")) ;
-		return (1) ;
+	
+	if (r->p_val < pAC->vpd.vpd_buf + vpd_size/2) {
+		SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
+			("Encoding Error: Invalid VPD struct size\n"));
+		return(1);
 	}
-	pAC->vpd.v.vpd_free_rw = r->p_len ;
+	pAC->vpd.v.vpd_free_rw = r->p_len;
 
 	/* everything seems to be ok */
-	pAC->vpd.v.vpd_status |= VPD_VALID ;
-	SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_INIT,
+	if (pAC->GIni.GIChipId != 0) {
+		pAC->vpd.v.vpd_status |= VPD_VALID;
+	}
+
+	SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_INIT,
 		("done. Free RO = %d, Free RW = %d\n",
-		pAC->vpd.v.vpd_free_ro, pAC->vpd.v.vpd_free_rw)) ;
+		pAC->vpd.v.vpd_free_ro, pAC->vpd.v.vpd_free_rw));
 
-	return(0) ;
+	return(0);
 }
 
 /*
  *	find the Keyword 'key' in the VPD buffer and fills the
- *	parameter sturct 'p' with it's values
+ *	parameter struct 'p' with it's values
  *
  * returns	*p	success
  *		0:	parameter was not found or VPD encoding error
@@ -573,63 +652,64 @@
 char *key,		/* keyword to find (e.g. "MN") */
 SK_VPD_PARA *p)	/* parameter description struct */
 {
-	char *v	;	/* points to vpd buffer */
-	int max ;	/* Maximum Number of Iterations */
+	char *v	;	/* points to VPD buffer */
+	int max;	/* Maximum Number of Iterations */
 
-	v = pAC->vpd.vpd_buf ;
-	max = 128 ;
+	v = pAC->vpd.vpd_buf;
+	max = 128;
 
-	SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_CTRL,
-		("vpd find para %s .. ",key)) ;
+	SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
+		("VPD find para %s .. ",key));
 
 	/* check mandatory resource type ID string (Product Name) */
-	if (*v != (char) RES_ID) {
-		SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
-			("Error: 0x%x missing\n",RES_ID)) ;
-		return (0) ;
-	}
-
-	if (strcmp(key,VPD_NAME) == 0) {
-		p->p_len = VPD_GET_RES_LEN(v) ;
-		p->p_val = VPD_GET_VAL(v) ;
-		SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_CTRL,
-			("found, len = %d\n",p->p_len)) ;
-		return(p) ;
+	if (*v != (char)RES_ID) {
+		SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
+			("Error: 0x%x missing\n", RES_ID));
+		return(0);
+	}
+
+	if (strcmp(key, VPD_NAME) == 0) {
+		p->p_len = VPD_GET_RES_LEN(v);
+		p->p_val = VPD_GET_VAL(v);
+		SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
+			("found, len = %d\n", p->p_len));
+		return(p);
 	}
 
-	v += 3 + VPD_GET_RES_LEN(v) + 3 ;
-	for ( ; ; ) {
+	v += 3 + VPD_GET_RES_LEN(v) + 3;
+	for (;; ) {
 		if (SK_MEMCMP(key,v,2) == 0) {
-			p->p_len = VPD_GET_VPD_LEN(v) ;
-			p->p_val = VPD_GET_VAL(v) ;
-			SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_CTRL,
-				("found, len = %d\n",p->p_len)) ;
-			return (p) ;
+			p->p_len = VPD_GET_VPD_LEN(v);
+			p->p_val = VPD_GET_VAL(v);
+			SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
+				("found, len = %d\n",p->p_len));
+			return(p);
 		}
 
 		/* exit when reaching the "RW" Tag or the maximum of itera. */
-		max-- ;
+		max--;
 		if (SK_MEMCMP(VPD_RW,v,2) == 0 || max == 0) {
-			break ;
+			break;
 		}
 
 		if (SK_MEMCMP(VPD_RV,v,2) == 0) {
-			v += 3 + VPD_GET_VPD_LEN(v) + 3 ;	/* skip VPD-W */
-		} else {
-			v += 3 + VPD_GET_VPD_LEN(v) ;
+			v += 3 + VPD_GET_VPD_LEN(v) + 3;	/* skip VPD-W */
 		}
-		SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_CTRL,
-			("scanning '%c%c' len = %d\n",v[0],v[1],v[2])) ;
+		else {
+			v += 3 + VPD_GET_VPD_LEN(v);
+		}
+		SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
+			("scanning '%c%c' len = %d\n",v[0],v[1],v[2]));
 	}
 
 #ifdef DEBUG
-	SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_CTRL,("not found\n")) ;
+	SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL, ("not found\n"));
 	if (max == 0) {
-		SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
-			("Key/Len Encoding error\n")) ;
+		SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
+			("Key/Len Encoding error\n"));
 	}
-#endif
-	return (0) ;
+#endif /* DEBUG */
+	return(0);
 }
 
 /*
@@ -643,24 +723,25 @@
 char *end,		/* end of memory block to move */
 int n)			/* number of bytes the memory block has to be moved */
 {
-	char *p ;
-	int i ;		/* number of byte copied */
+	char *p;
+	int i;		/* number of byte copied */
 
 	if (n == 0)
-		return ;
+		return;
 
-	i = (int) (end - start + 1) ;
+	i = (int) (end - start + 1);
 	if (n < 0) {
-		p = start + n ;
+		p = start + n;
 		while (i != 0) {
-			*p++ = *start++ ;
-			i-- ;
+			*p++ = *start++;
+			i--;
 		}
-	} else {
-		p = end + n ;
+	}
+	else {
+		p = end + n;
 		while (i != 0) {
-			*p-- = *end-- ;
-			i-- ;
+			*p-- = *end--;
+			i--;
 		}
 	}
 }
@@ -676,13 +757,13 @@
 int len,		/* length of the value string */
 char *ip)		/* inseration point */
 {
-	SK_VPD_KEY *p ;
+	SK_VPD_KEY *p;
 
-	p = (SK_VPD_KEY *) ip ;
-	p->p_key[0] = key[0] ;
-	p->p_key[1] = key[1] ;
-	p->p_len = (unsigned char) len ;
-	SK_MEMCPY(&p->p_val,buf,len) ;
+	p = (SK_VPD_KEY *) ip;
+	p->p_key[0] = key[0];
+	p->p_key[1] = key[1];
+	p->p_len = (unsigned char) len;
+	SK_MEMCPY(&p->p_val,buf,len);
 }
 
 /*
@@ -696,46 +777,50 @@
 SK_AC *pAC,	/* common data base */
 char *etp)		/* end pointer input position */
 {
-	SK_VPD_KEY *p ;
-	unsigned char	x ;
-	int	i ;
+	SK_VPD_KEY *p;
+	unsigned char	x;
+	int	i;
+	int	vpd_size;
+
+	SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
+		("VPD modify endtag at 0x%x = '%c%c'\n",etp,etp[0],etp[1]));
 
-	SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_CTRL,
-		("vpd modify endtag at 0x%x = '%c%c'\n",etp,etp[0],etp[1])) ;
+	vpd_size = pAC->vpd.vpd_size;
 
-	p = (SK_VPD_KEY *) etp ;
+	p = (SK_VPD_KEY *) etp;
 
 	if (p->p_key[0] != 'R' || (p->p_key[1] != 'V' && p->p_key[1] != 'W')) {
 		/* something wrong here, encoding error */
 		SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
-			("Encoding Error: invalid end tag\n")) ;
-		return(1) ;
+			("Encoding Error: invalid end tag\n"));
+		return(1);
 	}
-	if (etp > pAC->vpd.vpd_buf + VPD_SIZE/2) {
+	if (etp > pAC->vpd.vpd_buf + vpd_size/2) {
 		/* create "RW" tag */
-		p->p_len = (unsigned char)(pAC->vpd.vpd_buf+VPD_SIZE-etp-3-1) ;
-		pAC->vpd.v.vpd_free_rw = (int) p->p_len ;
-		i = pAC->vpd.v.vpd_free_rw ;
-		etp += 3 ;
-	} else {
+		p->p_len = (unsigned char)(pAC->vpd.vpd_buf+vpd_size-etp-3-1);
+		pAC->vpd.v.vpd_free_rw = (int) p->p_len;
+		i = pAC->vpd.v.vpd_free_rw;
+		etp += 3;
+	}
+	else {
 		/* create "RV" tag */
-		p->p_len = (unsigned char)(pAC->vpd.vpd_buf+VPD_SIZE/2-etp-3) ;
-		pAC->vpd.v.vpd_free_ro = (int) p->p_len - 1 ;
+		p->p_len = (unsigned char)(pAC->vpd.vpd_buf+vpd_size/2-etp-3);
+		pAC->vpd.v.vpd_free_ro = (int) p->p_len - 1;
 
 		/* setup checksum */
-		for (i = 0, x = 0; i < VPD_SIZE/2 - p->p_len; i++) {
-			x += pAC->vpd.vpd_buf[i] ;
+		for (i = 0, x = 0; i < vpd_size/2 - p->p_len; i++) {
+			x += pAC->vpd.vpd_buf[i];
 		}
-		p->p_val = (char) 0 - x ;
-		i = pAC->vpd.v.vpd_free_ro ;
-		etp += 4 ;
+		p->p_val = (char) 0 - x;
+		i = pAC->vpd.v.vpd_free_ro;
+		etp += 4;
 	}
 	while (i) {
-		*etp++ = 0x00 ;
-		i-- ;
+		*etp++ = 0x00;
+		i--;
 	}
 
-	return (0) ;
+	return(0);
 }
 
 /*
@@ -760,76 +845,81 @@
 int	type,		/* VPD_RO_KEY or VPD_RW_KEY */
 int	op)			/* operation to do: ADD_KEY or OWR_KEY */
 {
-	SK_VPD_PARA vp ;
-	char	*etp ;		/* end tag position */
-	int	free ;		/* remaining space in selected area */
-	char	*ip ;		/* input position inside the VPD buffer */
-	int	rtv ;		/* return code */
-	int	head ;		/* additional haeder bytes to move */
-	int	found ;		/* additinoal bytes if the keyword was found */
+	SK_VPD_PARA vp;
+	char	*etp;		/* end tag position */
+	int	free;		/* remaining space in selected area */
+	char	*ip;		/* input position inside the VPD buffer */
+	int	rtv;		/* return code */
+	int	head;		/* additional haeder bytes to move */
+	int	found;		/* additinoal bytes if the keyword was found */
+	int vpd_size;
 
-	SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_CTRL,
-		("vpd setup para key = %s, val = %s\n",key,buf)) ;
+	SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
+		("VPD setup para key = %s, val = %s\n",key,buf));
+	
+	vpd_size = pAC->vpd.vpd_size;
 
-	rtv = 0 ;
-	ip = 0 ;
+	rtv = 0;
+	ip = 0;
 	if (type == VPD_RW_KEY) {
 		/* end tag is "RW" */
-		free = pAC->vpd.v.vpd_free_rw ;
-		etp = pAC->vpd.vpd_buf + (VPD_SIZE - free - 1 - 3) ;
-	} else {
+		free = pAC->vpd.v.vpd_free_rw;
+		etp = pAC->vpd.vpd_buf + (vpd_size - free - 1 - 3);
+	}
+	else {
 		/* end tag is "RV" */
-		free = pAC->vpd.v.vpd_free_ro ;
-		etp = pAC->vpd.vpd_buf + (VPD_SIZE/2 - free - 4) ;
+		free = pAC->vpd.v.vpd_free_ro;
+		etp = pAC->vpd.vpd_buf + (vpd_size/2 - free - 4);
 	}
-	SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_CTRL,
+	SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
 		("Free RO = %d, Free RW = %d\n",
-		pAC->vpd.v.vpd_free_ro, pAC->vpd.v.vpd_free_rw)) ;
+		pAC->vpd.v.vpd_free_ro, pAC->vpd.v.vpd_free_rw));
 
-	head = 0 ;
-	found = 0 ;
+	head = 0;
+	found = 0;
 	if (op == OWR_KEY) {
-		if (vpd_find_para(pAC,key,&vp)) {
-			found = 3 ;
-			ip = vp.p_val - 3 ;
-			free += vp.p_len + 3 ;
-			SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_CTRL,
-				("Overwrite Key\n")) ;
-		} else {
-			op = ADD_KEY ;
-			SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_CTRL,
-				("Add Key\n")) ;
+		if (vpd_find_para(pAC, key, &vp)) {
+			found = 3;
+			ip = vp.p_val - 3;
+			free += vp.p_len + 3;
+			SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
+				("Overwrite Key\n"));
+		}
+		else {
+			op = ADD_KEY;
+			SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_CTRL,
+				("Add Key\n"));
 		}
 	}
 	if (op == ADD_KEY) {
-		ip = etp ;
-		vp.p_len = 0 ;
-		head = 3 ;
+		ip = etp;
+		vp.p_len = 0;
+		head = 3;
 	}
 
 	if (len + 3 > free) {
 		if (free < 7) {
-			SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR,
+			SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
 				("VPD Buffer Overflow, keyword not written\n"));
-			return (4) ;
+			return(4);
 		}
 		/* cut it again */
-		len = free - 3 ;
-		rtv = 2 ;
-		SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR,
-			("VPD Buffer Full, Keyword was cut\n")) ;
+		len = free - 3;
+		rtv = 2;
+		SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
+			("VPD Buffer Full, Keyword was cut\n"));
 	}
 
-	vpd_move_para(ip + vp.p_len + found, etp+2, len-vp.p_len+head) ;
-	vpd_insert_key(key, buf, len, ip) ;
+	vpd_move_para(ip + vp.p_len + found, etp+2, len-vp.p_len+head);
+	vpd_insert_key(key, buf, len, ip);
 	if (vpd_mod_endtag(pAC, etp + len - vp.p_len + head)) {
-		pAC->vpd.v.vpd_status &= ~VPD_VALID ;
-		SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR,
-			("VPD Encoding Error\n")) ;
-		return(6) ;
+		pAC->vpd.v.vpd_status &= ~VPD_VALID;
+		SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
+			("VPD Encoding Error\n"));
+		return(6);
 	}
 
-	return (rtv) ;
+	return(rtv);
 }
 
 
@@ -837,7 +927,7 @@
  *	Read the contents of the VPD EEPROM and copy it to the
  *	VPD buffer if not already done.
  *
- * return:	A pointer to the vpd_status structure. The structure contain
+ * return:	A pointer to the vpd_status structure. The structure contains
  *		this fields.
  */
 SK_VPD_STATUS	*VpdStat(
@@ -845,9 +935,9 @@
 SK_IOC		IoC)	/* IO Context */
 {
 	if (!(pAC->vpd.v.vpd_status & VPD_VALID)) {
-		(void)VpdInit(pAC,IoC) ;
+		(void)VpdInit(pAC,IoC);
 	}
-	return(&pAC->vpd.v) ;
+	return(&pAC->vpd.v);
 }
 
 
@@ -880,67 +970,69 @@
 int		*len,		/* buffer length */
 int		*elements)	/* number of keywords returned */
 {
-	char *v ;
-	int n ;
+	char *v;
+	int n;
 
-	SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_RX,("list vpd keys .. ")) ;
-	*elements = 0 ;
+	SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_RX, ("list VPD keys .. "));
+	*elements = 0;
 	if (!(pAC->vpd.v.vpd_status & VPD_VALID)) {
 		if (VpdInit(pAC,IoC) != 0 ) {
-			*len = 0 ;
-			SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR,
-				("VPD Init Error, terminated\n")) ;
-			return(6) ;
+			*len = 0;
+			SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
+				("VPD Init Error, terminated\n"));
+			return(6);
 		}
 	}
 
 	if ((signed)strlen(VPD_NAME) + 1 <= *len) {
-		v = pAC->vpd.vpd_buf ;
-		strcpy(buf,VPD_NAME) ;
-		n = strlen(VPD_NAME) + 1 ;
-		buf += n ;
-		*elements = 1 ;
-		SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_RX,
-			("'%c%c' ",v[0],v[1])) ;
-	} else {
-		*len = 0 ;
+		v = pAC->vpd.vpd_buf;
+		strcpy(buf,VPD_NAME);
+		n = strlen(VPD_NAME) + 1;
+		buf += n;
+		*elements = 1;
+		SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_RX,
+			("'%c%c' ",v[0],v[1]));
+	}
+	else {
+		*len = 0;
 		SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR,
-			("buffer overflow\n")) ;
-		return(2) ;
+			("buffer overflow\n"));
+		return(2);
 	}
 
-	v += 3 + VPD_GET_RES_LEN(v) + 3 ;
-	for ( ; ; ) {
+	v += 3 + VPD_GET_RES_LEN(v) + 3;
+	for (;; ) {
 		/* exit when reaching the "RW" Tag */
 		if (SK_MEMCMP(VPD_RW,v,2) == 0) {
-			break ;
+			break;
 		}
 
 		if (SK_MEMCMP(VPD_RV,v,2) == 0) {
-			v += 3 + VPD_GET_VPD_LEN(v) + 3 ;	/* skip VPD-W */
-			continue ;
+			v += 3 + VPD_GET_VPD_LEN(v) + 3;	/* skip VPD-W */
+			continue;
 		}
 
 		if (n+3 <= *len) {
-			SK_MEMCPY(buf,v,2) ;
-			buf += 2 ;
-			*buf++ = '\0' ;
-			n += 3 ;
-			v += 3 + VPD_GET_VPD_LEN(v) ;
-			*elements += 1 ;
-			SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_RX,
-				("'%c%c' ",v[0],v[1])) ;
-		} else {
-			*len = n ;
-			SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR,
-				("buffer overflow\n")) ;
-			return (2) ;
+			SK_MEMCPY(buf,v,2);
+			buf += 2;
+			*buf++ = '\0';
+			n += 3;
+			v += 3 + VPD_GET_VPD_LEN(v);
+			*elements += 1;
+			SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_RX,
+				("'%c%c' ",v[0],v[1]));
+		}
+		else {
+			*len = n;
+			SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
+				("buffer overflow\n"));
+			return(2);
 		}
 	}
 
-	SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_RX,("\n")) ;
-	*len = n ;
-	return(0) ;
+	SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_RX, ("\n"));
+	*len = n;
+	return(0);
 }
 
 
@@ -964,34 +1056,35 @@
 char		*buf,	/* buffer where to copy the keyword value */
 int		*len)	/* buffer length */
 {
-	SK_VPD_PARA *p, vp ;
+	SK_VPD_PARA *p, vp;
 
-	SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_RX,("vpd read %s .. ",key)) ;
+	SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_RX, ("VPD read %s .. ", key));
 	if (!(pAC->vpd.v.vpd_status & VPD_VALID)) {
 		if (VpdInit(pAC,IoC) != 0 ) {
-			*len = 0 ;
-			SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR,
-				("vpd init error\n")) ;
-			return(6) ;
+			*len = 0;
+			SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
+				("VPD init error\n"));
+			return(6);
 		}
 	}
 
-	if ((p = vpd_find_para(pAC,key,&vp))) {
+	if ((p = vpd_find_para(pAC, key, &vp)) != NULL) {
 		if (p->p_len > (*(unsigned *)len)-1) {
-			p->p_len = *len - 1 ;
+			p->p_len = *len - 1;
 		}
-		SK_MEMCPY(buf,p->p_val,p->p_len) ;
-		buf[p->p_len] = '\0' ;
-		*len = p->p_len ;
-		SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_RX,
+		SK_MEMCPY(buf, p->p_val, p->p_len);
+		buf[p->p_len] = '\0';
+		*len = p->p_len;
+		SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_RX,
 			("%c%c%c%c.., len = %d\n",
-			buf[0],buf[1],buf[2],buf[3],*len)) ;
-	} else {
-		*len = 0 ;
-		SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR,("not found\n")) ;
-		return (1) ;
+			buf[0],buf[1],buf[2],buf[3],*len));
 	}
-	return (0) ;
+	else {
+		*len = 0;
+		SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR, ("not found\n"));
+		return(1);
+	}
+	return(0);
 }
 
 
@@ -1009,9 +1102,9 @@
 		key[1] < '0' || key[1] > 'Z' ||
 		(key[1] > '9' && key[1] < 'A') || strlen(key) != 2) {
 
-		return (SK_FALSE) ;
+		return(SK_FALSE);
 	}
-	return (SK_TRUE) ;
+	return(SK_TRUE);
 }
 
 /*
@@ -1033,46 +1126,46 @@
 char		*key,	/* keyword to write (allowed values "Yx", "Vx") */
 char		*buf)	/* buffer where the keyword value can be read from */
 {
-	int len ;			/* lenght of the keyword to write */
-	int rtv ;			/* return code */
-	int rtv2 ;
+	int len;			/* length of the keyword to write */
+	int rtv;			/* return code */
+	int rtv2;
 
-	SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_TX,
-		("vpd write %s = %s\n",key,buf)) ;
+	SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_TX,
+		("VPD write %s = %s\n",key,buf));
 
 	if ((*key != 'Y' && *key != 'V') ||
 		key[1] < '0' || key[1] > 'Z' ||
 		(key[1] > '9' && key[1] < 'A') || strlen(key) != 2) {
 
-		SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR,
-			("illegal key tag, keyword not written\n")) ;
-		return (5) ;
+		SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
+			("illegal key tag, keyword not written\n"));
+		return(5);
 	}
 
 	if (!(pAC->vpd.v.vpd_status & VPD_VALID)) {
 		if (VpdInit(pAC,IoC) != 0 ) {
-			SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR,
-				("vpd init error\n")) ;
-			return(6) ;
+			SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
+				("VPD init error\n"));
+			return(6);
 		}
 	}
 
-	rtv = 0 ;
-	len = strlen(buf) ;
+	rtv = 0;
+	len = strlen(buf);
 	if (len > VPD_MAX_LEN) {
 		/* cut it */
-		len = VPD_MAX_LEN ;
-		rtv = 2 ;
-		SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR,
-			("keyword to long, cut after %d bytes\n",VPD_MAX_LEN)) ;
-	}
-	if ((rtv2 = VpdSetupPara(pAC,key,buf,len,VPD_RW_KEY,OWR_KEY)) != 0) {
-		SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR,
-			("vpd write error\n")) ;
-		return(rtv2) ;
+		len = VPD_MAX_LEN;
+		rtv = 2;
+		SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
+			("keyword to long, cut after %d bytes\n",VPD_MAX_LEN));
+	}
+	if ((rtv2 = VpdSetupPara(pAC, key,buf, len, VPD_RW_KEY, OWR_KEY)) != 0) {
+		SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
+			("VPD write error\n"));
+		return(rtv2);
 	}
 
-	return (rtv) ;
+	return(rtv);
 }
 
 /*
@@ -1092,43 +1185,47 @@
 SK_IOC		IoC,	/* IO Context */
 char		*key)	/* keyword to read (e.g. "MN") */
 {
-	SK_VPD_PARA *p, vp ;
-	char *etp ;
+	SK_VPD_PARA *p, vp;
+	char *etp;
+	int	vpd_size;
 
-	SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_TX,("vpd delete key %s\n",key)) ;
+	vpd_size = pAC->vpd.vpd_size;
+
+	SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_TX,("VPD delete key %s\n",key));
 	if (!(pAC->vpd.v.vpd_status & VPD_VALID)) {
 		if (VpdInit(pAC,IoC) != 0 ) {
-			SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR,
-				("vpd init error\n")) ;
-			return(6) ;
+			SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
+				("VPD init error\n"));
+			return(6);
 		}
 	}
 
-	if ((p = vpd_find_para(pAC,key,&vp))) {
-		if (p->p_val < pAC->vpd.vpd_buf + VPD_SIZE/2) {
+	if ((p = vpd_find_para(pAC, key, &vp)) != NULL) {
+		if (p->p_val < pAC->vpd.vpd_buf + vpd_size/2) {
 			/* try to delete read only keyword */
-			SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR,
-				("cannot delete RO keyword\n")) ;
-			return (5) ;
+			SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
+				("cannot delete RO keyword\n"));
+			return(5);
 		}
 
-		etp = pAC->vpd.vpd_buf + (VPD_SIZE-pAC->vpd.v.vpd_free_rw-1-3) ;
+		etp = pAC->vpd.vpd_buf + (vpd_size-pAC->vpd.v.vpd_free_rw-1-3);
 
 		vpd_move_para(vp.p_val+vp.p_len, etp+2,
-			- ((int)(vp.p_len + 3))) ;
+			- ((int)(vp.p_len + 3)));
 		if (vpd_mod_endtag(pAC, etp - vp.p_len - 3)) {
-			pAC->vpd.v.vpd_status &= ~VPD_VALID ;
-			SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR,
-				("vpd encoding error\n")) ;
-			return(6) ;
+			pAC->vpd.v.vpd_status &= ~VPD_VALID;
+			SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
+				("VPD encoding error\n"));
+			return(6);
 		}
-	} else {
-		SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR,
-			("keyword not found\n")) ;
-		return (1) ;
+	}
+	else {
+		SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
+			("keyword not found\n"));
+		return(1);
 	}
 
-	return (0) ;
+	return(0);
 }
 
 /*
@@ -1142,18 +1239,22 @@
 SK_AC		*pAC,	/* Adapters context */
 SK_IOC		IoC)	/* IO Context */
 {
-	SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_TX,("vpd update .. ")) ;
+	int vpd_size;
+
+	vpd_size = pAC->vpd.vpd_size;
+
+	SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_TX, ("VPD update .. "));
 	if (pAC->vpd.v.vpd_status & VPD_VALID) {
-		if (VpdTransferBlock(pAC,IoC,pAC->vpd.vpd_buf + VPD_SIZE/2,
-			VPD_SIZE/2, VPD_SIZE/2, VPD_WRITE) != VPD_SIZE/2) {
+		if (VpdTransferBlock(pAC, IoC, pAC->vpd.vpd_buf + vpd_size/2,
+			vpd_size/2, vpd_size/2, VPD_WRITE) != vpd_size/2) {
 
-			SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR,
-				("transfer timed out\n")) ;
-			return(3) ;
+			SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
+				("transfer timed out\n"));
+			return(3);
 		}
 	}
-	SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_TX,("done\n")) ;
-	return (0) ;
+	SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_TX, ("done\n"));
+	return(0);
 }
 
 
@@ -1173,32 +1274,33 @@
 SK_IOC		IoC,	/* IO Context */
 char		*msg)	/* error log message */
 {
-	SK_VPD_PARA *v, vf ;	/* VF */
-	int len ;
+	SK_VPD_PARA *v, vf;	/* VF */
+	int len;
 
-	SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_TX,
-		("vpd error log msg %s\n",msg)) ;
+	SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_TX,
+		("VPD error log msg %s\n",msg));
 	if (!(pAC->vpd.v.vpd_status & VPD_VALID)) {
 		if (VpdInit(pAC,IoC) != 0 ) {
-			SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR,
-				("vpd init error\n")) ;
-			return ;
+			SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_ERR,
+				("VPD init error\n"));
+			return;
 		}
 	}
 
-	len = strlen(msg) ;
+	len = strlen(msg);
 	if (len > VPD_MAX_LEN) {
 		/* cut it */
-		len = VPD_MAX_LEN ;
+		len = VPD_MAX_LEN;
+	}
+	if ((v = vpd_find_para(pAC, VPD_VF, &vf)) != NULL) {
+		SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_TX, ("overwrite VL\n"));
+		(void)VpdSetupPara(pAC, VPD_VL, msg, len, VPD_RW_KEY, OWR_KEY);
 	}
-	if ((v = vpd_find_para(pAC,VPD_VF,&vf))) {
-		SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_TX,("overwrite VL\n")) ;
-		(void)VpdSetupPara(pAC,VPD_VL,msg,len,VPD_RW_KEY,OWR_KEY) ;
-	} else {
-		SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_TX,("write VF\n")) ;
-		(void)VpdSetupPara(pAC,VPD_VF,msg,len,VPD_RW_KEY,ADD_KEY) ;
+	else {
+		SK_DBG_MSG(pAC, SK_DBGMOD_VPD, SK_DBGCAT_TX, ("write VF\n"));
+		(void)VpdSetupPara(pAC, VPD_VF, msg,len, VPD_RW_KEY, ADD_KEY);
 	}
 
-	(void)VpdUpdate(pAC,IoC) ;
+	(void)VpdUpdate(pAC, IoC);
 }
 

FUNET's LINUX-ADM group, linux-adm@nic.funet.fi
TCL-scripts by Sam Shen (who was at: slshen@lbl.gov)