usrsmobj.c

vxworks source code, used for develop vxworks system.

/* usrSmObj.c - shared memory object initialization */

/* Copyright 1992-2002 Wind River Systems, Inc. */

/*
modification history
--------------------
01e,13feb02,mas  fixed staged delay/check for slave node startup (SPR 73189)
01d,02oct01,mas  added staged delay/check for slave node startup (SPR 62128)
01c,13sep01,jws  fix smObjSpinTries initialization (SPR68418)
01b,20jan99,scb  modified to use "sm=" before SM_ANCHOR_ADRS (23035)
01a,16feb97,ms   based on old 01i version.
*/

/*
DESCRIPTION
This file is used to configure and initialize the VxWorks shared memory
object support.  This file is included by usrConfig.c.

SEE ALSO: usrExtra.c

NOMANUAL
*/

/******************************************************************************
*
* usrSmObjInit - initialize shared memory objects
*
* This routine initializes the shared memory objects facility.  It sets up
* the shared memory objects facility if called from processor 0.
* Then it initializes a shared memory descriptor and calls smObjAttach()
* to attach this CPU to the shared memory object facility.
*
* When the shared memory pool resides on the local CPU dual ported memory,
* SM_OBJ_MEM_ADRS must be set to NONE in configAll.h and the shared memory
* objects pool is allocated from the VxWorks system pool.
*
* RETURNS: OK, or ERROR if unsuccessful.
*
* INTERNAL
* The delayed start for slave processors used below is required.  The anchor
* may not yet be mapped to the bus.  So, probing of shared memory locations is
* used to overcome Bus Errors which occur on many boards if the slave accesses
* shared memory (SM) before the master has finished initializing it.  The code
* here simply delays access to the SM region until the SM master has finished
* initializing it.
*
* The method used is to repetitively probe key locations in the SM region
* after delay periods until valid values are detected or a time-out occurs.
* The initial delay period is set based on processor number.  (The master
* processor does not delay.)  If the first probe of a location fails, an
* exponential increase in delay period is used to reduce bus contention on
* subsequent probes.
*
* This method is no better than receiving raw BERRs and does reduce bus
* contention and the number of BERRs.
*
* NOMANUAL
*/

