sysmotfccend.c

WINDRIVER 8260 ATM BSP

/* sysMotFccEnd.c - system configuration module for motFccEnd driver */
 
/* Copyright 1984-1999 Wind River Systems, Inc. */
#include "copyright_wrs.h"
 
/*
modification history
--------------------
01d,14jan03,gjc  SPR#85164 and SPR#85098 :Added support for motFcc2End.
01c,07mar02,kab  SPR 70817: *EndLoad returns NULL on failure
01b,17sep01,g_h  change to work with the new m8206FccEnd driver rev 01g.
01a,05jul01,g_h  created from ads860/sysMotCpmEnd.c
*/
 
/*
DESCRIPTION
This is the WRS-supplied configuration module for the VxWorks
m8260FccEnd END driver.

It performs the dynamic parameterization of the motFccEnd driver.
This technique of 'just-in-time' parameterization allows driver
parameter values to be declared as any other defined constants rather
than as static strings.
*/

#include "vxWorks.h"
#include "config.h"
#include "vmLib.h"
#include "stdio.h"
#include "sysLib.h"
#include "logLib.h"
#include "stdlib.h"
#include "string.h"
#include "end.h"
#include "intLib.h"
#include "lstLib.h"
#include "drv/mem/m82xxDpramLib.h"
#include "miiLib.h"


/* defines */

#ifdef INCLUDE_MOTFCCEND

#define MOT_FCC_NUM             0x02    /* FCC being used */
#define MOT_FCC_TBD_NUM         0x40    /* transmit buffer descriptors (TBD)*/
#define MOT_FCC_RBD_NUM         0x20    /* receive buffer descriptors (RBD) */
#define MOT_FCC_PHY_ADDR        0x00    /* PHY address */
#define MOT_FCC_DEF_PHY_MODE    0x02    /* PHY's default operating mode */
#define MOT_FCC_BDS_SIZE        (2 * 1024)


/* imports */
 
IMPORT END_OBJ * motFcc2EndLoad (char *);
IMPORT UINT32    sysPCGet (void);

/* globals */

/* locals */

LOCAL STATUS sysMiiPhyInit ( PHY_INFO * pPhyInfo );
LOCAL STATUS sysMiiPhyDuplex ( PHY_INFO * pPhyInfo,int * pDuplex );
LOCAL STATUS sysMiiPhySpeed ( PHY_INFO * pPhyInfo,int * pSpeed );

/*
 * this table may be customized by the user to force a
 * particular order how different technology abilities may be
 * negotiated by the PHY. Entries in this table may be freely combined
 * and even OR'd together.
 */
 
LOCAL INT16 motFccAnOrderTbl [] = {
                                MII_TECH_100BASE_TX,    /* 100Base-T */
                                MII_TECH_100BASE_T4,    /* 10Base-T */
                                MII_TECH_10BASE_T,      /* 100Base-T4 */
                                MII_TECH_10BASE_FD,     /* 100Base-T FD*/
                                MII_TECH_100BASE_TX_FD, /* 10Base-T FD */
                                -1                      /* end of table */
                               };

/* forward declarations */

STATUS sysFccEnetAddrGet (int unit, UCHAR *address);
STATUS sysFccEnetEnable (UINT32 immrVal, UINT8 fccNum);
STATUS sysFccEnetDisable (UINT32 immrVal, UINT8 fccNum);
STATUS sysFccMiiBitWr (UINT32 immrVal, UINT8 fccNum, INT32 bitVal);
STATUS sysFccMiiBitRd (UINT32 immrVal, UINT8 fccNum, INT8 * bitVal);

#define SYS_MII_PHY_INT     1

LOCAL FUNCPTR sysMotFccFuncs[] =
    {
    (FUNCPTR) sysMiiPhyInit,      /* bsp MiiPhy init function */
    (FUNCPTR) NULL,               /* Interrupt End Driver function called by BSP */
    (FUNCPTR) sysFccMiiBitRd,     /* BSP Bit Read funtion    */
    (FUNCPTR) sysFccMiiBitWr,     /* BSP Bit Write function  */
    (FUNCPTR) sysMiiPhyDuplex,    /* duplex status call back */
    (FUNCPTR) sysMiiPhySpeed,     /* speed status call back  */
    (FUNCPTR) NULL,               /* heart beat error        */
    (FUNCPTR) NULL,               /* disconnect function */
    (FUNCPTR) m82xxDpramFree,     /* Dpram Free routine */
    (FUNCPTR) m82xxDpramFccMalloc,/* Dpram Malloc */
    (FUNCPTR) m82xxDpramFccFree,  /* Dpram FCC Free */
    NULL, NULL, NULL, NULL
    };

