sysmotsccend.c

WINDRIVER 8260 ATM BSP

/* sysMotSccEnd.c - system configuration module for m8260SccEnd driver */
 
/* Copyright 1984-1999 Wind River Systems, Inc. */
#include "copyright_wrs.h"
 
/*
modification history
--------------------
01c,16jan03,gjc  SPR#85071 and SPR#85071 :Added mechanism to support
                 initial duplex setting.
01b,23sep02,gjc  Fixing SPRs #81417 and #82303 - sysSccEnetDisable
         sets bits in portB instead of portD. Always use
         global mac[1] for scc0. Fixes Duplicate MAC.
01a,07mar02,kab  SPR 70817: *EndLoad returns NULL on failure
01b,10may01, g_h  rename to sysMotSccEnd.c
01a,08mar01, g_h  created from sbc8260/sysMotFccEnd.c
*/
 
/*
DESCRIPTION
This is the WRS-supplied configuration module for the VxWorks
motCpmEnd END driver.

It performs the dynamic parameterization of the motCpmEnd 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 "drv/mem/m82xxDpramLib.h" 
#include "drv/end/m8260SccEnd.h"

/* defines */

#ifdef INCLUDE_MOTSCCEND

#define MOT_SCC_INTVEC_NUM  0x23  /* Interrupt vector number */
#define MOT_SCC_NUM         0x1   /* SCC number */
#define MOT_SCC_TBD_NUM     0x20  /* number of transmit buffer descriptors (TBD)*/
#define MOT_SCC_RBD_NUM     0x20  /* number of receive buffer descriptors (RBD)*/

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

/* forward declarations */

void   sysSccEnetDisable (int unit);
void   sysSccEnetIntDisable (int unit);
STATUS sysSccEnetEnable ( int unit );
STATUS sysSccEnetAddrGet (int  unit, UINT8 *addr);
STATUS sysSccEnetCommand (int  unit, UINT16 command);
void   sysSccEnetIntEnable (int unit);
void   sysSccEnetIntClear (int unit);

/***********************************************************************
*
* sysMotSccEndLoad - load an istance of the m8260SccEnd driver
*
* This routine loads the m8260SccEnd 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.
* <motCpmAddr>:<ivec>:<sccNum>:<txBdNum>:<rxBdNum>:<txBdBase>:<rxBdBase>:
* <bufBase>
*
* .IP <motCpmAddr>
* Internal memory address
* .IP <ivec>
* Interrupt vector 
* .IP <sccNum>
* SCC number being used
* .IP <txBdNum>
* number of TBDs or NULL
* .IP <rxBdNum>
* number of RBDs or NULL
* .IP <txBdBase>
* base location of the TBDs
* .IP <rxBdBase>
* base location of the RBDs
* .IP <bufBase>
* address of the shared memory region
* .IP <flags>
* SCC_USR_RUNNING_FROM_ROM
* SCC_USR_DUPLEX_HALF or SCC_USR_DUPLEX_FULL 
*
* This routine only loads and initializes one instance of the device.
* If the user wishes to use more than one m8260SccEnd devices, this routine
* should be changed. 
* The driver interface supports setting the duple mode to half or full via the flag
* load string parameter. The default is half duplex.
*
* RETURNS: pointer to END object or NULL.
*
* SEE ALSO: m8260EndLoad ()
*/
 
