vxlib.c

VxWorks BSP框架源代码包含头文件和驱动

    vxHid0Set ((vxHid0Get() & ~(_PPC_HID0_DOZE | _PPC_HID0_NAP | 
		_PPC_HID0_SLEEP)) | hid0Mode);
#endif  /* CPU != PPC85XX */

    return (OK);

#elif	(CPU == PPC604)

    /* set vxPowMgtEnable and vxPowMgtMode according to <mode> */

    if (mode == VX_POWER_MODE_DISABLE) 
        {
	vxPowMgtEnable = FALSE;
	vxPowMgtMode = VX_POWER_MODE_DISABLE;
	}
    else
        {
    	if (mode == VX_POWER_MODE_NAP)
	    {
	    vxPowMgtMode = VX_POWER_MODE_NAP;
    	    vxPowMgtEnable = TRUE;
	    }
	else
	    return (ERROR);
	}
    
    return (OK);

#elif	((CPU == PPC860) || (CPU == PPC555))
    UINT32 	plprcrVal = 0;
    
# if (CPU == PPC555)
    int 	immrVal = vxImemBaseGet();
# else	/* CPU == PPC555 */
    int 	immrVal = vxImmrGet();
# endif	/* CPU == PPC555 */

    /* set plprcrVal, vxPowMgtEnable and vxPowMgtMode according to <mode> */

    switch (mode)
	{
	case VX_POWER_MODE_DISABLE:
	    plprcrVal = PLPRCR_LPM_NORMAL;
	    vxPowMgtMode = VX_POWER_MODE_DISABLE;
    	    vxPowMgtEnable = FALSE;
	    break;

	case VX_POWER_MODE_FULL:
	    plprcrVal = PLPRCR_LPM_NORMAL;
	    vxPowMgtMode = VX_POWER_MODE_FULL;
    	    vxPowMgtEnable = TRUE;
	    break;

    	case VX_POWER_MODE_DOZE:
	    plprcrVal = PLPRCR_LPM_DOZE;
	    vxPowMgtMode = VX_POWER_MODE_DOZE;
    	    vxPowMgtEnable = TRUE;
	    break;

    	case VX_POWER_MODE_SLEEP:
	    plprcrVal = PLPRCR_LPM_SLEEP;
	    vxPowMgtMode = VX_POWER_MODE_SLEEP;
    	    vxPowMgtEnable = TRUE;
	    break;

    	case VX_POWER_MODE_DEEP_SLEEP:
	    plprcrVal = PLPRCR_LPM_DEEP_SLEEP;
	    vxPowMgtMode = VX_POWER_MODE_DEEP_SLEEP;
    	    vxPowMgtEnable = TRUE;
	    break;

    	case VX_POWER_MODE_DOWN:
	    plprcrVal = PLPRCR_LPM_DOWN | PLPRCR_TEXPS;
	    vxPowMgtMode = VX_POWER_MODE_DOWN;
    	    vxPowMgtEnable = TRUE;
	    break;

	default:
	    return (ERROR);		/* mode not supported */
	}

    /* set new value for PLPRCR */

# if (CPU == PPC860)
    if (vx860KeyedRegUsed==TRUE)
        {
	*PLPRCRK(immrVal) = 0x55ccaa33; /* KEYED_REG_UNLOCK_VALUE */
	WRS_ASM("        isync");
	plprcrVal |= (*PLPRCR(immrVal) & ~PLPRCR_LPM_MSK);
        /* the delay value of 3 is worst case scenario */
	vxPlprcrSet ((UINT32*)immrVal,plprcrVal,3); 
	*PLPRCRK(immrVal) = ~0x55ccaa33; /* ~KEYED_REG_UNLOCK_VALUE */
        }
    else
        {
	plprcrVal |= (*PLPRCR(immrVal) & ~PLPRCR_LPM_MSK);
        /* the delay value of 3 is worst case scenario */ 
	vxPlprcrSet ((UINT32*)immrVal,plprcrVal,3);
        }

# else	/* CPU == PPC860 */
    *PLPRCR(immrVal) = (*PLPRCR(immrVal) & ~PLPRCR_LPM_MSK) | plprcrVal;
# endif	/* CPU == PPC860 */

    return (OK);

#else	/* remaining cases are 403, 405, 405F, 440, 505, 509, 601, 602 */

    return (ERROR);			/* power management not supported */

#endif	/* ((CPU == PPC603) || (CPU == PPCEC603)) */
    }

