mmue500lib.c

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

	if (mmuE500Selected & MMU_INST)
	    {
	    mmuPpcAEnable (MMU_I_ADDR_TRANS);	/* enable instruction MMU */
	    mmuPpcIEnabled = TRUE;		/* tell I MMU is turned on */

	    /* test if the Instruction cache should be enabled too */

	    if (cacheIToEnable)			
		cacheArchEnable (_INSTRUCTION_CACHE);	/* enable the I cache */
	    }

	if (mmuE500Selected & MMU_DATA)
	    {
	    mmuPpcAEnable (MMU_D_ADDR_TRANS);	/* enable data MMU */
	    mmuPpcDEnabled = TRUE;		/* tell D MMU is turned on */

	    /* test if the Data cache should be enabled too */

	    if (cacheDToEnable)
		cacheArchEnable (_DATA_CACHE);		/* enable the D cache */
	    }

	}
    else
	{

	if (mmuE500Selected & MMU_INST)
	    {
	    /*
	     * if the Instruction cache is enabled, then disable the 
	     * instruction cache before to disable the Instruction MMU.
	     */
	    if (cacheIToEnable)
		cacheArchDisableFromMmu (_INSTRUCTION_CACHE);

	    /* disable the Instruction MMU */

	    mmuPpcADisable (MMU_I_ADDR_TRANS);

	    /* set the flag to tell that the Instruction MMU is disabled */

	    mmuPpcIEnabled = FALSE;
	    }

	if (mmuE500Selected & MMU_DATA)
	    {
	    /*
	     * if the Data cache is enabled, then disable the Data cache
	     * to disable the Data MMU.
	     */
	    if (cacheDToEnable)
		cacheArchDisableFromMmu (_DATA_CACHE);

	    /* disable the Data MMU */

	    mmuPpcADisable (MMU_D_ADDR_TRANS);

	    /* set the flag to tell that the Data MMU is disabled */
	    mmuPpcDEnabled = FALSE;
	    }
	}
	
    /* AE would unmap EA 0x0 - 0x2fff here, but only for user mode tasks */

    intUnlock (lockKey);			/* unlock the interrupt */

    return (OK);
    }

/******************************************************************************
*
* mmuE500GlobalPageMap - map physical memory page to global virtual memory page
*
* mmuPpcGlobalPageMap is used to map physical pages into global virtual memory
* that is shared by all virtual memory contexts.  The translation tables
* for this section of the virtual space are shared by all virtual memory
* contexts.
*
* RETURNS: OK, or ERROR if no pte for given virtual page.
*/

LOCAL STATUS mmuE500GlobalPageMap
    (
    void *  effectiveAddr, 	/* effective address */
    void *  physicalAddr	/* physical address */
    )
    {
    return (mmuE500PageMap (mmuGlobalTransTbl, effectiveAddr, physicalAddr));
    }


/******************************************************************************
*
* mmuE500PageMap - map physical memory page to virtual memory page
*
* The physical page address is entered into the level 2 descriptor
* corresponding to the given virtual page.  The state of a newly mapped page
* is undefined.
*
* RETURNS: OK, or ERROR if translation table creation failed.
*/

