motfecend.c

vxworks源码源码解读是学习vxworks的最佳途径

END_OBJ *	motFecEndLoad (char *initString);    
LOCAL STATUS    motFecStart (DRV_CTRL *pDrvCtrl);
LOCAL STATUS	motFecUnload (DRV_CTRL *pDrvCtrl);
LOCAL STATUS    motFecStop (DRV_CTRL *pDrvCtrl);
LOCAL int       motFecIoctl (DRV_CTRL *pDrvCtrl, int cmd, caddr_t data);
LOCAL STATUS    motFecSend (DRV_CTRL *pDrvCtrl, M_BLK_ID pMblk);
LOCAL STATUS    motFecMCastAddrAdd (DRV_CTRL *pDrvCtrl, char* pAddress);
LOCAL STATUS    motFecMCastAddrDel (DRV_CTRL *pDrvCtrl, char* pAddress);
LOCAL STATUS    motFecMCastAddrGet (DRV_CTRL *pDrvCtrl,
                                        MULTI_TABLE *pTable);
LOCAL STATUS    motFecPollSend (DRV_CTRL *pDrvCtrl, M_BLK_ID pMblk);
LOCAL STATUS    motFecPollReceive (DRV_CTRL *pDrvCtrl, M_BLK_ID pMblk);
LOCAL STATUS    motFecPollStart (DRV_CTRL *pDrvCtrl);
LOCAL STATUS    motFecPollStop (DRV_CTRL *pDrvCtrl);

/* globals */

FUNCPTR _func_motFecPhyInit = (FUNCPTR) motFecPhyInit;
FUNCPTR _func_motFecHbFail = (FUNCPTR) NULL;

#ifdef MOT_FEC_DBG
void motFecCsrShow (void);
void motFecRbdShow (int);
void motFecTbdShow (int);
void motFecErrorShow (void);
void motFecDrvShow (void);
void motFecMiiShow (void);
void motFecMibShow (void);

#endif /* MOT_FEC_DBG */

/* 
 * Define the device function table.  This is static across all driver
 * instances.
 */

LOCAL NET_FUNCS netFuncs = 
    {
    (FUNCPTR) motFecStart,		/* start func. */		 
    (FUNCPTR) motFecStop,		/* stop func. */
    (FUNCPTR) motFecUnload,		/* unload func. */		
    (FUNCPTR) motFecIoctl,		/* ioctl func. */		 
    (FUNCPTR) motFecSend,		/* send func. */		  
    (FUNCPTR) motFecMCastAddrAdd,    	/* multicast add func. */	 
    (FUNCPTR) motFecMCastAddrDel,    	/* multicast delete func. */      
    (FUNCPTR) motFecMCastAddrGet,    	/* multicast get fun. */	  
    (FUNCPTR) motFecPollSend,    	/* polling send func. */	  
    (FUNCPTR) motFecPollReceive,    	/* polling receive func. */
    endEtherAddressForm,   		/* put address info into a NET_BUFFER */
    (FUNCPTR) endEtherPacketDataGet, 	/* get pointer to data in NET_BUFFER */
    (FUNCPTR) endEtherPacketAddrGet  	/* Get packet addresses */
    };		