/*******************************************************************************
*
* vxPowerModeGet - get the power management mode 
*
* This routine returns the power management mode set via vxPowerDown().
*
* RETURNS:
* the power management mode (VX_POWER_MODE_DOZE, VX_POWER_MODE_NAP,
* VX_POWER_MODE_SLEEP, VX_POWER_MODE_DEEP_SLEEP, VX_POWER_MODE_DPM,
* VX_POWER_MODE_FULL, VX_POWER_MODE_DOWN or VX_POWER_MODE_DISABLE),
* or ERROR if no power mode has been selected or power management is
* not supported.
*
* SEE ALSO:
* vxPowerModeSet(), vxPowerDown()
*/

UINT32 vxPowerModeGet (void)
    {
#if	((CPU == PPC603) || (CPU == PPCEC603) || (CPU == PPC604) || \
	 (CPU == PPC860) || (CPU == PPC555) || (CPU == PPC85XX))

    return (vxPowMgtMode);		/* return mode set via vxPowerDown() */

#else	/* remaining cases are 403, 405, 405F, 440, 505, 509, 601, 602 */

    return (ERROR);			/* power management not supported */

#endif	/* PPC603, PPCEC603, PPC604, PPC860, PPC555 */
    }


#if	(CPU==PPC403)
/*******************************************************************************
*
* vxExierEnable - turn on external interrupt
*
* This routine enables specified external interrupt by setting the exier.
*
* RETURNS: old value of exier.
*
*/

UINT32 vxExierEnable 
    (
    UINT32 exier		/* external interrupts to enable */
    )
    {
    int oldExier = vxExierGet ();

    vxExierSet ((oldExier | exier));

    return (oldExier);
    }
/*******************************************************************************
*
* vxExierDisable - turn off external interrupt
*
* This routine disables specified external interrupt.  
*
* RETURNS: old value of exier.
*
*/
UINT32 vxExierDisable 
    (
    UINT32 exier		/* external interrupts to disable */
    )
    {
    int oldExier = vxExierGet ();

    vxExierSet ((oldExier & ~exier));

    return (oldExier);
    }
#endif	/* CPU==PPC403 */

#if 0 /*PCS Verify with DIAB folks. */
#ifdef	_DIAB_TOOL

/*
 * Copyright 1995 Diab Data, Inc.
 *
 * Description :
 * Implemention of PowerPC ABI function
 * void *__va_arg(va_list argp, int type)
 *
 * History :
 * When     Who     What
 * 950523   teve    initial
 */

#undef __EABI__
#define __EABI__	1

void *__va_arg(va_list argp, int type)
    {
    int index;
    char *rp;

    if (type == 1) 
        {	/* arg_WORD	*/
       	index = argp->__gpr;
       	if (index < 8) 
            {
    	    argp->__gpr = index + 1;
	    return argp->__reg + index*4;
	    } 
        else 
            {
	    rp = argp->__mem;
	    argp->__mem = rp + 4;
	    return rp;
	    }
	} 
    else if (type == 3) 
        {	/* arg_ARGREAL	*/
	index = argp->__fpr;
        if (index < 8) 
            {
            argp->__fpr = index + 1;
            return argp->__reg + index*8 + 32;
  	    } 
        else 
            {
	    rp = argp->__mem;
	    rp = (char *)(((long)rp + 7) & ~7);
            argp->__mem = rp + 8;
            return rp;
            }
        } 
    else if (type == 4) 
        {	/* arg_ARGSINGLE */
        index = argp->__fpr;
        if (index < 8) 
            {
            argp->__fpr = index + 1;
	    return argp->__reg + index*4 + 32;
            } 
        else 
            {
	    rp = argp->__mem;
            argp->__mem = rp + 4;
            return rp;
            }
        } 
    else if (type == 2) 
        {	/* arg_DOUBLEWORD */
        index = argp->__gpr;
      	index = (index + 1) & ~1;
       	if (index < 7) 
            { 
       	    argp->__gpr = index + 2;
       	    return argp->__reg + index*4;
       	    } 
        else 
            {
      	    rp = argp->__mem;
       	    argp->__gpr = index;
       	    rp = (char *)(((long)rp + 7) & ~7);
       	    argp->__mem = rp + 4;
       	    return rp;
       	    }
        } 
    else if (type == 0) 
        {	/* arg_ARGPOINTER */
        index = argp->__gpr;
        if (index < 8) 
            {
            argp->__gpr = index + 1;
	    return *(void **)(argp->__reg + index*4);
	    } 
        else 
            {
            rp = argp->__mem;
	    argp->__mem = rp + 4;
	    return *(void **)rp;
	    }
	}
    }    

#endif	/* _DIAB_TOOL */
#endif

#ifdef	_GREEN_TOOL

# if	( (CPU==PPC403) || (CPU==PPC405) || (CPU==PPC440) )
#define	__ppcsfp	/* soft floating point */
# endif	/* CPU==PPC403 || CPU==PPC405 || CPU==PPC440 */