/***********************************************************************
*
* sysMotFccEndLoad - load an istance of the motFccEnd driver
*
* This routine loads the motFccEnd driver with proper parameters. It also
* reads the BCSR3 to find out which type of processor is being used, and
* sets up the load string accordingly.
*
* The END device load string formed by this routine is in the following
* format.
* <immrVal>:<fccNum>:<bdBase>:<bdSize>:<bufBase>:<bufSize>:<fifoTxBase>
* :<fifoRxBase>:<tbdNum>:<rbdNum>:<phyAddr>:<phyDefMode>:<pAnOrderTbl>:
* <userFlags>:<mBlkRatio>:<mBlkRatio>:<miiPhyParams>:<dpramParams>
*
* .IP <immrVal>
* Internal memory address
* .IP <fccNum>
* FCC number being used
* .IP <bdBase>
* buffer descriptors base address
* .IP <bdSize>
* buffer descriptors space size
* .IP <bufBase>
* data buffers base address
* .IP <bufSize>
* data buffers space size
* .IP <fifoTxBase>
* tx buffer in internal memory
* .IP <fifoRxBase>
* rx buffer in internal memory
* .IP <tbdNum>
* number of TBDs or NONE
* .IP <rbdNum>
* number of RBDs or NONE
* .IP <phyAddr>
* address of a MII-compliant PHY device
* .IP <phyDefMode>
* default operating mode of a MII-compliant PHY device
* .IP <pAnOrderTbl>
* auto-negotiation order table for a MII-compliant PHY device or NONE
* .IP <userFlags>
* User flages
* .IP <sysMotFccFuncs>
* Pointer to a predefined array of FUNCPTRs
*   sysMiiPhyInit         bsp MiiPhy init function 
*   NULL                  Interrupt End Driver function called by BSP 
*   sysFccMiiBitR,        BSP Bit Read funtion    
*   sysFccMiiBitWr        BSP Bit Write function  
*   sysMiiPhyDuplex       duplex status call back 
*   sysMiiPhySpeed        speed status call back  
*   NULL                  heart beat error        
*   NULL                  disconnect function 
*   m82xxDpramFree        Dpram Free routine (main pool)
*   m82xxDpramFccMalloc   Dpram Malloc from the FCC pool
*   m82xxDpramFccFree     Dpram Free from the FCC pool
*
* This routine only loads and initializes one instance of the device.
* If the user wishes to use more than one motFccEnd devices, this routine
* should be changed.
*
* RETURNS: pointer to END object or NULL.
*
* SEE ALSO: motFccEndLoad ()
*/
 