STATUS usrSmObjInit 
    (
    char * bootString		/* boot parameter string */
    )
    {
    char *           smAnchor;		/* anchor address */
    char *           smObjFreeAdrs;	/* free pool address */
    int              smObjMemSize;	/* pool size */
    BOOT_PARAMS      params;		/* boot paramters */
    BOOL             allocatedPool;	/* TRUE if pool is maloced */
    SM_OBJ_PARAMS    smObjParams;	/* smObj setup parameters */
    char 	     bb;		/* bit bucket for vxMemProbe */
    int              tics;		/* SM probe delay period */
    UINT             temp;		/* temp for smUtilMemProbe() */
    UINT             maxWait   = SM_MAX_WAIT;
    char *           cp;
    SM_OBJ_MEM_HDR * pSmObjHdr = NULL;	/* ptr to SMO header */

    allocatedPool = FALSE;

    /* Check for hardware test and set availability */

    if (SM_TAS_TYPE != SM_TAS_HARD)
        {
        printf ("\nError initializing shared memory objects, ");
	printf ("hardware test-and-set required.\n");
        return (ERROR);
        }

    if (smObjLibInit () == ERROR)	/* initialize shared memory objects */
	{
        printf("\nERROR smObjLibInit : shared memory objects already initialized.\n");
	return (ERROR);
	}

    if (bootString == NULL)
        bootString = BOOT_LINE_ADRS;

    /* interpret boot command */

    if (usrBootLineCrack (bootString, &params) != OK)
        return (ERROR);

    /* set processor number: may establish vme bus access, etc. */

    if (_procNumWasSet != TRUE)
	{
    	sysProcNumSet (params.procNum);
	_procNumWasSet = TRUE;
	}

    /* if we booted via the sm device use the same anchor address for smObj */

    if (strncmp (params.bootDev, "sm=", 3) == 0)
        {
        if (bootBpAnchorExtract (params.bootDev, &smAnchor) < 0)
            {
	    printf ("\nError initializing shared memory objects, invalid ");
            printf ("anchor address specified: \"%s\"\n", params.bootDev);
            return (ERROR);
            }
        }
    else
        {
	smAnchor = (char *) SM_ANCHOR_ADRS;         /* default anchor */
        }

    /* If we are shared memory master CPU, set up shared memory object (SMO) */

    if (params.procNum == SM_MASTER)
        {
        smObjFreeAdrs = (char *) SM_OBJ_MEM_ADRS;
	smObjMemSize  = SM_OBJ_MEM_SIZE;

        /* allocate the shared memory object pool if needed */

        if (smObjFreeAdrs == (char *) NONE)
            {
            /* check cache configuration - must be read and write coherent */

	    if (!CACHE_DMA_IS_WRITE_COHERENT() || !CACHE_DMA_IS_READ_COHERENT())
                {
		printf ("usrSmObjInit - cache coherent buffer not available. Giving up.  \n");
		return (ERROR);
                }

            allocatedPool = TRUE;

            smObjFreeAdrs = (char *) cacheDmaMalloc (SM_OBJ_MEM_SIZE);

            if (smObjFreeAdrs == NULL)
		{
		printf ("usrSmObjInit - cannot allocate shared memory pool. Giving up.\n");
                return (ERROR);
		}
            }

        if (!allocatedPool)
            {
            /* free memory pool must be behind the anchor */
            smObjFreeAdrs += sizeof (SM_ANCHOR);

	    /* adjust pool size */
	    smObjMemSize = SM_OBJ_MEM_SIZE - sizeof (SM_ANCHOR);
            }

	/* probe anchor address */

	if (vxMemProbe (smAnchor, VX_READ, sizeof (char), &bb) != OK)
	    {
	    printf ("usrSmObjInit - anchor address %#x unreachable. Giving up.\n", (unsigned int) smAnchor);
	    return (ERROR);
	    }

	/* probe beginning of shared memory */

	if (vxMemProbe (smObjFreeAdrs, VX_WRITE, sizeof (char), &bb) != OK)
	    {
	    printf ("usrSmObjInit - shared memory address %#x unreachable. Giving up.\n", (unsigned int) smObjFreeAdrs);
	    return (ERROR);
	    }

        /* set up shared memory objects */
        
        smObjSpinTries = SM_OBJ_MAX_TRIES; /* must do before smObjSetup() */

        smObjParams.allocatedPool = allocatedPool;
        smObjParams.pAnchor       = (SM_ANCHOR *) smAnchor;
        smObjParams.smObjFreeAdrs = (char *) smObjFreeAdrs;
        smObjParams.smObjMemSize  = smObjMemSize;
        smObjParams.maxCpus       = DEFAULT_CPUS_MAX;
        smObjParams.maxTasks      = SM_OBJ_MAX_TASK;
        smObjParams.maxSems       = SM_OBJ_MAX_SEM;
        smObjParams.maxMsgQueues  = SM_OBJ_MAX_MSG_Q;
        smObjParams.maxMemParts   = SM_OBJ_MAX_MEM_PART;
        smObjParams.maxNames      = SM_OBJ_MAX_NAME;

        if (smObjSetup (&smObjParams) != OK)
            {
            if (errno == S_smObjLib_SHARED_MEM_TOO_SMALL)
               printf("\nERROR smObjSetup : shared memory pool too small.\n");

            if (allocatedPool)
                free (smObjFreeAdrs);			/* cleanup */

            return (ERROR);
            }
        }

    /*
     * Else, we are not the master CPU, so wait until the anchor and SMO
     * header regions are accessible (the master CPU has initialized them)
     * before continuing.
     */

    else
        {
        /* first wait for valid anchor region */

        tics = params.procNum;
        for (tics <<= 1; tics < maxWait; tics <<= 1)
            {
            smUtilDelay (NULL, tics);
            if ((smUtilMemProbe (smAnchor, VX_READ, sizeof (UINT),
                                 (char *)&temp) == OK) &&
                (ntohl (temp) == SM_READY))
                {
                break;
                }
            }

        if (tics >= maxWait)
            {
            printf ("usrSmObjInit: anchor @ %p unreachable. Giving up.\n",
                    smAnchor);
            return (ERROR);
            }

        /* Finally, wait for master to init SM Object facility */

        tics = params.procNum;
        cp = (char *)(&((SM_ANCHOR *)smAnchor)->smObjHeader);
        for (tics <<= 1; tics < maxWait; tics <<= 1)
            {
            if ((smUtilMemProbe (cp, VX_READ, sizeof (UINT), (char *)&temp)
                              == OK) &&
                (temp != (UINT)~0)   &&
                (temp != 0))
                {
                break;
                }
            smUtilDelay (NULL, tics);
            }

        pSmObjHdr = SM_OFFSET_TO_LOCAL (ntohl (temp), (int)smAnchor,
                                        SM_OBJ_MEM_HDR *);

        cp = (char *)(&pSmObjHdr->initDone);
        for ( ; tics < maxWait; tics <<= 1)
            {
            if ((smUtilMemProbe (cp, VX_READ, sizeof (UINT), (char *)&temp)
                              == OK) &&
                (ntohl (temp) == TRUE))
                {
                break;
                }
            smUtilDelay (NULL, tics);
            }

        if (tics >= maxWait)
            {
            printf ("usrSmObjInit: Error: time out awaiting SM Object init\n");
            return (ERROR);
            }
        }

    /*
     * initialize shared memory descriptor
     *
     *  Note that SM_OBJ_MAX_TRIES is passed to smObjInit(),
     *  and is used to set the global int smObjSpinTries.
     *  This has already been done above to fix SPR68418.
     */

    smObjInit (&smObjDesc, (SM_ANCHOR *) smAnchor, sysClkRateGet (),
               SM_OBJ_MAX_TRIES, SM_INT_TYPE, SM_INT_ARG1,
	       SM_INT_ARG2, SM_INT_ARG3);

    /* attach to shared memory object facility */

    printf ("Attaching shared memory objects at %#x... ", (int) smAnchor);

    if (smObjAttach (&smObjDesc) != OK)
	{
	printf ("failed: errno = %#x.\n", errno);
        return (ERROR);
	}

    printf ("done\n");
    return (OK);
    }