gei82543end.c

操作系统vxworks平台下end设备的驱动程序,支持多种芯片,支持多种cpu

    DRV_LOG (DRV_DEBUG_LOAD, "Loading gei82543End Driver...\n", 
                              1, 2, 3, 4, 5, 6);
    /* sanity check */

    if (initString == NULL)
       return NULL;

    if (initString[0] == 0)
       {
       bcopy ((char *) DEVICE_NAME, (void *)initString, DEVICE_NAME_LENGTH);
       return 0;
       }

    /* allocate the device structure */

    pDrvCtrl = (END_DEVICE *)calloc (sizeof (END_DEVICE), 1);

    if (pDrvCtrl == NULL)
        goto errorExit;

    /* clean up driver structure */

    memset((void *)pDrvCtrl, 0, sizeof (END_DEVICE));

    /* parse the init string, filling in the device structure */

    if (gei82543EndParse (pDrvCtrl, initString) == ERROR)
        goto errorExit;

    /* zero adaptor structure */

    memset ((void *)&pDrvCtrl->adaptor, 0, sizeof(ADAPTOR_INFO));

    /* call BSP routine to get PCI information*/

    if (sys82543BoardInit (pDrvCtrl->unit, &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 = (UINT32)(pDrvCtrl->adaptor.regBaseLow);

    /* set up device structure based on user's flags */
    if (pDrvCtrl->usrFlags & GEI_END_JUMBO_FRAME_SUPPORT)
        {
        if (pDrvCtrl->mtu <= 0)
            pDrvCtrl->mtu = GEI_DEFAULT_JUMBO_MTU_SIZE;
        
        pDrvCtrl->mtu = (pDrvCtrl->mtu <= ETHERMTU)? ETHERMTU :
                  ((pDrvCtrl->mtu > GEI_MAX_JUMBO_MTU_SIZE)? 
                  GEI_MAX_JUMBO_MTU_SIZE : pDrvCtrl->mtu);
        }
    else  /* normal frame */
        pDrvCtrl->mtu = ETHERMTU;

    /* increase transmit storage in FIFO for jumbo frames */
  
    if (pDrvCtrl->mtu > ETHERMTU)
        {
        GEI_WRITE_REG(INTEL_82543GC_PBA, 0x20); /* 24KB for TX buffer */
        }

    /* perform memory allocation for descriptors */

    if (gei82543EndMemInit (pDrvCtrl) == ERROR)
        goto errorExit;

    /* set up device structure based on user's flags */
   
    if (pDrvCtrl->usrFlags & GEI_END_SET_TIMER)
        {
        pDrvCtrl->timerId = wdCreate ();
        if (pDrvCtrl->timerId == NULL)
            DRV_LOG (DRV_DEBUG_LOAD, ("create timer fails\n"), 
                                      1, 2, 3, 4, 5, 6);
        }

    if (pDrvCtrl->usrFlags & GEI_END_SET_RX_PRIORITY)
        pDrvCtrl->dmaPriority = DMA_RX_PRIORITY;
    else
        pDrvCtrl->dmaPriority = DMA_FAIR_RX_TX;

    if (pDrvCtrl->usrFlags & GEI_END_FREE_RESOURCE_DELAY)
        {
        pDrvCtrl->txIntDelay  = TXINT_DELAY_MORE;
        pDrvCtrl->txResoFreeQuick = FALSE;
        }
    else
        {
        pDrvCtrl->txIntDelay  = TXINT_DELAY_LESS;
        pDrvCtrl->txResoFreeQuick = TRUE; 
        }

#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 */

    SYS_INT_DISABLE(pDrvCtrl);

    /* set the default value for device */

    pDrvCtrl->rxIntDelay     = DEFAULT_RXINT_DELAY;
    pDrvCtrl->maxRxNumPerInt = DEFAULT_RXRES_PROCESS_FACTOR * 
                               pDrvCtrl->rxDescNum;
    pDrvCtrl->timerInterval  = DEFAULT_TIMER_INTERVAL;
    pDrvCtrl->flowCtrl       = DEFAULT_FLOW_CONTRL;   
    pDrvCtrl->duplex         = DEFAULT_DUPLEX_MODE;
     
    /* Misc. setting */

    pDrvCtrl->flags          = 0;
    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;

    /* initialize the END and MIB2 parts of the structure */
    /*
     * The M2 element must come from m2Lib.h 
     * This setting is for a DIX type ethernet device.
     */

#ifdef INCLUDE_RFC_1213
    
    if (END_OBJ_INIT (&pDrvCtrl->end, (DEV_OBJ *)pDrvCtrl, DEVICE_NAME,
                      pDrvCtrl->unit, &gei82543EndFuncTable,
                      "gei82543End Driver.") == ERROR || 
        END_MIB_INIT (&pDrvCtrl->end, M2_ifType_ethernet_csmacd,
                      &pDrvCtrl->adaptor.enetAddr[0], 6, pDrvCtrl->mtu,
                      END_SPEED) == ERROR )
        goto errorExit;

#else /* !INCLUDE_RFC_1213 */

    bzero ((char *)&pDrvCtrl->endStatsCounters, sizeof(END_IFCOUNTERS));

    pDrvCtrl->endStatsConf.ifPollInterval = sysClkRateGet();
    pDrvCtrl->endStatsConf.ifEndObj = &pDrvCtrl->end;
    pDrvCtrl->endStatsConf.ifWatchdog = NULL;
    pDrvCtrl->endStatsConf.ifValidCounters = (END_IFINUCASTPKTS_VALID |
        END_IFINMULTICASTPKTS_VALID | END_IFINBROADCASTPKTS_VALID |
        END_IFINOCTETS_VALID | END_IFOUTOCTETS_VALID | END_IFOUTUCASTPKTS_VALID |
        END_IFOUTMULTICASTPKTS_VALID | END_IFOUTBROADCASTPKTS_VALID);

    if (END_OBJ_INIT (&pDrvCtrl->end, (DEV_OBJ *)pDrvCtrl, DEVICE_NAME,
                      pDrvCtrl->unit, &gei82543EndFuncTable,
                      "gei82543End Driver.") == ERROR)
        goto errorExit;

    /* New RFC 2233 mib2 interface */

    /* Initialize MIB-II entries (for RFC 2233 ifXTable) */

    pDrvCtrl->end.pMib2Tbl = m2IfAlloc(M2_ifType_ethernet_csmacd,
                                          (UINT8*) &pDrvCtrl->adaptor.enetAddr[0], 6,
                                          pDrvCtrl->mtu, 1000000000,
                                          "gei", pDrvCtrl->unit);

    if (pDrvCtrl->end.pMib2Tbl == NULL)
        {
        DRV_LOG (DRV_DEBUG_LOAD, ("%s%d - MIB-II initializations failed\n"),
                "gei", pDrvCtrl->unit, 3, 4, 5, 6);
        goto errorExit;
        }

    /*
     * Set the RFC2233 flag bit in the END object flags field and
     * install the counter update routines.
     */

    m2IfPktCountRtnInstall(pDrvCtrl->end.pMib2Tbl, m2If8023PacketCount);

    /*
     * Make a copy of the data in mib2Tbl struct as well. We do this
     * mainly for backward compatibility issues. There might be some
     * code that might be referencing the END pointer and might
     * possibly do lookups on the mib2Tbl, which will cause all sorts
     * of problems.
     */

    bcopy ((char *)&pDrvCtrl->end.pMib2Tbl->m2Data.mibIfTbl,
                   (char *)&pDrvCtrl->end.mib2Tbl, sizeof (M2_INTERFACETBL));

    END_OBJ_READY (&pDrvCtrl->end, (IFF_UP | IFF_RUNNING | IFF_NOTRAILERS |
                    IFF_BROADCAST | IFF_MULTICAST | END_MIB_2233));
#endif /* INCLUDE_RFC_1213 */

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

    return (&pDrvCtrl->end);

errorExit:

    /* free all allocated memory */

    gei82543MemAllFree (pDrvCtrl);

    if (pDrvCtrl != NULL)
         free ((char *)pDrvCtrl);

    DRV_LOG (DRV_DEBUG_LOAD, ("Loading gei82543End...Error\n"), 
                               1, 2, 3, 4, 5, 6);
    return NULL;
    }

/*************************************************************************
*
* gei82534EndParse - parse the init string
*
* Parse the input string.  Fill in values in the driver control structure.
*
* RETURNS: OK or ERROR for invalid arguments.
*/

LOCAL STATUS gei82543EndParse
    (
    END_DEVICE *    pDrvCtrl,       /* device pointer */
    char *          initString      /* information string */
    )
    {
    char *    tok;
    char *    pHolder = NULL;

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

    /* parse the initString */

    tok = strtok_r (initString, ":", &pHolder);
    if (tok == NULL)
    return ERROR;
    pDrvCtrl->unit = atoi (tok);
 
    /* address of shared memory */

    tok = strtok_r (NULL, ":", &pHolder);
    if (tok == NULL)
    return ERROR;
    pDrvCtrl->pMemBase = (char *) strtoul (tok, NULL, 16);
 
    /* size of shared memory */

    tok = strtok_r (NULL, ":", &pHolder);
    if (tok == NULL)
    return ERROR;
    pDrvCtrl->memSize = strtoul (tok, NULL, 16);

    /* number of rx descriptors */

    tok = strtok_r (NULL, ":", &pHolder);
    if (tok == NULL)
     return ERROR;
    pDrvCtrl->rxDescNum = strtoul (tok, NULL, 16);

    /* number of tx descriptors */

    tok = strtok_r (NULL, ":", &pHolder);
    if (tok == NULL)
    return ERROR;
    pDrvCtrl->txDescNum = strtoul (tok, NULL, 16);
   
    /* get the usrFlags */

    tok = strtok_r (NULL, ":", &pHolder);
    if (tok == NULL)
    return ERROR;
    pDrvCtrl->usrFlags = strtoul (tok, NULL, 16);

    /* get the offset value */

    tok = strtok_r (NULL, ":", &pHolder);
    if (tok != NULL)
        pDrvCtrl->offset = atoi (tok);

    DRV_LOG (DRV_DEBUG_LOAD,
            ("gei82543EndParse: unit=%d pMemBase=0x%x memSize=0x%x
              rxDescNums=%d txDescNum=%d, usrFlags=0x%x\n"),
              pDrvCtrl->unit, 
              (int)pDrvCtrl->pMemBase,
              (int) pDrvCtrl->memSize,
              pDrvCtrl->rxDescNum,
              pDrvCtrl->txDescNum,
              pDrvCtrl->usrFlags
              );

    /* check Jumbo Frame support */

    if (pDrvCtrl->usrFlags & GEI_END_JUMBO_FRAME_SUPPORT)
        {        
        /* get mtu */

        tok = strtok_r (NULL, ":", &pHolder);
        if (tok != NULL)
            pDrvCtrl->mtu = atoi (tok);

        DRV_LOG (DRV_DEBUG_LOAD, ("mtu = %d\n"),pDrvCtrl->mtu, 
                 2, 3, 4, 5, 6);
        }

    return OK;
    }

/*************************************************************************
*
* 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 (pDrvCtrl == NULL)
        return;

    /* release TxDesCtl */

    if (pDrvCtrl->pTxDesCtlBase != NULL)
        {
        free (pDrvCtrl->pTxDesCtlBase);
        }

    if (pDrvCtrl->pRxBufVirtAddr != NULL)
        {
        free (pDrvCtrl->pRxBufVirtAddr);
        }

    if (pDrvCtrl->pTxPollBufAdr != NULL)
        {
        cacheDmaFree (pDrvCtrl->pTxPollBufAdr);
        }

    /* release TX/RX descriptors and RX buffer */

    if (pDrvCtrl->pMemBase != NULL && (pDrvCtrl->memAllocFlag == TRUE))
        {
        cacheDmaFree (pDrvCtrl->pMemBase);
        }

    /* free RX buffer memory */