/*******************************************************************************
*
* motFecEndLoad - initialize the driver and device
*
* This routine initializes both driver and device to an operational state
* using device specific parameters specified by <initString>.
*
* The parameter string, <initString>, is an ordered list of parameters each
* separated by a colon. The format of <initString> is:
*
* "<motCpmAddr>:<ivec>:<bufBase>:<bufSize>:<fifoTxBase>:<fifoRxBase>
* :<tbdNum>:<rbdNum>:<phyAddr>:<isoPhyAddr>:<phyDefMode>:<userFlags>"
*
* The FEC shares a region of memory with the driver.  The caller of this
* routine can specify the address of this memory region, or can specify that
* the driver must obtain this memory region from the system resources.
*
* A default number of transmit/receive buffer descriptors of 32 can be 
* selected by passing zero in the parameters <tbdNum> and <rbdNum>. 
* In other cases, the number of buffers selected should be greater than two.
*
* The <bufBase> parameter is used to inform the driver about the shared
* memory region.  If this parameter is set to the constant "NONE," then this
* routine will attempt to allocate the shared memory from the system.  Any
* other value for this parameter is interpreted by this routine as the address
* of the shared memory region to be used. The <bufSize> parameter is used
* to check that this region is large enough with respect to the provided
* values of both transmit/receive buffer descriptors.
*
* If the caller provides the shared memory region, then the driver assumes
* that this region does not require cache coherency operations, nor does it
* require conversions between virtual and physical addresses.
*
* If the caller indicates that this routine must allocate the shared memory
* region, then this routine will use cacheDmaMalloc() to obtain
* some  cache-safe memory.  The attributes of this memory will be checked,
* and if the memory is not write coherent, this routine will abort and
* return NULL.
*
* RETURNS: an END object pointer, or NULL on error.
*
* SEE ALSO: ifLib,
* .I "MPC860T Fast Ethernet Controller (Supplement to MPC860 User's Manual)"
*/

END_OBJ* motFecEndLoad
    (
    char *initString      /* parameter string */
    )
    {
    DRV_CTRL *	pDrvCtrl = NULL;	/* pointer to DRV_CTRL structure */
    UCHAR   	enetAddr[6];		/* ethernet address */

    MOT_FEC_LOG (MOT_FEC_DBG_LOAD, ("Loading end...\n"), 1, 2, 3, 4, 5, 6);

    if (initString == NULL)
	return (NULL);

    if (initString[0] == NULL)
	{
	bcopy ((char *)MOT_FEC_DEV_NAME, (void *)initString, 
		MOT_FEC_DEV_NAME_LEN);
	return (0);
	}

    /* allocate the device structure */

    pDrvCtrl = (DRV_CTRL *) calloc (sizeof (DRV_CTRL), 1);
    if (pDrvCtrl == NULL)
	return (NULL);

#ifdef MOT_FEC_DBG
    pDrvCtrlDbg = pDrvCtrl;
#endif /* MOT_FEC_DBG */

    /* Parse InitString */

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

    pDrvCtrl->ilevel = (int) IVEC_TO_ILEVEL (pDrvCtrl->ivec);

    /* sanity check the unit number */

    if (pDrvCtrl->unit < 0 )
	goto errorExit;    

    /* memory initialization */

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

    /* get our ethernet hardware address */

    SYS_FEC_ENET_ADDR_GET (enetAddr);

    MOT_FEC_LOG (MOT_FEC_DBG_LOAD, ("motFecEndLoad: enetAddr= 
				    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]);

    /* initialize some flags */

    pDrvCtrl->loaded = TRUE;
    pDrvCtrl->intrConnect = FALSE;

    /* 
     * create the synchronization semaphores for mii intr handling 
     * and for graceful transmit command interrupts. 
     */

    MOT_FEC_MII_SEM_CREATE;
    MOT_FEC_GRA_SEM_CREATE;

    /* endObj initializations */

    if (END_OBJ_INIT (&pDrvCtrl->endObj, (DEV_OBJ*) pDrvCtrl,
		      MOT_FEC_DEV_NAME, pDrvCtrl->unit, &netFuncs,
		      "Motorola FEC Ethernet Enhanced Network Driver") 
	== ERROR)
	goto errorExit;

    pDrvCtrl->phyInfo->phySpeed = MOT_FEC_10MBS;
    if (END_MIB_INIT (&pDrvCtrl->endObj, M2_ifType_ethernet_csmacd, 
		      (u_char *) &enetAddr[0], MOT_FEC_ADDR_LEN,
		      ETHERMTU, pDrvCtrl->phyInfo->phySpeed) == ERROR)
	goto errorExit;

    /* Mark the device ready */

    END_OBJ_READY (&pDrvCtrl->endObj,
                   IFF_NOTRAILERS | IFF_MULTICAST | IFF_BROADCAST);

    MOT_FEC_LOG (MOT_FEC_DBG_LOAD, ("motFecEndLoad... Done \n"), 
				    1, 2, 3, 4, 5, 6);

    return (&pDrvCtrl->endObj);

errorExit:
    motFecUnload (pDrvCtrl);
    free ((char *) pDrvCtrl);
    return NULL;

    }