LOCAL STATUS mmuE500PageMap
    (
    MMU_TRANS_TBL *	pTransTbl, 	/* translation table */
    void *		effectiveAddr, 	/* effective address */
    void *		physicalAddr	/* physical address */
    )
    {
    LEVEL_1_DESC *	pLvl1Desc;	/* level 1 descriptor address */
    LEVEL_1_DESC 	lvl1Desc;	/* level 1 descriptor */
    LEVEL_2_DESC *	pLvl2Desc;	/* level 2 descriptor address */
    LEVEL_2_DESC 	lvl2Desc;	/* level 2 descriptor */

    /* get the level 1 descriptor address */

    pLvl1Desc = mmuE500Lvl1DescAddrGet (pTransTbl, effectiveAddr);

    /* get the level 1 descriptor */

    lvl1Desc.l1desc = pLvl1Desc->l1desc;

    if (!lvl1Desc.field.v)
	{
	if (mmuE500Lvl1DescInit(pTransTbl, pLvl1Desc, effectiveAddr) == ERROR)
	    return (ERROR);
	}

    /*
     * Get the level 2 descriptor address. If the level 2 descriptor doesn't
     * exist then return ERROR.
     */

    if (mmuE500Lvl2DescAddrGet (pTransTbl, effectiveAddr, &pLvl2Desc) == ERROR)
	return (ERROR);

    /* get the level 2 descriptor */

    lvl2Desc = *pLvl2Desc;

    /* save the real address & effective addr in the level 2 descriptors */

    lvl2Desc.field.rpn = (UINT32) physicalAddr >> MMU_RPN_SHIFT;
    lvl2Desc.field.epn = (UINT32) effectiveAddr >> MMU_RPN_SHIFT;

    /* set the valid bit in the level 2 descriptor */
    lvl2Desc.field.v = 1;

    /* update the Level 2 descriptor in table */

    mmuE500Lvl2DescUpdate (pLvl2Desc, lvl2Desc);

    /* invalidate the tlb entry for this effective addr */
    mmuPpcE500Tlbie (pTransTbl, effectiveAddr);

    return (OK);
    }


/***********************************************************************
*
* mmuE500Lvl1DescInit -- initialize a level 1 descriptor
*
* Create the level 2 descriptor table, fill it in with appropriate
* defaults, and set up the level 1 descriptor to point at it.
*/

LOCAL STATUS mmuE500Lvl1DescInit
    (
    MMU_TRANS_TBL *	pTransTbl, 	/* translation table */
    LEVEL_1_DESC *	pLvl1Desc,	/* level 1 descriptor address */
    void *		effectiveAddr 	/* effective address */
    )
    {
    LEVEL_2_DESC *	pLvl2Desc;	/* Level 2 descriptor address */
    LEVEL_2_DESC	lvl2Desc;	/* Level 2 descriptor copy */
    LEVEL_1_DESC	lvl1Desc;	/* level 1 descriptor copy */
    int			ix;		/* general index counter */

    /*
     * Allocate memory to save the level 2 descriptor table.
     * The level 2 table needs to be aligned on a page boundary
     * and has a size of 1024 entries * 16 bytes/entry = 16K.
     */

    pLvl2Desc = (LEVEL_2_DESC *) memalign (MMU_PAGE_SIZE,
			    MMU_LVL_2_DESC_NB * sizeof(LEVEL_2_DESC));

    /*
     * check if the level 2 descriptor table was created properly.
     * If not then return ERROR.
     */

    if (pLvl2Desc == NULL)
	return (ERROR);
	
    /*
     * Initialize the very first level 2 descriptor in the table.
     * Note it is set up invalid.
     */

    /* word 0 */
    lvl2Desc.field.v     = 0;		/* initially invalid */
    lvl2Desc.field.iprot = 0;		/* not invalidate protected */
    lvl2Desc.field.rsvd1 = 0;
    lvl2Desc.field.tid   = 0;		/* tid = 0  */
    lvl2Desc.field.rsvd2 = 0;
    lvl2Desc.field.ts    = 1;		/* translation space 1 */
    lvl2Desc.field.tsize = 1;		/* default 4KB page */
    lvl2Desc.field.rsvd3 = 0;

    /* word 1 */
    lvl2Desc.field.epn    = 0;		/* effective page number */
    lvl2Desc.field.rsvd4  = 0;
    lvl2Desc.field.sharen = 0;		/* Do not enable cache fills to use shared cache stat */
    lvl2Desc.field.rsvd5  = 0;
    lvl2Desc.field.x0     = 0;		/* user defined 0 */
    lvl2Desc.field.x1     = 0;		/* user defined 1 */
    lvl2Desc.field.w      = 0;		/* no write thru */
    lvl2Desc.field.i      = 0;		/* no cache inhibit */
    lvl2Desc.field.m      = 0;		/* memory coherent: no effect */
    lvl2Desc.field.g      = 0;		/* memory unguarded */
    lvl2Desc.field.e      = 0;		/* big endian */

    /* word 2 */
    lvl2Desc.field.rpn   = 0;		/* real page number */
    lvl2Desc.field.rsvd6 = 0;	
    lvl2Desc.field.u0 = 0;		/* user attribute 0 unused */
    lvl2Desc.field.u1 = 0;		/* user attribute 1 unused */
    lvl2Desc.field.u2 = 0;		/* user attribute 2 unused */
    lvl2Desc.field.u3 = 0;		/* user attribute 3 unused */
    lvl2Desc.field.ux = 0;		/* user execute off */
    lvl2Desc.field.sx = 1;		/* supervisor execute on */
    lvl2Desc.field.uw = 0;		/* user write off */
    lvl2Desc.field.sw = 0;		/* supervisor write off */
    lvl2Desc.field.ur = 0;		/* user read off */
    lvl2Desc.field.sr = 1;		/* supervisor read on */

    /* word 3 */
    lvl2Desc.field.rsvd7 = 0;		

    /*
     * duplicate the first L2 descriptor through the rest of the table
     */

    for (ix = 0; ix < MMU_LVL_2_DESC_NB; ix ++)
	pLvl2Desc[ix] = lvl2Desc;

    /*
     * set up the Level 1 Descriptor with the new level 2 table pointer
     */

    lvl1Desc.l1desc = ((UINT32) pLvl2Desc) & MMU_LVL_1_L2BA_MSK;
    lvl1Desc.field.v   = 1;	/* segment valid */

    /* update the Level 1 descriptor in table */

    mmuE500Lvl1DescUpdate (pLvl1Desc, lvl1Desc);

    return (OK);
    }


