skvpd.c

内核linux2.4.20,可跟rtlinux3.2打补丁 组成实时linux系统,编译内核

		VPD_IN8(pAC,IoC,PCI_VPD_DAT_REG+(i%sizeof(SK_U32)),
			(SK_U8 *)buf) ;
	}

	return(Len) ;
}

/*
 *	Read ore wirtes '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 */
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)) ;

	if (len == 0)
		return (0) ;

	VPD_IN32(pAC,IoC,PCI_OUR_REG_2,&our_reg2) ;
	vpd_rom_size = 256 << ((our_reg2 & PCI_VPD_ROM_SZ) >> 14);
	if (addr > vpd_rom_size - 4) {
		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) ;
	}
	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)) ;
	}

	if (dir == VPD_READ) {
		Rtv = VpdReadStream(pAC, IoC, buf, addr, len);
	} else {
		Rtv = VpdWriteStream(pAC, IoC, buf, addr, len);
	}

	return (Rtv) ;
}

#ifdef SKDIAG

/*
 *	Read 'len' bytes of VPD data, starting at 'addr'.
 *
 * 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 */
int		addr,	/* start reading at the VPD address */
int		len)	/* number of bytes to read */
{
	return (VpdTransferBlock(pAC, IoC, buf, addr, len, VPD_READ)) ;
}

/*
 *	Write 'len' bytes of *but to the VPD EEPROM, starting at 'addr'.
 *
 * 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 */
int		addr,	/* start writing at the VPD address */
int		len)	/* number of bytes to write */
{
	return (VpdTransferBlock(pAC, IoC, buf, addr, len, VPD_WRITE)) ;
}
#endif	/* SKDIAG */

/*
 * (re)initialize the VPD buffer
 *
 * Reads the VPD data from the EEPROM into the VPD buffer.
 * Get the remaining read only and read / write space.
 *
 * return	0:	success
 *		1:	fatal VPD error
 */
static int	VpdInit(
SK_AC		*pAC,	/* Adapters context */
SK_IOC		IoC)	/* IO Context */
{
	SK_VPD_PARA *r, rp ;	/* RW or RV */
	int		i ;
	unsigned char	x ;

	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) {

		SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR,
			("Block Read Error\n")) ;
		return(1) ;
	}

	/* 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->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) ;
	}
	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] ;
	}
	if (x != 0) {
		/* checksum error */
		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->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 ;

	/* everything seems to be ok */
	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)) ;

	return(0) ;
}

/*
 *	find the Keyword 'key' in the VPD buffer and fills the
 *	parameter sturct 'p' with it's values
 *
 * returns	*p	success
 *		0:	parameter was not found or VPD encoding error
 */
static SK_VPD_PARA *vpd_find_para(
SK_AC *pAC,	/* common data base */
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 */

	v = pAC->vpd.vpd_buf ;
	max = 128 ;

	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) ;
	}

	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) ;
		}

		/* exit when reaching the "RW" Tag or the maximum of itera. */
		max-- ;
		if (SK_MEMCMP(VPD_RW,v,2) == 0 || max == 0) {
			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) ;
		}
		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")) ;
	if (max == 0) {
		SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_ERR | SK_DBGCAT_FATAL,
			("Key/Len Encoding error\n")) ;
	}
#endif
	return (0) ;
}

/*
 *	Move 'n' bytes. Begin with the last byte if 'n' is > 0,
 *	Start with the last byte if n is < 0.
 *
 * returns nothing
 */
static void vpd_move_para(
char *start,		/* start of memory block */
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 */

	if (n == 0)
		return ;

	i = (int) (end - start + 1) ;
	if (n < 0) {
		p = start + n ;
		while (i != 0) {
			*p++ = *start++ ;
			i-- ;
		}
	} else {
		p = end + n ;
		while (i != 0) {
			*p-- = *end-- ;
			i-- ;
		}
	}
}

/*
 *	setup the VPD keyword 'key' at 'ip'.
 *
 * returns nothing
 */
static void vpd_insert_key(
char *key,		/* keyword to insert */
char *buf,		/* buffer with the keyword value */
int len,		/* length of the value string */
char *ip)		/* inseration point */
{
	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) ;
}

/*
 *	Setup the VPD end tag "RV" / "RW".
 *	Also correct the remaining space variables vpd_free_ro / vpd_free_rw.
 *
 * returns	0:	success
 *		1:	encoding error
 */
static int vpd_mod_endtag(
SK_AC *pAC,	/* common data base */
char *etp)		/* end pointer input position */
{
	SK_VPD_KEY *p ;
	unsigned char	x ;
	int	i ;

	SK_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_CTRL,
		("vpd modify endtag at 0x%x = '%c%c'\n",etp,etp[0],etp[1])) ;

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

		/* setup checksum */
		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 ;
	}
	while (i) {
		*etp++ = 0x00 ;
		i-- ;
	}

	return (0) ;
}

/*
 *	Insert a VPD keyword into the VPD buffer.
 *
 *	The keyword 'key' is inserted at the position 'ip' in the
 *	VPD buffer.
 *	The keywords behind the input position will
 *	be moved. The VPD end tag "RV" or "RW" is generated again.
 *
 * returns	0:	success
 *		2:	value string was cut
 *		4:	VPD full, keyword was not written
 *		6:	fatal VPD error
 *
 */
int	VpdSetupPara(
SK_AC	*pAC,		/* common data base */
char	*key,		/* keyword to insert */
char	*buf,		/* buffer with the keyword value */
int	len,		/* length of the keyword value */
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_DBG_MSG(pAC,SK_DBGMOD_VPD,SK_DBGCAT_CTRL,
		("vpd setup para key = %s, val = %s\n",key,buf)) ;

	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 {
		/* end tag is "RV" */
		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,
		("Free RO = %d, Free RW = %d\n",
		pAC->vpd.v.vpd_free_ro, pAC->vpd.v.vpd_free_rw)) ;

	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 (op == ADD_KEY) {