/*******************************************************************************
*
* motFecUnload - unload a driver from the system
*
* This routine unloads the driver pointed to by <pDrvCtrl> from the system.
*
* RETURNS: OK, always.
*
* SEE ALSO: motFecLoad()
*/
LOCAL STATUS motFecUnload
    (
    DRV_CTRL	*pDrvCtrl       /* pointer to DRV_CTRL structure */
    )
    {
    int		ix = 0;		/* a counter */

    MOT_FEC_LOG (MOT_FEC_DBG_LOAD, ("Unloading end..."), 1, 2, 3, 4, 5, 6);

    if (pDrvCtrl == NULL)
	return (ERROR);

    pDrvCtrl->loaded = FALSE;

    /* free lists */

    for (ix = 0; ix < pDrvCtrl->tbdNum; ix++)
	{
	cfree ((char *) pDrvCtrl->pTbdList [ix]);
	}

    END_OBJECT_UNLOAD (&pDrvCtrl->endObj);

    /* free allocated memory if necessary */

    if ((MOT_FEC_FLAG_ISSET (MOT_FEC_OWN_MEM)) && 
	(pDrvCtrl->pBufBase != NULL))
	cacheDmaFree (pDrvCtrl->pBufBase);

    /* free allocated memory if necessary */

    if ((pDrvCtrl->pMBlkArea) != NULL)
	free (pDrvCtrl->pMBlkArea);

    cfree ((char *) pDrvCtrl);

    /* free the semaphores if necessary */

    MOT_FEC_MII_SEM_DELETE;
    MOT_FEC_GRA_SEM_DELETE;

    MOT_FEC_LOG (MOT_FEC_DBG_LOAD, ("motFecUnload... Done\n"), 
				    1, 2, 3, 4, 5, 6);

    return (OK);
    }