/*******************************************************************************
*
* mmuE500Lvl1DescUpdate - update a level 1 descriptor
*
* This function updates a level 1 descriptor. The address of the level 1
* descriptor is handled by <pLvl1Desc> and the new value of the level 1
* descriptor by <lvl1Desc>.
*
* RETURNS: N/A
*/

LOCAL void mmuE500Lvl1DescUpdate
    (
    LEVEL_1_DESC *	pLvl1Desc,	/* Level 1 descriptor address */
    LEVEL_1_DESC	lvl1Desc	/* Level 1 descriptor */
    )
    {
    UINT32	key;

    if (mmuE500IsOn (MMU_INST)  || mmuE500IsOn (MMU_DATA))
	{
	/* circumvent page protection by turning MMU off to write entry */

	key = intLock();			/* lock interrupt */
	mmuE500Enable (FALSE);                   /* disable the mmu */
	pLvl1Desc->l1desc = lvl1Desc.l1desc;	/* update the descriptor */
	mmuE500Enable (TRUE);			/* enable the MMU */
	intUnlock(key);				/* re-enable interrupt */
	}
    else
	pLvl1Desc->l1desc = lvl1Desc.l1desc;	/* update the descriptor */
    }


/*******************************************************************************
*
* mmuE500Lvl2DescAddrGet - get the address of a level 2 Desciptor
*
* This routine finds the address of a level 2 descriptor corresponding to the
* <effectiveAddr> in the translation table pointed to by <pTransTbl> structure.
* If a matching level 2 Descriptor exists, the routine save the level 2
* descriptor address at the address pointed to by <ppLvl2Desc>.
* If any level 2 Descriptor matching the <effectiveAddr> is not found then
* the function return ERROR.
*
* RETURNS: OK or ERROR.
*/

LOCAL STATUS mmuE500Lvl2DescAddrGet
    (
    MMU_TRANS_TBL *	pTransTbl,	/* translation table */
    void *		effectiveAddr,	/* effective address */
    LEVEL_2_DESC **	ppLvl2Desc	/* where to save the lvl 2 desc addr */
    )
    {
    LEVEL_1_DESC * 	pLvl1Desc;	/* level 1 descriptor address */
    LEVEL_2_DESC *  	pLvl2Desc;  /* level 2 descriptor address */
    EFFECTIVE_ADDR	effAddr;	/* effective address */

    /* get address of the level 1 descriptor */

    pLvl1Desc = mmuE500Lvl1DescAddrGet (pTransTbl, effectiveAddr);

    /*
     * check the valid bit. If the level 1 descriptor is not valid than
     * the level 2 descriptor doesn't exist. In this case return ERROR.
     */

    if (!pLvl1Desc->field.v)
	return (ERROR);

    effAddr.effAddr = effectiveAddr;

    /*
     * save the level 2 descriptor address at the address
     * pointed to by <ppLvl2Desc>.
     */

    pLvl2Desc = (LEVEL_2_DESC *) (pLvl1Desc->field.l2ba << 2);
    * ppLvl2Desc = pLvl2Desc + effAddr.field.l2index;

    return (OK);
    }

