gei82543end.c

intel 82543 千兆网卡 vxworks驱动源码

    (FUNCPTR) drv_MgeoCapacity,
    (FUNCPTR) drv_gei82543EndSend,      /* Send function for the driver. */
    (FUNCPTR) gei82543EndMCastAdd,  /* Multicast add function for the */
                                    /* driver. */
    (FUNCPTR) gei82543EndMCastDel,  /* Multicast delete function for */
                                    /* the driver. */
    (FUNCPTR) gei82543EndMCastGet,  /* Multicast retrieve function for */
                                    /* the driver. */
    };
 /*lint -restore*/

/***************************************************************************/
/*init mgeo*/
void gei82545Init(UINT8 slot)
{
    static int firstTimeFlag = 0;

    if ((0 != firstTimeFlag) ||(slot < 1) || (slot > MAX_IF_CARD_NUM))
    {
        return;
    }
    if (ERROR== sys543PciInit(slot) )
    {
        printf("Initializing gei82543Pci fail!\n");
        return;
    }

    if ( (DRV_OBJ*)NULL== gei82543EndLoad(slot))
    {
        printf("Create end device fail!\n");
        return;
    }
#if 0
    if(gei82545IsFx(slot))
    {
        if(ERROR==gei82543TBIModeSet(slot))
        {
            printf("Init gei82543End Fiber Device fail!\n");
            return;
        }
    }
#endif
    if(ERROR ==gei82543EndStart(slot))
    {
        printf("Starting gei82543End Device fail!\n");
        return;
    }
    /*add multicast address*/
    gei82543IsisSet(slot);

    return;
}

LOCAL STATUS gei82543TBIModeSet(UINT8 slot)
{
    UINT32 extDevCtrlRegVal;
    UINT32 ctrlRegval;
    END_DEVICE* pDrvCtrl;

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

     /* find the dev's end_device */
    if ((pDrvCtrl = gei82543Unit(slot)) == (END_DEVICE*)NULL)
    {
        return ERROR;
    }

    /*Make sure the Tx/Rx is disabled by RCTL.EN= TCTL.EN = 0b*/
    gei82543TxRxDisable(pDrvCtrl);
    
    /*Set Link Mode to internal SerDes by CTRL_EXT.Link_Mode=10b*/
    GEI_READ_REG(INTEL_82543GC_CTRL_EXT, extDevCtrlRegVal);
    GEI_WRITE_REG(INTEL_82543GC_CTRL_EXT, extDevCtrlRegVal|CTRL_EXT_LINKMODEF_BIT);

    /*Set AN by TXCW.ANE=1b*/
    GEI_WRITE_REG(INTEL_82543GC_TXCW, pDrvCtrl->txConfigureWord);
    
    /* Reset PHY by CTRL.PHY_RST =1b,  wait for 10ms, then clear the reset.*/
    GEI_READ_REG(INTEL_82543GC_CTRL, ctrlRegval);
    GEI_WRITE_REG(INTEL_82543GC_CTRL, ctrlRegval |CTRL_PHY_RST_BIT);

    /*pause for 10ms*/
    taskDelay(sysClkRateGet() / 10);
    GEI_WRITE_REG(INTEL_82543GC_CTRL, ctrlRegval);
    
    return OK;

}


/*************************************************************************
*
* gei82543EndLoad - initialize the driver and device
*
* This routine initializes the driver and the device to the operational state.
* All of the device specific parameters are passed in the initString.
*
* The string contains the target specific parameters like this:
* "unitnum:shmem_addr:shmem_size:rxDescNum:txDescNum:usrFlags:offset:mtu"
*
* RETURNS: an END object pointer, NULL if error, or zero
*/