END_OBJ * sysMotFccEndLoad
    (
    char * pParamStr,   /* ptr to initialization parameter string */
    void * unused       /* unused optional argument */
    )
    {
    /*
    * The motFccEnd driver END_LOAD_STRING should be:
    * <immrVal>:<fccNum>:<bdBase>:<bdSize>:<bufBase>:<bufSize>:<fifoTxBase>
    * :<fifoRxBase>:<tbdNum>:<rbdNum>:<phyAddr>:<phyDefMode>
    * :<pAnOrderTbl>:<userFlags>:<sysMotFccFuncs>
    * Note that unit string is prepended by the mux, so we
    * don't put it here.
    */
 
    char * pStr = NULL;
    char   paramStr [300];
    UINT32 regPC;
    UINT32 motFccBufsDescAdr;
    UINT32 motFccBufsDescSize;
    UINT32 motFccBufsAdr;
    UINT32 motFccBufsSize;
    UINT32 motFccFlags;
    
    static char motFccEndParamTemplate [] = 
    "0x%x:0x%x:0x%x:0x%x:0x%x:0x%x:0x%x:0x%x:0x%x:0x%x:0x%x:0x%x:0x%x:0x%x:0x%x";
    
    END_OBJ * pEnd;

 
    if (strlen (pParamStr) == 0) 
        {
        /*
        * muxDevLoad() calls us twice.  If the string is
        * zero length, then this is the first time through
        * this routine.
        */

        pEnd = (END_OBJ *) motFcc2EndLoad  (pParamStr);
        }
    else
        {
        regPC = sysPCGet ();
    
        if ((regPC & ROM_BASE_ADRS) == ROM_BASE_ADRS)
            {
        /* We are running from ROM */

        /* 
        * ROM resident applications MUST use the option, wail RAM resident
        * MAY use the option, which forces all
        * driver buffers (rx and tx) to reside in local bus space. The
        * drawback to having buffers on the local bus is that the driver
        * MUST copy all transmit packets to the local bus -- so zcopy
        * must be inhibited. The driver still passes rx data zcopy.
        */

        /* for ROM apps, specify local bus space for the buffers */
            motFccBufsAdr  = LOCAL_BUS_SDRAM_ADRS + (LOCAL_BUS_SDRAM_SIZE >> 1);
            motFccBufsSize = LOCAL_BUS_SDRAM_SIZE >> 1;
            
        /* for ROM apps, MOT_FCC_FLAGS *must* include the following. */
            motFccFlags = 0x0000D000; 
        /*(MOT_FCC_USR_BUF_LBUS|MOT_FCC_USR_NO_ZCOPY|MOT_FCC_USR_DPRAM_ALOC)*/
                        
        /* 
        * NOTE! The FCC driver internally forces MOT_FCC_USR_NO_ZCOPY if
        * MOT_FCC_USR_BUF_LBUS is set in MOT_FCC_FLAGS, making the
        * inclusion of 'NO_ZCOPY not strictly required. The 'NO_ZCOPY
        * flag can be used independently of the bus on which buffers
        * reside -- for those rare apps that might need this option.
        */
            }
        else
            {
            /* We are running from RAM */

            /* for RAM apps, let the driver find space for the buffers */
            motFccBufsAdr  = -1UL;
            motFccBufsSize = -1UL;
            motFccFlags    = 0x00008000; /* MOT_FCC_USR_DPRAM_ALOC */
            }
        /* 
        * NOTE! Regarding bus choices for BDs and buffers.
        * If you give a local bus address for BDs and don't include
        * MOT_FCC_USR_BD_LBUS in MOT_FCC_FLAGS, the CPM will hang.
        * If you give a local bus address for buffers and don't include
        * MOT_FCC_USR_BUF_LBUS in MOT_FCC_FLAGS, the CPM will hang.
        * If you give a 60x bus address for buffers and/or BDs and
        * mistakenly include either a 'LBUS flag, the CPM will hang.
        */

        /* 
        * If you want the driver to decide where to put the BDs, set BOTH of the
        * following motFccBufsDescAdr & motFccBufsDescSize to -1UL.
        * If you decide to force the driver to use BDs on the local bus, set the
        * following motFccBufsDescAdr to a local bus address and size AND be sure to add
        * MOT_FCC_USR_BD_LBUS to the definition of MOT_FCC_FLAGS below.
        * The defaults use internal DPRAM for BDS. You may optionally specify
        * a 60x bus address for BDS.  In these cases do not set the LBUS flag.
        * Because the Wind River ATM driver need as much as posible free DPRAM, when using
        * the ATM driver the BDs will be on the 60x bus.
        */

        motFccBufsDescSize = MOT_FCC_BDS_SIZE;

        #ifdef INCLUDE_ATM
        motFccBufsDescAdr = -1UL;
        #else /* INCLUDE_ATM is not defined */
        if ((motFccBufsDescAdr = (UINT32)m82xxDpramAlignedMalloc (MOT_FCC_BDS_SIZE,8)) == 0)
            {
            motFccBufsDescAdr = -1UL;
            }
        #endif /* INCLUDE_ATM */

        /*
        * On the second pass through here, we actually create
        * the initialization parameter string on the fly.
        * Note that we will be handed our unit number on the
        * second pass and we need to preserve that information.
        * So we use the unit number handed from the input string.
        */
 
        pStr = strcpy (paramStr, pParamStr);
 
        /* Now, we get to the end of the string */
 
        pStr += strlen (paramStr);
 
        /* finish off the initialization parameter string */
        sprintf (pStr, motFccEndParamTemplate,
            (UINT) vxImmrGet (),
            MOT_FCC_NUM,
            motFccBufsDescAdr,
            motFccBufsDescSize,
            motFccBufsAdr,
            motFccBufsSize,
            -1UL,-1UL,
            MOT_FCC_TBD_NUM,    
            MOT_FCC_RBD_NUM,    
            MOT_FCC_PHY_ADDR,   
            MOT_FCC_DEF_PHY_MODE,   
            &motFccAnOrderTbl,
            motFccFlags,
            &sysMotFccFuncs);

        if ((pEnd = (END_OBJ *) motFcc2EndLoad  (paramStr)) == (END_OBJ *)NULL) 
            {
            logMsg ("Error: motFccEndLoad  failed to load driver\n", 0, 0, 0, 0, 0, 0);
            }
        }

    return pEnd;
    }

/***********************************************************************
*
* sysMiiPhyDuplex - check if link is Full Duplex
*
* This routine checks if the link is Full Duplex or not
*
* RETURNS: 1 if Ful Duplex or 0 if not.
*/

LOCAL STATUS sysMiiPhyDuplex
    (
    PHY_INFO * pPhyInfo,
    int      * pDuplex
    )
    {
    UINT16 miiStat;
    int    retVal;

    MII_READ(pPhyInfo->phyAddr,17,&miiStat,retVal);
    
    if (retVal == OK)
        {
        *pDuplex = (miiStat & 0x200) ? 1 : 0;
        }
    return retVal;
    }

/***********************************************************************