gei82543debug.c

intel 82543 千兆网卡 vxworks驱动源码

#include "gei82543Lib.h"
 void sys543Show(int unit);
 void gei82543StatusShow(UINT8 unit);
 void gei82543DumpCount(UINT8 unit);
 void gei82543RegShow(UINT8 unit);
 UINT32 gei82543RegGet(int unit,UINT32 offset);
 void gei82543RegSet(int unit,UINT32 offset,UINT32 regval);
 void gei82543LedOn(int unit);
 void gei82543LedOff(int unit);
 int gei82543PhyRegSet(int unit,int reg,UINT16 tmp);
 int gei82543PhyRegGet(int unit,UINT16 reg);
 STATUS gei82543ShowCount(UINT8 slot);
 STATUS gei82543ClearCount(UINT8 slot);
 void gei82543BDShow(UINT8 slot);
 void gei82543DebugHelp(void);
 void gei82543Help(void);
 void gei82543DrvInfoShow(UINT8 slot);
STATUS gei82543CpldRegShow(UINT8 slot);
#define INCLUDE_GEI82543_DEBUG_ROUTINE

#ifdef INCLUDE_GEI82543_DEBUG_ROUTINE
#define SYS_DELAY(count)	{                                               \
			volatile int cx = 0;                            \
			for (cx = 0; cx < (count); cx++);               \
			}
#define GEI_SYS_WRITE_REG(unit, reg, value)     \
        ((*(volatile UINT32 *)((geiResources[(unit)].memBaseLow) + (reg))) = \
         (UINT32) LONGSWAP(value))

#define GEI_SYS_READ_REG(unit, reg)             \
        (LONGSWAP( *(volatile UINT32 *)((geiResources[(unit)].memBaseLow) + (reg))) )
