sysmotfcc2end.c

MPC8560 for vxwork BSP

/* sysMotFcc2End.c - system configuration module for motFccEnd driver */

/*
 * Copyright (c) 2003-2005 Wind River Systems, Inc.
 *
 * The right to copy, distribute or otherwise make use of this software
 * may be licensed only pursuant to the terms of an applicable Wind River
 * license agreement. No license to Wind River intellectual property rights
 * is granted herein. All rights not licensed by Wind River are reserved
 * by Wind River.
 */
 
/*
modification history
--------------------
01g,06apr05,dtr  Add support for SNOOP.
01f,23mar05,mdo  Documentation fixes for apigen
01e,24oct03,mil  Bypassed miiPhyInit with local routine.
01d,17sep03,mil  Added Fcc2End support and modified for two FCCs.
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 FILES:
*/

#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"
#include "motFcc2End.h"
/* defines */
#undef INUM_TO_IVEC
#define INUM_TO_IVEC(x) (x)
#undef INUM_FCC2
#define INUM_FCC2  33
#undef INUM_IRQ6
#define INUM_IRQ6 6
#ifdef INCLUDE_MOT_FCC_END

#define MOT_FCC_BASE_NUM        0x02    /* first FCC to be used */
#define MOT_FCC_TBD_NUM         0x40    /* transmit buffer descriptors (TBD)*/
#define MOT_FCC_RBD_NUM         0x20    /* receive buffer descriptors (RBD)*/
#define MOT_FCC_DEF_PHY_MODE    0x02    /* PHY's default operating mode */
#define MOT_FCC_BDS_SIZE        (2 * 1024)
#define MOT_FCC_MBLK_RBD_RATIO  0x03    /* Driver allocates (3* MOT_FCC_RBD_NUM) mBlk's */
#define MOT_FCC_CLUS_RBD_RATIO  0x04    /* Driver allocates (4* MOT_FCC_RBD_NUM) Clusters*/

/* imports */

IMPORT END_OBJ * motFcc2EndLoad (char *);
IMPORT UINT32    sysPCGet (void);
IMPORT STATUS    miiNoscanPhyInit (PHY_INFO * phyInfo);

/* globals */

UINT32 miiNumLinkChgInts = 0;
UINT32 miiBitRdCount     = 0;
UINT32 miiBitWrCount     = 0;

/* locals */

UINT32 fccPhyAdrs[] = {
                      0x2,      /* FCC2 */
                      0x3       /* FCC3 */
                      };

/*
 * 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 sysFccEnetEnable (UINT32 immrVal, UINT8 fccNum);
STATUS sysFccEnetCommand(UINT32 immrVal, UINT8  fccNum, UINT16  command);
STATUS sysFccMiiBitWr (UINT32 immrVal, UINT8 fccNum, INT32 bitVal);
STATUS sysFccMiiBitRd (UINT32 immrVal, UINT8 fccNum, INT8 * bitVal);
STATUS sysFccEnetDisable (UINT32 immrVal, UINT8 fccNum);
LOCAL STATUS sysMiiPhyInit    (PHY_INFO * pPhyInfo);
LOCAL void sysMiiInt(PHY_INFO * pPhyInfo);
LOCAL STATUS sysMiiPhyDuplex(PHY_INFO * pPhyInfo,int * pDuplex);
FCC_END_FUNCS fccFuncs;

/***********************************************************************
*
* sysMotFccEndLoad - load an instance 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>
*
* \is
* \i <immrVal>
* Internal memory address
* \i <fccNum>
* FCC number being used
* \i <bdBase>
* buffer descriptors base address
* \i <bdSize>
* buffer descriptors space size
* \i <bufBase>
* data buffers base address
* \i <bufSize>
* data buffers space size
* \i <fifoTxBase>
* tx buffer in internal memory
* \i <fifoRxBase>
* rx buffer in internal memory
* \i <tbdNum>
* number of TBDs or NONE
* \i <rbdNum>
* number of RBDs or NONE
* \i <phyAddr>
* address of a MII-compliant PHY device
* \i <phyDefMode>
* default operating mode of a MII-compliant PHY device
* \i <pAnOrderTbl>
* auto-negotiation order table for a MII-compliant PHY device or NONE
* \i <userFlags>
* User flags
* \i <mBlkRatio>
* Ratio between mBlk's and Rx BD's
* \i <clusterRatio>
* Ratio between Clusters and Rx BD's
*
* 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.
* \ie
* 
* RETURNS: pointer to END object or NULL.
*
* ERRNO
*
* 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>:<mBlkRatio>:<clusterRatio>
     * 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:0x%x:0x%x";

    END_OBJ * pEnd;

    int fccUnit=0;
    char * tok;                /* an initString token */
    char * holder = NULL;      /* points to pParamStr fragment beyond tok */

    fccFuncs.miiPhyInit = sysMiiPhyInit;       /* bsp MiiPhy init function */
    fccFuncs.miiPhyInt = (FUNCPTR) sysMiiInt;  /* drv func for BSP to call */
    fccFuncs.miiPhyBitRead = (FUNCPTR) sysFccMiiBitRd;    /* Bit Read func */
    fccFuncs.miiPhyBitWrite = (FUNCPTR) sysFccMiiBitWr;   /* Bit Write func */
    fccFuncs.miiPhyDuplex = sysMiiPhyDuplex;     /* duplex status call back */
    fccFuncs.miiPhySpeed = NULL;      /* speed status call back */
    fccFuncs.hbFail = NULL;           /* heart beat fail */
    fccFuncs.intDisc = NULL;          /* disconnect Function */
    fccFuncs.dpramFree = NULL;
    fccFuncs.dpramFccMalloc = NULL;
    fccFuncs.dpramFccFree = NULL;

    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_MEM_LOCAL_ADRS + (LOCAL_MEM_SIZE >> 1);
            motFccBufsSize = LOCAL_MEM_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;

