usrwdb.c

ppc 8245 可编译bsp 包括 uart

    wdbBpInstall ();
#endif
    }

/******************************************************************************
*
* wdbTgtHasFpp - TRUE if target has floating point support.
*/

LOCAL bool_t wdbTgtHasFpp (void)
    {
#ifdef	INCLUDE_HW_FP
    if (fppProbe() == OK)
	return (TRUE);
    return (FALSE);
#else
    return (FALSE);
#endif
    }

/******************************************************************************
*
* wdbRtInfoGet - get info on the VxWorks run time system.
*/

LOCAL void wdbRtInfoGet
    (
    WDB_RT_INFO *	pRtInfo
    )
    {
    pRtInfo->rtType	= WDB_RT_VXWORKS;
    pRtInfo->rtVersion	= vxWorksVersion;
    pRtInfo->cpuType	= CPU;
    pRtInfo->hasFpp	= wdbTgtHasFpp();
#ifdef	INCLUDE_PROTECT_TEXT
    pRtInfo->hasWriteProtect	= (vmLibInfo.pVmTextProtectRtn != NULL);
#else	/* !INCLUDE_PROTECT_TEXT */
    pRtInfo->hasWriteProtect	= FALSE;
#endif	/* !INCLUDE_PROTECT_TEXT */
    pRtInfo->pageSize   = VM_PAGE_SIZE_GET();
    pRtInfo->endian	= _BYTE_ORDER;
    pRtInfo->bspName	= sysModel();

    pRtInfo->bootline	= vxBootFile;

    pRtInfo->memBase	= (TGT_ADDR_T)(LOCAL_MEM_LOCAL_ADRS);
    pRtInfo->memSize	= (int)sysMemTop() - (int)LOCAL_MEM_LOCAL_ADRS;
    pRtInfo->numRegions	= wdbNumMemRegions;
    pRtInfo->memRegion	= pWdbMemRegions;

    pRtInfo->hostPoolBase = (TGT_ADDR_T)WDB_POOL_BASE;
    pRtInfo->hostPoolSize = WDB_POOL_SIZE;
    }

/******************************************************************************
*
* vxReboot - reboot the system.
*/

LOCAL void vxReboot (void)
    {
    reboot (0);
    }

/******************************************************************************
*
* vxMemProtect - protect a region of memory.
*/

LOCAL STATUS vxMemProtect
    (
    char * addr,
    u_int  nBytes,
    bool_t protect		/* TRUE = protect, FALSE = unprotect */
    )
    {
    return (VM_STATE_SET (NULL, addr, nBytes, VM_STATE_MASK_WRITABLE, 
                     (protect ? VM_STATE_WRITABLE_NOT : VM_STATE_WRITABLE)));
    }

#ifdef	INCLUDE_VXWORKS_KERNEL
/******************************************************************************
*
* wdbSp - spawn a task with default params
*/ 

#define PRIORITY        100
#define OPTIONS         VX_FP_TASK

void wdbSp
    (
    int (*func)(),
    int arg0,
    int arg1,
    int arg2,
    int arg3,
    int arg4
    )
    {
    taskSpawn (NULL, PRIORITY, OPTIONS, WDB_SPAWN_STACK_SIZE, func, arg0,
        arg1, arg2, arg3, arg4, 0, 0, 0, 0, 0);
    }

/******************************************************************************
*
* vxTaskCreate - WDB callout to create a task (and leave suspended).
*
* RETURNS : Task ID or ERROR if unable to create a task
*
* NOMANUAL
*/