END_OBJ * sysMotSccEndLoad
    (
    char * pParamStr,   /* ptr to initialization parameter string */
    void * unused       /* unused optional argument */
    )
    {
    /*
     * The motCpmEnd driver END_LOAD_STRING should be:
     * <motCpmAddr>:<ivec>:<sccNum>:<txBdNum>:<rxBdNum>:<txBdBase>:
     * <rxBdBase>:<bufBase>:<userFlags>
     * Note that unit string is prepended by the mux, so we
     * don't put it here.
     */
 
    char * pStr = NULL;
    char   paramStr [200];
    UINT32 regPC;
    UINT32 motSccTxBufDescBase;
    UINT32 motSccRxBufDescBase;
    UINT32 motSccBufBase;
    UINT32 motSccFlags;

    static char motSccEndParamTemplate [] = "0x%x:0x%x:%d: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 *) m8260SccEndLoad (pParamStr);
        }
    else
        {
    regPC = sysPCGet ();

    motSccFlags = 0;

    if ((regPC & ROM_BASE_ADRS) == ROM_BASE_ADRS)
        {
        /* We are running from ROM */
            
        motSccBufBase = 0x04100000;               /* BD in local bus */
        motSccFlags   |= SCC_USR_RUNNING_FROM_ROM; /* user flags */
        }
    else
        {
        /* We are running from RAM */
            
        motSccBufBase = -1UL; /* BD in 60x bus */
        }

    motSccFlags |= SCC_USR_DUPLEX_HALF;  /* user flags */
        
        /*
         * 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.
         */

    if ((motSccTxBufDescBase = (UINT32)m82xxDpramAlignedMalloc (0x280,8)) == 0)
        return 0;

    if((motSccRxBufDescBase = (UINT32)m82xxDpramAlignedMalloc (0x280,8)) == 0)
       return 0;

        pStr = strcpy (paramStr, pParamStr);
 
        /* Now, we get to the end of the string */
 
        pStr += strlen (paramStr);
 
        
        /* finish off the initialization parameter string */

        sprintf (pStr, motSccEndParamTemplate,
                 (UINT) vxImmrGet (),
                 MOT_SCC_INTVEC_NUM,
                 MOT_SCC_NUM,
                 MOT_SCC_TBD_NUM,   
                 MOT_SCC_RBD_NUM,   
                 motSccTxBufDescBase,
                 motSccRxBufDescBase,
                 motSccBufBase,
                 motSccFlags);
 
        if ((pEnd = (END_OBJ *) m8260SccEndLoad  (paramStr)) == (END_OBJ *)NULL)
            {
            logMsg ("Error: m8260SccEndLoad  failed to load driver\n",
            0, 0, 0, 0, 0, 0);
            }
        }
 
    return (pEnd);
    }

/***********************************************************************
*
* sysSccEnetDisable - disable the Ethernet controller
*
* This routine is expected to perform any target specific functions required
* to disable the Ethernet controller.  This usually involves disabling the
* Transmit Enable (TENA) signal.
*
* RETURNS: N/A
*/

void sysSccEnetDisable
    (
    int         unit    /* not used - only slave SCC1 is wired to port */
    )
    {
    /*                                                                      */
    /* Get the physical location of the IMMR register                       */
    /*                                                                      */
    int immrVal = vxImmrGet() ;


    *M8260_IOP_PDPAR(immrVal) &= ~(PD29);    /* clear port D pin 29 -> RTS1 = *TENA */
    
    }

/***********************************************************************
*
* sysSccEnetIntDisable - disable the Ethernet interface interrupt
*
* This routine disable the interrupt for the Ethernet interface specified
* by <unit>.
*
* RETURNS: N/A.
*/

void sysSccEnetIntDisable
    (
    int     unit
    )
    {
    /*                                                                      */
    /* Get the physical location of the IMMR register                       */
    /*                                                                      */
    int immrVal = vxImmrGet ();

    *M8260_SIMR_L(immrVal) &= ~0x00800000;   /* Mask SCC1 */
    }

/***********************************************************************
*
* sysSccEnetEnable - enable the Ethernet controller
*
* This routine is expected to perform any target specific functions required
* to enable the Ethernet controller.  These functions typically include
* enabling the Transmit Enable signal (TENA) and connecting the transmit
* and receive clocks to the SCC.
*
* RETURNS: OK, or ERROR if the Ethernet controller cannot be enabled.
*/