/*******************************************************************************
*
* motFecInitParse - parse parameter values from initString
*
* This routine parses parameter values from initString and stores them in
* the related fiels of the driver control structure.
*
* RETURNS: OK or ERROR
*/
LOCAL STATUS motFecInitParse
    (
    DRV_CTRL *	pDrvCtrl,      		/* pointer to DRV_CTRL structure */
    char *	initString		/* parameter string */
    )
    {
    char *  tok;		/* an initString token */
    char *  holder = NULL;	/* points to initString fragment beyond tok */

    tok = strtok_r (initString, ":", &holder);
    if (tok == NULL)
	return ERROR;
    pDrvCtrl->unit = atoi (tok);

    tok = strtok_r (NULL, ":", &holder);
    if (tok == NULL)
	return ERROR;
    pDrvCtrl->motCpmAddr = (UINT32) strtoul (tok, NULL, 16);

    tok = strtok_r (NULL, ":", &holder);
    if (tok == NULL)
	return ERROR;
    pDrvCtrl->ivec = (int) strtoul (tok, NULL, 16);

    tok = strtok_r (NULL, ":", &holder);
    if (tok == NULL)
	return ERROR;
    pDrvCtrl->pBufBase = (char *) strtoul (tok, NULL, 16);

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

    tok = strtok_r (NULL, ":", &holder);
    if (tok == NULL)
	return ERROR;
    pDrvCtrl->fifoTxBase = (UINT32) strtoul (tok, NULL, 16);

    tok = strtok_r (NULL, ":", &holder);
    if (tok == NULL)
	return ERROR;
    pDrvCtrl->fifoRxBase = (UINT32) strtoul (tok, NULL, 16);

    tok = strtok_r (NULL, ":", &holder);
    if (tok == NULL)
	return ERROR;
    pDrvCtrl->tbdNum = (UINT16) strtoul (tok, NULL, 16);

    tok = strtok_r (NULL, ":", &holder);
    if (tok == NULL)
	return ERROR;
    pDrvCtrl->rbdNum = (UINT16) strtoul (tok, NULL, 16);

    tok = strtok_r (NULL, ":", &holder);
    if (tok == NULL)
	return ERROR;
    pDrvCtrl->phyInfo->phyAddr = (UINT8) strtoul (tok, NULL, 16);

    tok = strtok_r (NULL, ":", &holder);
    if (tok == NULL)
	return ERROR;
    pDrvCtrl->phyInfo->isoPhyAddr = (UINT8) strtoul (tok, NULL, 16);

    tok = strtok_r (NULL, ":", &holder);
    if (tok == NULL)
        return ERROR;
    pDrvCtrl->phyInfo->phyDefMode = (UINT8) strtoul (tok, NULL, 16);

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

    if (!pDrvCtrl->tbdNum || pDrvCtrl->tbdNum <= 2)
	{
	MOT_FEC_FLAG_SET (MOT_FEC_INV_TBD_NUM);
	pDrvCtrl->tbdNum = MOT_FEC_TBD_DEF_NUM;
	}

    if (!pDrvCtrl->rbdNum || pDrvCtrl->rbdNum <= 2)
	{
	MOT_FEC_FLAG_SET (MOT_FEC_INV_RBD_NUM);
	pDrvCtrl->rbdNum = MOT_FEC_RBD_DEF_NUM; 
	}

    MOT_FEC_LOG (MOT_FEC_DBG_LOAD,
		 ("motFecEndParse: unit=%d motCpmAddr=0x%x ivec=0x%x
		 bufBase=0x%x bufSize=0x%x \n"),
		 pDrvCtrl->unit, 
		 (int) pDrvCtrl->motCpmAddr,
		 (int) pDrvCtrl->ivec,
		 pDrvCtrl->pBufBase,
		 pDrvCtrl->bufSize,
		 0);

    MOT_FEC_LOG (MOT_FEC_DBG_LOAD,
		 ("motFecEndParse: fifoTxBase=0x%x fifoRxBase=0x%x
		 tbdNum=%d rbdNum=%d flags=0x%x\n"),
		 pDrvCtrl->fifoTxBase,
		 pDrvCtrl->fifoRxBase,
		 pDrvCtrl->tbdNum,
		 pDrvCtrl->rbdNum,
		 pDrvCtrl->userFlags,
		 0);

    MOT_FEC_LOG (MOT_FEC_DBG_LOAD,
                 ("motFecEndParse: phyAddr=0x%x isoPhyAddr=0x%x
                  phyDefMode=0x%x \n"),
                 pDrvCtrl->phyInfo->phyAddr,
                 pDrvCtrl->phyInfo->isoPhyAddr,
                 pDrvCtrl->phyInfo->phyDefMode,
                 0, 0, 0);
    return (OK);
    }

/*******************************************************************************
* motFecInitMem - initialize memory
*
* This routine initializes all the memory needed by the driver whose control
* structure is passed in <pDrvCtrl>.
*
* RETURNS: OK or ERROR
*/
LOCAL STATUS motFecInitMem
    (
    DRV_CTRL *  pDrvCtrl       		/* pointer to DRV_CTRL structure */
    )
    {
    UINT32		bdSize;	   	/* temporary size holder */
    UINT32		clSize;	   	/* temporary size holder */
    UINT16		clNum;		/* a buffer number holder */
    M_CL_CONFIG	 	mclBlkConfig = {0, 0, NULL, 0};
					/* cluster blocks configuration */
    CL_DESC	 	clDescTbl [] = { {MOT_FEC_MAX_CL_LEN, 0, NULL, 0} };
					/* cluster blocks config table */
    int clDescTblNumEnt = (NELEMENTS (clDescTbl));
					/* number of different clusters */

    /* initialize the netPool */

    if ((pDrvCtrl->endObj.pNetPool = malloc (sizeof (NET_POOL))) == NULL)
	return (ERROR);

    /* 
     * we include here room for both TBDs and RBDs, 
     * and the alignment factor.
     */