#if (USER_D_CACHE_MODE == (CACHE_COPYBACK | CACHE_SNOOP_ENABLE))
            motFccFlags    = MOT_FCC_USR_SNOOP_ENABLE | MOT_FCC_USR_PHY_MON;
#else
	    motFccFlags    = 0x00008000; /* DPRAM ALOC */
#endif

            }
        /*
         * 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 possible 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 (USER_D_CACHE_MODE == (CACHE_COPYBACK | CACHE_SNOOP_ENABLE))
    motFccBufsDescAdr = -1UL;
#   else
    if ((motFccBufsDescAdr = (UINT32)m82xxDpramAlignedMalloc (MOT_FCC_BDS_SIZE,8)) == 0)
        {
        motFccBufsDescAdr = -1UL;
	}
#   endif

# 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);

        tok = strtok_r (pParamStr, ":", &holder);

        if (tok == NULL)
           {
           return (END_OBJ*)NULL;
           }

        fccUnit = ((int) strtoul (tok, NULL, 16));

        /* finish off the initialization parameter string */
        sprintf (pStr, motFccEndParamTemplate,
            (UINT) vxImmrGet (),
            MOT_FCC_BASE_NUM + fccUnit,
            motFccBufsDescAdr,
            motFccBufsDescSize,
            motFccBufsAdr,
            motFccBufsSize,
            -1UL,-1UL,
            MOT_FCC_TBD_NUM,
            MOT_FCC_RBD_NUM,
            fccPhyAdrs[fccUnit],
            MOT_FCC_DEF_PHY_MODE,
            &motFccAnOrderTbl,
            motFccFlags,
            &fccFuncs,
            MOT_FCC_MBLK_RBD_RATIO,
            MOT_FCC_CLUS_RBD_RATIO
         );

        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 check if the link is Full Duplex or not
*
* RETURNS: 1 if Full Duplex or 0 if not.
*
* ERRNO
*/

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;
    }

/***********************************************************************
*
* sysMiiInt - MII interrupt service routine
*
* This routine check if the link up or down and update a flag
*
* RETURNS: N/A
*
* ERRNO
*/

LOCAL void sysMiiInt
    (
    PHY_INFO * pPhyInfo
    )
    {
    UINT16 miiIntStatusReg;
    int    tmp;

    /* Clear MII interrupt by reading Int status reg */
    MII_READ(pPhyInfo->phyAddr,19,&miiIntStatusReg,tmp);
    ++miiNumLinkChgInts;
    }

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