/*******************************************************************************
*
* mmuE500Lvl2DescUpdate - update a level 2 descriptor
*
* This function updates a level 2 descriptor. The addess of the level 2
* descriptor is handled by <pLvl2Desc> and the new value of the level 2
* descriptor by <lvl2Desc>.
*
* RETURNS: N/A
*/

LOCAL void mmuE500Lvl2DescUpdate
    (
    LEVEL_2_DESC *	pLvl2Desc,	/* Level 2 descriptor address */
    LEVEL_2_DESC	lvl2Desc	/* Level 2 descriptor */
    )
    {
    UINT32	key;

    if (mmuE500IsOn (MMU_INST)  || mmuE500IsOn (MMU_DATA))
	{
	/* circumvent page protection by turning MMU off to write entry */

	key = intLock();			/* lock interrupt */
	mmuE500Enable (FALSE);                   /* disable the mmu */
	*pLvl2Desc = lvl2Desc;			/* update the descriptor */
	mmuE500Enable (TRUE);			/* enable the MMU */
	intUnlock(key);				/* re-enable interrupt */
	}
    else
	*pLvl2Desc = lvl2Desc;			/* update the descriptor */
    }

/*******************************************************************************
*
* mmuE500Lvl1DescAddrGet - get the address of a level 1 descriptor
*
* This function returns the address of the level 1 descriptor corresponding
* to the effective address pointed to by <effectiveAddr>.
*
* RETRUNS: always the address of the level 1 descriptor
*
*/

LOCAL LEVEL_1_DESC * mmuE500Lvl1DescAddrGet
    (
    MMU_TRANS_TBL *	pTransTbl,	/* translation table */
    void *		effectiveAddr	/* effective address */
    )
    {
    EFFECTIVE_ADDR	effAddr;

    effAddr = * ((EFFECTIVE_ADDR *) &effectiveAddr);

    /*
     * build the Level 1 descriptor address corresponding to the effective
     * address pointed to by <effectiveAddr>.
     */
    return ( pTransTbl->l1TblPtr.pL1Desc + effAddr.field.l1index );
    }

/*******************************************************************************
*
* mmuE500IsOn - return the state of the MMU
*
* This function returns TRUE if the MMU selected by <mmuType> is set to
* translation space 1.
*
* RETURNS: TRUE or FALSE
*
*/

LOCAL BOOL mmuE500IsOn
    (
    int	mmuType			/* MMU type to return the state of */
    )
    {

    switch (mmuType)
	{
	case MMU_INST:		/* Instruction MMU to test */
	    return (vxMsrGet () & _PPC_MSR_IS);
	    break;

	case MMU_DATA:		/* Data MMU to test */
	    return (vxMsrGet () & _PPC_MSR_DS);
	    break;

	default:		/* default value */
	    return (FALSE);
	}
    }


/*******************************************************************************
*
* mmuE500PidAlloc - get a free PID for use with a new address map from
*		mmuAddrMapArray, and set the address map element
*		to point to MMU_TRANS_TBL pointer.
*
* NOTE: For MMU library internal use only
*
* RETURNS: index of free array element, or -1 for ERROR.
*/
LOCAL UINT8 mmuE500PidAlloc (MMU_TRANS_TBL *transTbl)
    {
    int i;

    for (i = 1; i < MMU_ADDR_MAP_ARRAY_SIZE; i++)
        if (mmuAddrMapArray [i] == MMU_ADDR_MAP_ARRAY_INV)
	    {
	    mmuAddrMapArray [i] = transTbl;
	    return i;
	    }