** RETURNS: A pointer to the desired packet and OK if the packet was found,*          otherwise it returns ERROR.** SEE ALSO: sysVpdPktParse()*/STATUS sysVpdPktGet    (    UCHAR         vpdType,     /* target packet type */    UINT32        vpdInstance, /* instance number of desired packet (0-based) */    VPD_PACKET ** pVpdPtr,     /* address of the array of packet pointers */    VPD_PACKET ** pVpdPacket   /* address of the return variable */    )    {    UCHAR        type;         /* current packet type */    VPD_PACKET * p;            /* pointer to current packet */    /* if the first pointer in the array is NULL, return an error indication. */    if (*pVpdPtr == NULL)        return (ERROR);    do        {        /* get the current packet pointer */        p = *pVpdPtr;        /* if the packet type matches the caller's requested type */        if ( (type = p->type) == vpdType )            {            /*             * see if the type is an ethernet address and has a trailing             * instance value. if it does, see of the instance number matches             * the caller's requested instance.             */            if ( (vpdType == VPD_PID_EA) &&                 (p->size == ENET_INSTANCE_SIZE) &&                 (vpdInstance == p->data[ENET_INSTANCE_SIZE-1]) )                {                *pVpdPacket = p;                return (OK);                }            else                {                /*                 * see if this is the instance the caller requested, if not                 * decrement the instance count and go around again.                 */                if (vpdInstance-- == 0)                    {                    *pVpdPacket = p;                    return (OK);                    }                }            }        /* advance to the next packet. */        pVpdPtr++;        /* terminate on reaching the term packet. */        } while ( type != VPD_PID_TERM);    return (ERROR);    }/******************************************************************************** sysVpdPktRead - read a packet vital product data structure.** This routine searches the vpd in I2C looking for the specified * instance of a specific packet type.  The routine takes the number* of data bytes to read in an effort to reduce I2C cycles.** RETURNS: OK, if successful or ERROR if unsuccessful.**/STATUS sysVpdPktRead    (    UCHAR         devAdrs,     /* i2c address of the serial eeprom */    UCHAR         devOffset,   /* offset to vpd within the serial eeprom */    UCHAR         vpdType,     /* target packet type */    UINT32        vpdInstance, /* instance number of desired packet (0-based) */    VPD_PACKET    *packet,     /* pointer to packet to fill out */    UINT32        numBytes     /* number of data bytes to read */     )    {    UINT32        currentOffset;    currentOffset = 0;    do        {        /* Read the next vpd packet.  Add the type and size to numBytes. */        if (I2C_BYTE_RANGE_READ (devAdrs,                      devOffset + sizeof(VPD_HEADER) + currentOffset,                      numBytes + 2, (UCHAR *)packet) != OK)            return (ERROR);        /*         * Compare the type of this vpd packet.         */        if (packet->type == vpdType)            return (OK);        currentOffset += packet->size + 2;        } while ((currentOffset < VPD_EEPROM_SIZE) &&                  (packet->type != VPD_PID_TERM));    return (ERROR);    }/******************************************************************************** sysVpdPktInit - initialize a vital product data structure.** This routine reads the vital product data header from a serial eeprom and* validates it. If the header is valid, the remainder of the vpd data* is read from the serial eeprom and parsed into vpd packets for general* purpose use.  If the board type is LoPEC, the packets are read one* packet at a time rather than the whole 256 bytes.** RETURNS: OK, if successful or ERROR if unsuccessful.** SEE ALSO: sysVpdPktParse(), sysVpdPktGet() */STATUS sysVpdPktInit    (    UCHAR         devAdrs,   /* i2c address of the serial eeprom */    UCHAR         devOffset, /* offset to vpd within the serial eeprom */    VPD *         pVpd,      /* address of vpd structure */    VPD_PACKET ** pVpdPtr,   /* address of packet ptr array */    UINT32        PktLimit,  /* number of entries in the packet ptr array */    UINT32        parseFlag  /* flag indicating to read all bytes or not */    )    {    UINT32        currentOffset;    UCHAR *       currentPacketOffset;    UCHAR         size;    /* mark vpd packet pointer contents invalid. */    *pVpdPtr = NULL;    /* read just the header from serial eeprom. */    if (I2C_BYTE_RANGE_READ (devAdrs, devOffset, sizeof(VPD_HEADER),                        (UCHAR *)pVpd) != OK)        return (ERROR);    /* check for a valid header */    if (sysVpdHdrVld (pVpd) != OK)         return (ERROR);    if (!parseFlag)        return (OK);    /* read the rest of the vpd from the serial eeprom. */    currentOffset = 0;    currentPacketOffset = (UCHAR *)&pVpd->packets[0];    do        {        /* Read next packet type. */        if (I2C_BYTE_READ (devAdrs,                      devOffset + sizeof(VPD_HEADER) + currentOffset++,                      currentPacketOffset) != OK)            return (ERROR);        if ((*currentPacketOffset == VPD_PID_TERM) ||            (*currentPacketOffset == VPD_PID_GI))            break;         currentPacketOffset++;        /* Read the packet size. */        if (I2C_BYTE_READ (devAdrs,                      devOffset + sizeof(VPD_HEADER) + currentOffset++,                      &size) != OK)            return (ERROR);        *currentPacketOffset++ = size;        /* Read the next vpd packet.  Add the type and size to numBytes. */        if (I2C_BYTE_RANGE_READ (devAdrs,                      devOffset + sizeof(VPD_HEADER) + currentOffset,                      size, currentPacketOffset) != OK)            return (ERROR);        currentOffset += size; /* Add size to pointer */        currentPacketOffset += size;        } while (currentOffset < VPD_EEPROM_SIZE);     /* parse the raw vpd data into vpd packets. */    return (sysVpdPktParse (pVpd, pVpdPtr, PktLimit) );    }/******************************************************************************** sysCalcBusSpd - routine to calculate the speed of the 60x processor bus** This routine calculates the 60x processor bus frequency using the UART's* crystal and baud rate generator as a reference. The UART is configured* for 9600 baud, which produces a (9600 x 16) Hz frequency reference on the* UART's BAUDOUT pin, this signal is visible as bit 1 in the board status* register. The processor's bus frequency can be determined by noting the* number of elapsed "ticks" required for a given number of BAUDOUT edges and* applying for formula below. The constants are: 2 = number edge per period.* 16 = the baud rate to BAUDOUT multiplier. 4 = The processor's time base* registers are driven by a clock which is 1/4 the bus frequency.**.CS*          edges counted            elapsed ticks*  T =  ----------------------  =  --------------------*         2 * baud rate * 16        bus frequency / 4****         2 * baud rate * 16        bus frequency / 4*  F = ----------------------  = ----------------------*           edges counted           elapsed ticks***       2 * baud rate * 16 * ticks * 4*  F = ---------------------------------- = bus Frequency*               edges counted*.CE** To keep everything in 32 bits, the number of ticks must be below 3495. At* 100 MHz, 3495 time base ticks is only 140 uSecs or 43 BAUDOUT edges. At* these numbers, each time base tick is worth 29.25 KHz. By setting the number* of edges equal to the baud rate, (baud rate / edges counted) = 1 the * equation reduces to:**.CS* F = 2 * 16 * ticks * 4 = Bus Frequency.*.CE** Using this equation, the sampling interval is increased to about 31 mSecs,* each time base tick is only worth 128 Hz and there is no danger of overflowing* 32 bits.** RETURNS: The bus speed (in Hz).** NOTE: This routine must be called before interrupts are enabled and before* the serial port baud rate has been configured. Since it is usually called* very early in the start up sequence, this should not be a problem.*/#define BAUD_RATE           9600#define BAUD_RATE_CODE      12#define EDGES_PER_PERIOD    2	    /* one rising, one falling = 2 */#define BAUD_CLOCK_RATIO    16	    /* UART's BAUDOUT is 16x baud rate */#define TIME_BASE_RATIO     4	    /* time base clock is 1/4 bus frequency */#define MULTIPLIER (EDGES_PER_PERIOD * BAUD_CLOCK_RATIO * TIME_BASE_RATIO)UINT32 sysCalcBusSpd (void)    {    UCHAR * pUart = (UCHAR *) COM1_BASE_ADR;    UINT32 edgeTime;    /* configure the uart for 9600 baud */    pUart[UART_LCR * UART_REG_ADDR_INTERVAL] |= I8250_LCR_DLAB;    pUart[UART_BRDL * UART_REG_ADDR_INTERVAL] = BAUD_RATE_CODE;    pUart[UART_BRDH * UART_REG_ADDR_INTERVAL] = 0;    pUart[UART_LCR * UART_REG_ADDR_INTERVAL] &= ~I8250_LCR_DLAB;    EIEIO_SYNC;    edgeTime = sysTimeEdges (BAUD_RATE) * MULTIPLIER;    if (edgeTime == 0)	flashFailLed (TRUE, FAIL_LED_BAUDOUT, 4);    return (edgeTime);    }