STATUS sysSccEnetEnable
    (
    int     unit    /* not used - only slave SCC1 is wired to port */
    )
    {
    UINT32 temp;
    int immrVal = vxImmrGet ();

    /*
     * Configure port D pins to enable TXD1 and RXD1.
     *
     * Set PPARD[30,31] and PDIRD[30] and clear PDIRD[31] 
     * and PSORD[31].  Set PSORD[30].
     */
    *M8260_IOP_PDPAR(immrVal) |=  (PD30 | PD31);  /* Set PD30 and PD31 */
    *M8260_IOP_PDDIR(immrVal) |=  (PD30);         /* Set PD30 */
    *M8260_IOP_PDDIR(immrVal) &= ~(PD31);         /* Clear PD31 */
    *M8260_IOP_PDSO(immrVal)  |=  (PD30);         /* Set PD30 */
    *M8260_IOP_PDSO(immrVal)  &= ~(PD31);         /* Clear PD31 */

    /*
     * Configure ports C and D to enable TENA1 (RTS1), CLSN1 (CTS1),
     * and RENA1 (CD1).
     *
     * Set PPARD[29], PPARC[14,29], PDIRD[29], and PSORC[29] and clear 
     * PDIRC[14,29], PSORC[14] and PSORD[29].
     */
    *M8260_IOP_PDPAR(immrVal) |=  (PD29);         /* Set PD29 */
    *M8260_IOP_PCPAR(immrVal) |=  (PC14 | PC29);  /* Set PC14 and PC29 */
    *M8260_IOP_PDDIR(immrVal) |=  (PD29);         /* Set PD29 */
    *M8260_IOP_PCSO(immrVal)  |=  (PC29);         /* Set PC29 */
    *M8260_IOP_PCDIR(immrVal) &= ~(PC14 | PC29);  /* Clear PC14 and PC29 */
    *M8260_IOP_PCSO(immrVal)  &= ~(PC14);         /* Clear PC14 */
    *M8260_IOP_PDSO(immrVal)  &= ~(PD29);         /* Clear PD29 */

    /*
     * Configure port C pins to enable CLK11 and CLK12.
     *
     * Set PPARC[20,21] and clear PDIRC[20,21] and PSORC[20,21].
     */
    *M8260_IOP_PCPAR(immrVal) |=  (PC20 | PC21);  /* Set PC20 and PC21 */
    *M8260_IOP_PCDIR(immrVal) &= ~(PC20 | PC21);  /* Clear PC20 and PC21 */
    *M8260_IOP_PCSO(immrVal)  &= ~(PC20 | PC21);  /* Clear PC20 and PC21 */


    /*
     * Connect CLK11 to the SCC1 receiver and CLK12 to the
     * transmitter using the CPM mux.  Also, connect the SCC1
     * to the NMSI.
     *
     * Program CMXSCR[R1CS] to 0b100 and CMXSCR[T1CS] to 0b101.
     * Clear CMXSCR[SC1].
     */
    temp = (*M8260_CMXSCR(immrVal) & 0x00ffffff);
    *M8260_CMXSCR(immrVal) = (temp | 0x25000000);
 
    return (OK);
    }

/***********************************************************************
*
* sysSccEnetAddrGet - gets the 6 byte ethernet address
*
* The routine gets the 6 byte ethernet address used by the ethernet device.
*
* RETURNS: OK, or ERROR
*/

STATUS sysSccEnetAddrGet
    (
    int     unit ,       
    UINT8 * pAddr   /* LOcation address is returned in                 */
    )
    {
    /* need extra room for a 'EOS' -- driver may not provide it */
    UINT8   eAdrs[MAC_ADRS_LEN + 2];
    STATUS  status;

    status = sysEnetAddrGet (1,eAdrs); 
    if (status == OK)
    {
    memcpy (pAddr,eAdrs,MAC_ADRS_LEN);
        }
    return status;
    }

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

*
* sysSccEnetCommand - issue a command to the Ethernet interface controller
*
* The routine issue a command to the Ethernet interface controller.
*
* RETURNS: OK, or ERROR if the Ethernet controller could not be restarted.
*/

STATUS sysSccEnetCommand
    (
    int     unit,
    UINT16  command
    )
    {
    int immrVal = vxImmrGet ();

    while (*M8260_CPCR(immrVal) & M8260_CPCR_FLG);

    *M8260_CPCR(immrVal) = M8260_CPCR_PAGE(M8260_CPCR_PAGE_SCC1) | \
                   M8260_CPCR_SBC(M8260_CPCR_SBC_SCC1)   | \
                           command                               | \
               M8260_CPCR_FLG;
    
    while (*M8260_CPCR(immrVal) & M8260_CPCR_FLG);

    return (OK);
    }

/***********************************************************************
*
* sysSccEnetIntEnable - enable the Ethernet interface interrupt
*
* This routine enable the interrupt for the Ethernet interface specified
* by <unit>.
*
* RETURNS: N/A.
*/

void sysSccEnetIntEnable
    (
    int     unit
    )
    {
    /*                                                                      */
    /* Get the physical location of the IMMR register                       */
    /*                                                                      */
    int immrVal = vxImmrGet ();

    *M8260_SIMR_L(immrVal) |= 0x00800000;   /* Enable SCC1 */
    }

/***********************************************************************
*
* sysSccEnetIntClear - clear the Ethernet interface interrupt
*
* This routine clears the interrupt for the Ethernet interface specified
* by <unit>.
*
* RETURNS: N/A.
*/

void sysSccEnetIntClear
    (
    int     unit
    )
    {
    /*                                                                      */
    /* Get the physical location of the IMMR register                       */
    /*                                                                      */
    int immrVal = vxImmrGet ();

    *M8260_SIPNR_L(immrVal) = 0x00800000;
    }

#endif /* INCLUDE_MOTSCCEND */