/* the following code is from indvaarg.c of Green Hills */

/*
		    Low Level Interface Library

    Copyright 1983,1984,1985,1986,1987,1988,1989,1990,1991,1992,1993,1994
		    Green Hills Software,Inc.

 *  This program is the property of Green Hills Software, Inc,
 *  its contents are proprietary information and no part of it
 *  is to be disclosed to anyone except employees of Green Hills
 *  Software, Inc., or as agreed in writing signed by the President
 *  of Green Hills Software, Inc.
 *
*/

#define NINTREGS 8
#define NFLTREGS 13

# if !defined(__ppcsfp)

/* Power PC Varargs helper function */
/* This assumes that all pointers are the same size >= size of ints.
 * Actually for PPC pointers are the size of ints now, but this is
 * designed to be slightly more general.
 */
char * __gh_va_arg(va_list *pap, int isreg, int isfloat, int size)
    {
/* [Hal] Wed May 24 12:03:17 PDT 1995 - Rewrite to be reentrant. */
    char *z;
    if (isreg && !isfloat) 
        {
	/* ints */
	if (pap->int_cnt < NINTREGS) 
            {
	    return (char *)&pap->reg_ptr[pap->int_cnt++];
	    } 
        else 
            {
	    return (char *)&pap->oflo_ptr[pap->mem_cnt++];
	    }
        } 
    else if (isreg && isfloat) 
        {
	/* doubles */
#       define DSIZE (sizeof(double)/sizeof(int))
	if (pap->FP_cnt < NFLTREGS) 
            {
	    return (char *)(pap->reg_ptr+NINTREGS+(DSIZE*pap->FP_cnt++));
	    } 
        else 
            {
	    /* Align doubles */
	    pap->mem_cnt = ((pap->mem_cnt+DSIZE-1)/DSIZE)*DSIZE;
	    z = (char *)(pap->oflo_ptr+pap->mem_cnt);
	    pap->mem_cnt += DSIZE;
	    return z;
	    }
        } 
    else 
        {
	/* structs */
#       define PSIZE (sizeof(char *)/sizeof(int))
	if (pap->int_cnt < NINTREGS) 
            {
	    z = *(char **)(pap->reg_ptr+(PSIZE*pap->int_cnt));
	    pap->int_cnt += PSIZE;
	    } 
        else 
            {
	    z = *(char **)(pap->oflo_ptr+pap->mem_cnt);
	    pap->mem_cnt += PSIZE;
	    }
	return z;		/* structs passed as addresses */
       }
    }

# else /* __ppcsfp */
/* [Hal] Tue Mar 21 14:56:56 PST 1995 - Support for PPC403 software FP. */

char * __gh_va_arg(va_list *pap, int isreg, int isfloat, int size)
    {
/* [Hal] Wed May 24 12:03:17 PDT 1995 - Rewrite to be reentrant. */
    char *z;
    if (isreg && !isfloat) 
        {
	/* ints */
	if (pap->int_cnt < NINTREGS) 
            {
	    return (char *)&pap->reg_ptr[pap->int_cnt++];    /* fixed: & */
	    } 
        else 
            {
	    return (char *)&pap->oflo_ptr[pap->mem_cnt++];   /* fixed: & */
	    }
        } 
    else if (isreg && isfloat) 
        {
	/* doubles */
#       define DSIZE (sizeof(double)/sizeof(int))
	if (pap->int_cnt & 1)	/* Get to even offset */
	    pap->int_cnt += 1;
	if (pap->int_cnt < NINTREGS) 
            {
	    z = (char *)(pap->reg_ptr+pap->int_cnt);
	    pap->int_cnt += 2;
	    } 
        else 
            {
	    /* Align doubles */
	    pap->mem_cnt = ((pap->mem_cnt+DSIZE-1)/DSIZE)*DSIZE;
	    z = (char *)(pap->oflo_ptr+pap->mem_cnt);
	    pap->mem_cnt += DSIZE;
	    }
	return z;
        } 
    else 
        {
	/* structs */
#       define PSIZE (sizeof(char *)/sizeof(int))
	if (pap->int_cnt < NINTREGS) 
            {
	    z = *(char **)(pap->reg_ptr+(PSIZE*pap->int_cnt));
	    pap->int_cnt += PSIZE;
	    } 
        else 
            {
	    z = *(char **)(pap->oflo_ptr+pap->mem_cnt);
	    pap->mem_cnt += PSIZE;
	    }
	return z;		/* structs passed as addresses */
        }
    }

# endif	/* __ppcsfp */

#endif	/* _GREEN_TOOL */