/*****************************************************************************
*
* sys543Show - shows 82543 configuration
*
* This routine shows (Intel Pro 1000F/T) adapters configuration
*
* RETURNS: N/A
*/
 void sys543Show
    (
    int    slot        /* unit number */
    )
{
    GEI_RESOURCE *pReso =(GEI_RESOURCE *) NULL;

    if ((slot <1)||(slot>MAX_IF_CARD_NUM))
    {
        printf("Invalid slot number!\n");
        return (void)ERROR;
    }

    pReso = &geiResources [slot];
    if((GEI_RESOURCE *)NULL==pReso)
    {
        return (void)ERROR;
    }
    if (pReso->boardType == PRO1000F_BOARD)
        printf ("********* Intel PRO1000 F Adapter ***********\n");

    else if (pReso->boardType == PRO1000T_BOARD)
        printf ("********* Intel PRO1000 T Adapter ***********\n");

    else
        printf ("********* UNKNOWN Adaptor ************ \n");

    printf ("  CSR PCI Membase address = 0x%x\n", pReso->memBaseLow);

    printf ("  PCI bus no.= 0x%x, device no.= 0x%x, function no.= 0x%x\n",
             pReso->pciBus, pReso->pciDevice, pReso->pciFunc);

    printf ("  IRQ = %d\n", pReso->irq);

    if (pReso->iniStatus == ERROR)
    {
        return;
    }

    printf ("*********************************************\n");

    return;
}
/*****************************************************************************
*
* gei82543StatusShow - shows 82543 device status
*
* This routine shows  adapters configuration speed/duplex/auto negotiation
*
* RETURNS: N/A
*/
 void gei82543StatusShow(UINT8 unit)
{
    END_DEVICE * pDrvCtrl;
    UINT32 statusRegVal;
    UINT16 ctrlReg;

    if ((unit<1)||(unit>MAX_IF_CARD_NUM))
    {
       printf("Invalid slot number!\n");
       return (void)ERROR;
    }
    if ((END_DEVICE *)NULL == (pDrvCtrl = gei82543Unit (unit)))
    {
        return (void)ERROR;
    }

    printf ("\n");
    printf ("*****************************************************\n");
    printf ("* Intel 82545 Status *********** Device: %8p *\n", pDrvCtrl);
    printf ("*****************************************************\n");
    printf ("\n");

    GEI_READ_REG(INTEL_82543GC_STATUS, statusRegVal);
    if(statusRegVal&STATUS_LU_BIT)
    {
        printf(" Link status:              UP \n");
    }
    else
    {
        printf(" Link status:              DOWN \n");
    }

    gei82544PhyRead(pDrvCtrl, 1, PHY_CTRL_REG, &ctrlReg);
    if (ctrlReg&PCTRL_ANE_BIT)
    {
        printf(" Auto-Negotiation:         ENABLE \n");
    }
    else
    {
        printf(" Auto-Negotiation:         DISABLE\n");
    }
    /* get speed info */
    gei82543SpeedGet (pDrvCtrl);

    printf (" Device speed:                %d\n", pDrvCtrl->speed);

    /* get duplex info */
    gei82543DuplexGet (pDrvCtrl);

    printf (" Device duplex mode:          %s\n",
             (pDrvCtrl->duplex == FULL_DUPLEX_MODE) ?
             "FULL duplex": "HALF duplex");

    printf ("\n");

    printf (" Software Rx descriptor tail index:  %d\n", pDrvCtrl->rxDescTail);

    printf (" Software Tx descriptor tail index:  %d\n", pDrvCtrl->txDescTail);

    printf (" Tx descriptor last check index:     %d\n",
             pDrvCtrl->txDescLastCheck);

    printf (" Tx descriptor available number:     %d\n",
             pDrvCtrl->txDescFreeNum);
   
}
/***************************************************************************
*
* gei82543DumpCount - show statistic registers
*
* This routine dumps and shows statistic registers
*
* Note, statistics polling may cause this routine to display
* a lot of zeros, as these are clear-on-read registers, and
* gei82543HwStatusDump() and gei82543EndStatsDump() don't accumulate
* counts anywhere.
*
* \NOMANUAL
*
* RETURNS: N/A
*/
 void gei82543DumpCount
    (
    UINT8 unit            /* device unit */
    )
{
    END_DEVICE * pDrvCtrl;
    STA_REG * pStats;

    if ((unit<1)||(unit>MAX_IF_CARD_NUM))
    {
       printf("Invalid slot number!\n");
       return (void)ERROR;
    }
    if ((END_DEVICE *)NULL == (pDrvCtrl = gei82543Unit (unit)))
    {
        return (void)ERROR;
    }
    /* dump statistic registers */
    gei82543HwStatusDump (pDrvCtrl);

    /* print out statistic registers */
    pStats = &pDrvCtrl->staRegs;

    printf ("\n");

    printf (" CRC error count:             0x%x\n", pStats->crcerrs);

    printf (" Alignment error count:       0x%x\n", pStats->algnerrc);

    printf (" Symbol error count:          0x%x\n", pStats->symerrs);

    printf (" RX error count:              0x%x\n", pStats->rxerrc);

    printf (" Missed packet count:         0x%x\n", pStats->mpc);

    printf (" Single collision count:      0x%x\n", pStats->scc);

    printf (" Excessive collision count:   0x%x\n", pStats->ecol);

    printf (" Multiple collision count:    0x%x\n", pStats->mcc);

    printf (" late collision count:        0x%x\n", pStats->latecol);

    printf (" Collision count:             0x%x\n", pStats->colc);

    printf (" Transmit underrun count:     0x%x\n", pStats->tuc);

    printf (" Defer count:                 0x%x\n", pStats->dc);

    printf (" Transmit no CRS count:       0x%x\n", pStats->tncrs);

    printf (" Sequence error count:        0x%x\n", pStats->sec);

    printf (" Carrier extension err count: 0x%x\n",
              pStats->cexteer);

    printf (" Receive length error count:  0x%x\n\n", pStats->rlec);

    printf (" XON (received, transmitted):   (0x%x, 0x%x)\n",
        pStats->xonrxc, pStats->xontxc);

    printf (" XOFF (received, transmitted):  (0x%x, 0x%x)\n",
        pStats->xoffrxc, pStats->xofftxc);

    printf (" FC received unsupported count:\t0x%x\n",
              pStats->fcruc);

    printf ("\n");

    printf ("                  Packets Received    Packets Transmitted\n\n");

    printf (" 64 bytes         0x%-8x          0x%x\n",
        pStats->prc64, pStats->ptc64);

    printf (" 65-127 bytes     0x%-8x          0x%x\n",
        pStats->prc127, pStats->ptc127);

    printf (" 128-255 bytes    0x%-8x          0x%x\n",
        pStats->prc255, pStats->ptc255);

    printf (" 256-511 bytes    0x%-8x          0x%x\n",
        pStats->prc511, pStats->ptc511);

    printf (" 512-1023 bytes   0x%-8x          0x%x\n",
        pStats->prc1023, pStats->ptc1023);

    printf (" 1024-1522 bytes  0x%-8x          0x%x\n\n",
        pStats->prc1522, pStats->ptc1522);

    printf (" Total:           0x%-8x          0x%x\n",
        pStats->tpr, pStats->tpt);

    printf (" Good:            0x%-8x          0x%x\n",
        pStats->gprc, pStats->gptc);

    printf (" Broadcast:       0x%-8x          0x%x\n",
        pStats->bprc, pStats->bptc);

    printf (" Multicast:       0x%-8x          0x%x\n",
        pStats->mprc, pStats->mptc);

    printf ("\n");

    printf (" Total octets received:     0x%08x%08x\n",
        pStats->torh, pStats->torl);

    printf (" Good octets received:      0x%08x%08x\n",
        pStats->gorh, pStats->gorl);

    printf (" Total octets transmitted:  0x%08x%08x\n",
        pStats->toth, pStats->totl);

    printf (" Good octets transmitted:   0x%08x%08x\n\n",
        pStats->goth, pStats->gotl);

    printf (" Receive no buffer count:   0x%x\n", pStats->rnbc);

    printf (" Receive under size count:  0x%x\n",  pStats->ruc);

    printf (" Receive fragment count:    0x%x\n", pStats->rfc);

    printf (" Receive oversize count:    0x%x\n", pStats->roc);

    printf (" Receive jabber count:      0x%x\n", pStats->rjc);

    printf ("\n");

    printf ("                  RX Data FIFO    TX Data FIFO\n");

    printf (" head             0x%-8x      0x%x\n",
        pStats->rdfh, pStats->tdfh);
    printf (" tail             0x%-8x      0x%x\n",
        pStats->rdft, pStats->tdft);
    printf (" head saved       0x%-8x      0x%x\n",
        pStats->rdfhs, pStats->tdfhs);
    printf (" tail saved       0x%-8x      0x%x\n\n",
        pStats->rdfts, pStats->tdfts);

    printf ("*************************************************************\n");

    return;
}