LOCAL int vxTaskCreate
    (
    char *   name,       /* name of new task (stored at pStackBase)   */
    int      priority,   /* priority of new task                      */
    int      options,    /* task option word                          */
    caddr_t  stackBase,  /* base of stack. ignored by VxWorks	      */
    int      stackSize,  /* size (bytes) of stack needed plus name    */
    caddr_t  entryPt,    /* entry point of new task                   */
    int      arg[10],	 /* 1st of 10 req'd task args to pass to func */
    int      fdIn,	 /* fd for input redirection		      */
    int      fdOut,	 /* fd for output redirection		      */
    int      fdErr	 /* fd for error output redirection	      */
    )
    {
    int tid;

    if (stackSize == 0)
	stackSize = WDB_SPAWN_STACK_SIZE;

    tid = taskCreat (name, priority, options, stackSize, (int (*)())entryPt,
		arg[0], arg[1], arg[2], arg[3], arg[4], arg[5], arg[6],
		arg[7], arg[8], arg[9]);

    if (tid == NULL)		/* create failed */
	return (ERROR);

#ifdef	INCLUDE_IO_SYSTEM
    if (fdIn != 0)
	ioTaskStdSet (tid, 0, fdIn);
    if (fdOut != 0)
	ioTaskStdSet (tid, 1, fdOut);
    if (fdErr != 0)
	ioTaskStdSet (tid, 2, fdErr);
#endif	/* INCLUDE_IO_SYSTEM */

    return (tid);
    }


/******************************************************************************
*
* vxTaskResume - WDB callout to resume a suspended task.
*/

LOCAL STATUS vxTaskResume
    (
    WDB_CTX *	pContext
    )
    {
    if (pContext->contextType != WDB_CTX_TASK)
	return (ERROR);

    return (taskResume (pContext->contextId));
    }

/******************************************************************************
*
* vxTaskSuspend - WDB callout to suspend a task.
*/

LOCAL STATUS vxTaskSuspend
    (
    WDB_CTX *	pContext
    )
    {
    if (pContext->contextType != WDB_CTX_TASK)
	return (ERROR);

    return (taskSuspend (pContext->contextId));
    }

/******************************************************************************
*
* vxTaskDelete - WDB callout to delete a task.
*/

LOCAL STATUS vxTaskDelete
    (
    WDB_CTX *	pContext
    )
    {
    if (pContext->contextType != WDB_CTX_TASK)
	return (ERROR);

    return (taskDelete (pContext->contextId));
    }

/******************************************************************************
*
* vxTaskRegsSet - WDB callout to get a task register set.
*/

LOCAL STATUS vxTaskRegsSet
    (
    WDB_CTX *	 pContext,
    WDB_REG_SET_TYPE regSetType,
    char *	 pRegSet
    )
    {
    STATUS		status;

    if (pContext->contextType != WDB_CTX_TASK)
	return (ERROR);

    switch (regSetType)
	{
	case WDB_REG_SET_IU:
	    status = taskRegsSet (pContext->contextId, (REG_SET *)pRegSet);
	    break;

#ifdef  INCLUDE_HW_FP
	case WDB_REG_SET_FPU:
	    {
	    WIND_TCB * pTcb = taskTcb (pContext->contextId);

	    if ((pTcb == NULL) || (pTcb->pFpContext == NULL))
		return (ERROR);

	    bcopy (pRegSet, (char *)(pTcb->pFpContext), sizeof (FP_CONTEXT));
	    return (OK);
	    }
#endif	/* INCLUDE_HW_FP */

	default:
	    status = ERROR;
	}

    return (status);
    }

/******************************************************************************
*
* vxTaskRegsGet - WDB callout to get a tasks register set.
*
* This routine is not reentrant, but it it only called by one thread (the
* WDB agent).
*/

LOCAL STATUS vxTaskRegsGet
    (
    WDB_CTX *		pContext,
    WDB_REG_SET_TYPE 	regSetType,
    char **		ppRegSet
    )
    {
    WIND_TCB * pTcb;
    if (pContext->contextType != WDB_CTX_TASK)
	return (ERROR);

    pTcb = taskTcb (pContext->contextId);
    if (pTcb == NULL)
	return (ERROR);

    switch (regSetType)
	{
	case WDB_REG_SET_IU:
	    {
	    REG_SET dummy;
	    taskRegsGet (pContext->contextId, &dummy);
	    *ppRegSet = (char *) &pTcb->regs;
	    return (OK);
	    }

#ifdef  INCLUDE_HW_FP
	case WDB_REG_SET_FPU:
	    if (pTcb->pFpContext == NULL)
		return (ERROR);		/* no coprocessor support */

	    *ppRegSet = (char *) pTcb->pFpContext;
	    return (OK);
#endif	/* INCLUDE_HW_FP */

	default:
	    return (ERROR);
	}

    }