DRV_OBJ* gei82543EndLoad
    (
    UINT8 slot       /* slot no. passed by the driver. */
    )
 {
    END_DEVICE *    pDrvCtrl; /* pointer to device structure */
    UCHAR               enetAddr[6];
    DRV_LOG (DRV_DEBUG_LOAD, "Loading gei82543End Driver...\n",
                              1, 2, 3, 4, 5, 6);

    if ((slot < 1) || (slot > MAX_IF_CARD_NUM))
    {
        return (DRV_OBJ*)ERROR;
    }

    /* allocate the device structure */
    pDrvCtrl = (END_DEVICE *)calloc (sizeof (END_DEVICE), 1);

    if ((END_DEVICE * )NULL ==pDrvCtrl)
    {
        goto errorExit;
    }

    geiEndDevice[slot]=pDrvCtrl;

    /* clean up driver structure */
    memset((void *)pDrvCtrl, 0, sizeof (END_DEVICE));

    /* call BSP routine to get PCI information*/
    if (sys82543BoardInit (slot, &pDrvCtrl->adaptor) != OK)
    {
        DRV_LOG (DRV_DEBUG_LOAD, "Error in getting board info\n", 1, 2, 3, 4, 5, 6);
        goto errorExit;
    }

    /* set up the base register */
    pDrvCtrl->devRegBase =pDrvCtrl->adaptor.regBaseLow;

    pDrvCtrl->mtu = ETHERMTU;

    /* perform memory allocation for descriptors */
    if (ERROR ==gei82543EndMemInit (pDrvCtrl))
    {
        DRV_LOG (DRV_DEBUG_LOAD, "Error in memory init\n", 1, 2, 3, 4, 5, 6);

        goto errorExit;
    }

    pDrvCtrl->txResoFreeQuick = TRUE;

    /*Initialization the DRV_OBJ*/
    pDrvCtrl->drvObj.slot = slot;
    pDrvCtrl->drvObj.txSem = semBCreate (SEM_Q_FIFO, SEM_FULL);
    if ((SEM_ID)NULL == pDrvCtrl->drvObj.txSem)
    {
        goto errorExit;
    }

    IF_DRV_TX_SEM_GIVE(&pDrvCtrl->drvObj);
    pDrvCtrl->drvObj.pFuncTable = &gei82543EndFuncTable;

    /* Check and control the length of the name string. */
    strcpy (pDrvCtrl->drvObj.name, DEVICE_NAME);

    /* Enet MAC address. */
    memcpy ((char *)&pDrvCtrl->drvObj.ifPhysAddress.phyAddress[0], (char *)pDrvCtrl->adaptor.enetAddr, ETHER_ADDRESS_SIZE);
    pDrvCtrl->drvObj.ifPhysAddress.addrLength = ETHER_ADDRESS_SIZE;

    bcopy ((char *)pDrvCtrl->adaptor.enetAddr,
       (char *)&enetAddr[0],
       ETHER_ADDRESS_SIZE);


    DRV_LOG (DRV_DEBUG_LOAD, ("gei82543Load...\n
             ADRR: 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x \n "),
            enetAddr[0],
            enetAddr[1],
            enetAddr[2],
            enetAddr[3],
            enetAddr[4],
            enetAddr[5]);


#ifdef INCLUDE_TBI_COMPATIBLE
    pDrvCtrl->tbiCompatibility = FALSE;
#endif /* INCLUDE_TBI_COMPATIBLE */

    /* stop/reset the chip before configuration */
    gei82543Reset (pDrvCtrl);

    /* disable all chip interrupt */
    gei82543DisableChipInt (pDrvCtrl);

    /* turn off system interrupts */
    b_pciUnitIntDisable((UINT8)pDrvCtrl->drvObj.slot);
    /*b_cintDisable(pDrvCtrl->drvObj.slot);*/
    /* set the default value for device */
    pDrvCtrl->rxIntDelay      = DEFAULT_RXINT_DELAY;
    pDrvCtrl->maxRxNumPerInt  = DEFAULT_RXRES_PROCESS_FACTOR * pDrvCtrl->rxDescNum;
    pDrvCtrl->flowCtrl        = DEFAULT_FLOW_CONTRL;
    pDrvCtrl->duplex          = DEFAULT_DUPLEX_MODE;
    pDrvCtrl->speed           = DEFAULT_END_SPEED;
    /* Misc. setting */
    pDrvCtrl->flags          =DEFAULT_DRV_FLAGS;
    pDrvCtrl->linkStatus     = LINK_STATUS_UNKNOWN;
    pDrvCtrl->linkMethod     = GEI82543_HW_AUTO;
    pDrvCtrl->txConfigureWord     = (TXCW_ANE_BIT | TXCW_FD_BIT);
    pDrvCtrl->multiCastFilterType = DEFAULT_MULTI_FILTER_TYPE;
    pDrvCtrl->attach         = FALSE;
    pDrvCtrl->devStartFlag   = FALSE;

    bzero ((char *)&pDrvCtrl->statscounters, sizeof(END_STATS));

    /* disable RX/TX operations now, will be re-enable in Start function */
    gei82543TxRxDisable (pDrvCtrl);

    pDrvCtrl->attach = TRUE;

    DRV_LOG (DRV_DEBUG_LOAD, ("loading gei82543End...OK\n"),1,2,3,4,5,6);
    drv_regSndFunc(pDrvCtrl->drvObj.slot, (FUNCPTR)drv_gei82543EndSend); /*lint !e64*/

    return (&pDrvCtrl->drvObj);

errorExit:
    /* free all allocated memory */
    gei82543MemAllFree (pDrvCtrl);   /*lint !e961*/

    DRV_LOG (DRV_DEBUG_LOAD, ("Loading gei82543End...Error\n"),
                               1, 2, 3, 4, 5, 6);
    return (DRV_OBJ*)NULL;
}
/*************************************************************************
*
* gei82543MemAllFree - free all memory allocated by driver
*
* This routine returns all allocated memory by this driver to OS
*
* RETURN: N/A
*/
LOCAL void gei82543MemAllFree
    (
    END_DEVICE * pDrvCtrl    /* device to be initialized */
    )
{
    if ( (END_DEVICE *) NULL==pDrvCtrl)
    {
        return;
    }

    /* release TX/RX descriptors and RX buffer */
    if ((NULL !=pDrvCtrl->pMemBase)&& (TRUE ==pDrvCtrl->memAllocFlag))
    {
        cacheDmaFree (pDrvCtrl->pMemBase);
        pDrvCtrl->pMemBase = (char*)NULL;
    }
    /* free RX buffer memory */
    if ( NULL !=pDrvCtrl->pRxBufMem)
    {
        free (pDrvCtrl->pRxBufMem);
        pDrvCtrl->pRxBufMem = (char *)NULL;
    }
    /* free allocated memory if necessary */
    cfree ((char *)pDrvCtrl);

    return;
}

/*************************************************************************
*
* gei82543EndMemInit - allocate and initialize memory for driver
*
* This routine allocates and initializes memory for descriptors and
* corresponding buffers, and sets up the receive data pool for receiving
* packets.
*
* RETURNS: OK or ERROR.
*/
LOCAL STATUS gei82543EndMemInit
    (
    END_DEVICE * pDrvCtrl    /* device to be initialized */
    )
{
    UINT32      size;           /* required memory size */

    DRV_LOG (DRV_DEBUG_LOAD, ("gei82543EndMemInit...\n"), 1, 2, 3, 4, 5, 6);

    /* set the default TX/RX descriptor Number */
    if ( 0 ==pDrvCtrl->txDescNum)
    {
        pDrvCtrl->txDescNum = GEI_DEFAULT_TXDES_NUM;
    }

    if (0 ==pDrvCtrl->rxDescNum )
    {
        pDrvCtrl->rxDescNum = GEI_DEFAULT_RXDES_NUM;
    }

    /* round up to multiple of 8, hardware requirement */
    pDrvCtrl->txDescNum = ROUND_UP_MULTIPLE(pDrvCtrl->txDescNum,
                                           INTEL_82543GC_MULTIPLE_DES);

    pDrvCtrl->rxDescNum = ROUND_UP_MULTIPLE((UINT32)pDrvCtrl->rxDescNum,
                                         (UINT32)INTEL_82543GC_MULTIPLE_DES);
    /*receive buffer size*/
    pDrvCtrl->rxBufSize = 2048;
    pDrvCtrl->memAllocFlag=FALSE;
    /* Check or allocate memory for descriptors */
    size = (UINT32)(pDrvCtrl->txDescNum * TXDESC_SIZE +   /* for TX descriptor */
               pDrvCtrl->rxDescNum * RXDESC_SIZE +   /* for RX descriptor */
               512);                                  /* alignment */

    /* alloc memory in driver for TX/RX area*/
    pDrvCtrl->pMemBase = (char *)cacheDmaMalloc (size);

    if ((char *)NULL ==pDrvCtrl->pMemBase )      /* no memory available */
    {
        DRV_LOG (DRV_DEBUG_LOAD, ("gei82543EndMemInit: could not obtain "
                  "memory\n"), 1, 2, 3, 4, 5, 6);
        return ERROR;
    }
    /*total memeory for TX/RX area*/
    pDrvCtrl->memSize = size;
    pDrvCtrl->memAllocFlag=TRUE;
    /* zero the pre-provided or allocated memory */
    memset((void *)pDrvCtrl->pMemBase, 0, size);

    /* set the TX descriptor base address, align to 128 byte */
    pDrvCtrl->pTxDescBase = (char *)(((UINT32)(pDrvCtrl->pMemBase) +
                                      (GEI_DESC_ALIGN_BYTE - 1)) &
                                      ~(GEI_DESC_ALIGN_BYTE - 1));

    /* set the RX descriptor base Address */
    pDrvCtrl->pRxDescBase = (char *)GEI_GET_TX_DESC_ADDR(pDrvCtrl->txDescNum);

    CACHE_PIPE_FLUSH ();  /*lint !e522*/

    DRV_LOG (DRV_DEBUG_LOAD, "gei82543EndMemInit...OK\n", 1, 2, 3, 4, 5, 6);


    return (OK);
    }
/*************************************************************************
*
* gei82543EndStart - setup and start the device
*
* This routine connects interrupts, initializes receiver and transmitter,
* and enable the device for running
* Argument:
*    UINT8 slot  - slot number
*
* RETURNS: OK or ERROR
*/
STATUS gei82543EndStart
    (
    UINT8 slot  /* device ID */
    )
{

    /*int result;            results of start device */
    END_DEVICE * pDrvCtrl=(END_DEVICE *)NULL;
    if (slot<1||slot >MAX_IF_CARD_NUM)
    {
        return ERROR;
    }

    pDrvCtrl = geiEndDevice[slot];

    if ((END_DEVICE *)NULL==pDrvCtrl )
    {