/****************************************************************************
*
* gei82543RegGet - get the specified register value in 82543 chip
*
* This routine gets and shows the specified register value in 82543 chip
*
* RETURNS: Register value
*/
 UINT32 gei82543RegGet
    (
    int     unit,       /* device unit */
    UINT32  offset      /* register offset */
    )
{
    UINT32  regVal;
    END_DEVICE * pDrvCtrl;

    if (offset % 4 != 0)
    {
        printf ("Invalid register index\n");
        return 0;
    }

    if ( (pDrvCtrl = gei82543Unit (unit)) == NULL)
    {
        return 0;
    }

    GEI_READ_REG(offset, regVal);
    return regVal;
}

/****************************************************************************
*
* gei82543RegSet - set the specified register value
*
* This routine sets the specified register value
*
* RETURNS: N/A
*/
void gei82543RegSet
    (
    int     unit,       /* device unit */
    UINT32  offset,     /* register offset */
    UINT32  regVal      /* value to write */
    )
{
    END_DEVICE * pDrvCtrl; /* driver structure */

    if (offset % 4 != 0)
    {
        printf ("Invalid register index.\n");
        return;
    }

    if ( (pDrvCtrl = gei82543Unit (unit)) == (END_DEVICE *)NULL)
    {
        return (void)ERROR;
    }

    GEI_WRITE_REG(offset, regVal);

    return;
}

/****************************************************************************
*
* gei82543LedOn - turn on LED
*
* This routine turns LED on
*
* RETURNS: N/A
*/
 void gei82543LedOn
    (
    int unit        /* device unit */
    )
{
    UINT32 ctrlRegVal;      /* control register value */
    END_DEVICE * pDrvCtrl;  /* driver structure */

    if ((END_DEVICE *)NULL== (pDrvCtrl = gei82543Unit (unit)))
    {
        return;
    }

    GEI_READ_REG(INTEL_82543GC_CTRL, ctrlRegVal);

    ctrlRegVal |= (CTRL_SWDPIO0_BIT | CTRL_SWDPIN0_BIT);

    GEI_WRITE_REG(INTEL_82543GC_CTRL, ctrlRegVal);

    return;
}
/***************************************************************************
*
* gei82543LedOff - turn off LED
*
* This routine turns LED off
*
* RETURNS: N/A
*/
 void gei82543LedOff
    (
    int unit        /* device unit */
    )
{
    END_DEVICE * pDrvCtrl;  /* driver structure */
    UINT32 ctrlRegVal;      /* control register value */

    if ((END_DEVICE *)NULL== (pDrvCtrl = gei82543Unit (unit)))
    {
        return (void)ERROR;
    }

    GEI_READ_REG(INTEL_82543GC_CTRL, ctrlRegVal);

    ctrlRegVal |= CTRL_SWDPIO0_BIT;

    ctrlRegVal &= ~CTRL_SWDPIN0_BIT;

    GEI_WRITE_REG(INTEL_82543GC_CTRL, ctrlRegVal);

    return;
}
/***************************************************************************
*
* gei82543PhyRegSet - set the register value in PHY
*
* This routine returns the PHY's register value, or -1 if an error occurs.
*
* RETURNS: PHY's register value
*/
 int gei82543PhyRegSet
    (
    int unit,       /* device unit */
    int reg,         /* PHY's register */
    UINT16 tmp
    )
{
    END_DEVICE * pDrvCtrl; /* driver structure */

    if ((END_DEVICE *)NULL== (pDrvCtrl = gei82543Unit (unit)))
    {
        return ERROR;
    }

    gei82544PhyWrite (pDrvCtrl, pDrvCtrl->pPhyInfo->phyAddr, (UINT8)reg, tmp);

    printf ("PHY Device, Reg:%d, value:0x%x\n", reg, tmp);

    return tmp;
}
/***************************************************************************
*
* gei82543PhyRegGet - get the register value in PHY
*