/******************************************************************************
*
* vxSemCreate - create a SEMAPHORE
*/

LOCAL void * vxSemCreate (void)
    {
    return ((void *)semBCreate (0, 0));
    }

/******************************************************************************
*
* vxSemGive - give a semaphore
*/

LOCAL STATUS vxSemGive
    (
    void * semId
    )
    {
    return (semGive ((SEM_ID)semId));
    }

/******************************************************************************
*
* vxSemTake - take a semaphore
*/

LOCAL STATUS vxSemTake
    (
    void *		semId,
    struct timeval *	tv
    )
    {
    return (semTake ((SEM_ID) semId, 
	(tv == NULL ? WAIT_FOREVER :
	tv->tv_sec * sysClkRateGet() +
	(tv->tv_usec * sysClkRateGet()) / MILLION)));
    }
#endif	/* INCLUDE_VXWORKS_KERNEL */

/******************************************************************************
*
* vxExcHookAdd -
*/

LOCAL void (*vxExcHook)();

LOCAL int vxExcHookWrapper (int vec, char *pESF, WDB_IU_REGS *pRegs)
    {
    WDB_CTX	context;
    static int	restartCnt;
    extern int	wdbTaskId;

    if (INT_CONTEXT() || wdbIsNowExternal() || (taskIdCurrent == 0))
	context.contextType = WDB_CTX_SYSTEM;
    else
	context.contextType = WDB_CTX_TASK;
    context.contextId	= (int)taskIdCurrent;

    (*vxExcHook)(context, vec, pESF, pRegs);

    /*
     * if the exception is in the agent task, restart the agent
     * after a delay.
     */

    if (((int)taskIdCurrent == wdbTaskId) && (restartCnt < WDB_MAX_RESTARTS))
	{
	restartCnt++;
	if (_func_logMsg != NULL)
	    _func_logMsg ("WDB exception. restarting agent in %d seconds...\n",
		WDB_RESTART_TIME, 0,0,0,0,0);
	taskDelay (sysClkRateGet() * WDB_RESTART_TIME);
	taskRestart (0);
	}

    return (FALSE);
    }

LOCAL void vxExcHookAdd
    (
    void	(*hook)()
    )
    {
    vxExcHook = hook;

    _func_excBaseHook = vxExcHookWrapper;
    }

/******************************************************************************
*
* __wdbTaskDeleteHook -
*/ 

LOCAL int __wdbTaskDeleteHook
    (
    WIND_TCB *pTcb
    )
    {
    WDB_CTX	ctx;
    void	(*hook)();

    hook = pTcb->wdbExitHook;

    if (hook != NULL)
	{
	ctx.contextType	= WDB_CTX_TASK;
	ctx.contextId	= (UINT32)pTcb;
	(*hook) (ctx, pTcb->exitCode, pTcb->errorStatus);
	}

    return (OK);
    }

/******************************************************************************
*
* vxTaskDeleteHookAdd - task-specific delete hook (one per task).
*
* currently only one hook per task.
*/ 

LOCAL STATUS vxTaskDeleteHookAdd
    (
    UINT32	tid,
    void	(*hook)()
    )
    {
    static int initialized = FALSE;

    if (taskIdVerify ((int)tid) == ERROR)
	return (ERROR);

    taskTcb (tid)->wdbExitHook = hook;

    if (!initialized)
	{
	taskDeleteHookAdd (__wdbTaskDeleteHook);
	initialized = TRUE;
	}

    return (OK);
    }

/******************************************************************************
*
* __wdbTaskCreateHook - task create hook
*
* This hook is called each time a task is created.
*
* RETURNS : OK always
*/ 

LOCAL int __wdbTaskCreateHook
    (
    WIND_TCB *	pTcb
    )
    {
    WDB_CTX	createdCtx;
    WDB_CTX	creationCtx;

    if (wdbCreateHook != NULL)
	{
	/* fill createdCtx structure */

	createdCtx.contextType	= WDB_CTX_TASK;
	createdCtx.contextId	= (UINT32)pTcb;

	/* fill creationCtx structure */

	creationCtx.contextType	= WDB_CTX_TASK;
	creationCtx.contextId	= (UINT32)taskIdCurrent;