cmmtest.c

这是单板上DPRAM的驱动程序

#include <psos.h>
#include "board.h"
#include "bspcomm.h"
#include "bspspec.h"
#include "cmmtest.h"

static ULONG TestTaskID, TestQueID;
static volatile int FNCount, TicksCount, GPriority;
static volatile char pSendBuf[MAX_TEST_BUF_LEN], pRecvBuf[MAX_TEST_BUF_LEN];
static void (*pCallback)(int cmd, void *param, int len);

int TestTaskInit(int priority, void (*callback)(int cmd, void *param, int len))
{
    volatile int rc;
    
    GPriority = priority;
    
    rc = CreateTask("TstT", TestTask, &TestTaskID, GPriority, 0);
    if(rc != 0){
        return SDE_CREATE_TASK_FAIL;
    }
    
    rc = q_create("TstQ", 0, Q_LOCAL|Q_PRIOR|Q_NOLIMIT|Q_PRIBUF, &TestQueID);
    if(rc != 0){
        return SDE_CREATE_QUEUE_FAIL;
    }
    
    pCallback = callback;
    return SDE_OK;
}

void TestTaskCmd(int cmd, void *param, int len)
{
    int i;
    ULONG QSendMsgBuf[4];
    
    QSendMsgBuf[0] = cmd;
    QSendMsgBuf[1] = (ULONG)param;
    QSendMsgBuf[2] = len;
    
    q_send(TestQueID, QSendMsgBuf);
}

static void TestTask(void)
{
    int i;
    volatile int rc;
    TestStruct Ti, To;
    SDCEventQueueStruct eq;
    TestRsltStruct tr;
    CommTestRsltStruct ctr;
    ULONG QRecvMsgBuf[4];
    
    while (1) {
        q_receive(TestQueID, Q_WAIT, 0, QRecvMsgBuf);
        Ti.cmd   = QRecvMsgBuf[0];
        Ti.param = (void *)QRecvMsgBuf[1];
        Ti.len   = QRecvMsgBuf[2];
        
        memset(&tr, 0, sizeof(TestRsltStruct));
        memset(&ctr, 0, sizeof(CommTestRsltStruct));
        switch(Ti.cmd){
            case SDC_MT90826_TEST:
                rc = sd_cntrl(SDN_MT90826, SDC_SET_TEST_MODE, 0, 0);
                if(Ti.len < sizeof(CommTestStruct)){
                    ctr.WrTest     = SDE_FAIL;
                    ctr.OnLineTest = SDE_FAIL;
                    ctr.FacTest    = SDE_FAIL;
                    ctr.ErrInfo[0] = SDE_INVALID_ARG;
                }    
                else
                    MT90826Test(Ti.param, &ctr);
                To.cmd   = Ti.cmd;
                To.param = &ctr;
                To.len   = sizeof(CommTestRsltStruct);
                rc = sd_cntrl(SDN_MT90826, SDC_SET_UNTEST_MODE, 0, 0);
                break;
    		case SDC_DS21354_TEST:
				ti.Cmd    		
    			rc = sd_cntrl(SDN_DS21354_A, SDC_SET_TEST_MODE, 0, 0);
    			
    			rc = sd_cntrl(SDN_DS21354_A, SDC_UNSET_TEST_MODE, 0, 0);
    			break;
            case SDC_FLASH_TEST:
                rc = sd_cntrl(SDN_FLASH, SDC_SET_TEST_MODE, 0, 0);
                FlashTest(&tr);
                To.cmd   = Ti.cmd;
                To.param = &tr;
                To.len   = sizeof(TestRsltStruct);
                rc = sd_cntrl(SDN_FLASH, SDC_SET_UNTEST_MODE, 0, 0);
                break;
            case SDC_ALARMS_TEST:
                AlarmsTest(&tr);
                To.cmd   = Ti.cmd;
                To.param = &tr;
                To.len   = sizeof(TestRsltStruct);
                break;
            default:
                break;
        }
        
        pCallback(To.cmd, To.param, To.len);
    }
}

static int CreateTask(char *name,void (*task)(void), ULONG *tid, int priority, ULONG *p)
{
    volatile int rc;
    rc = t_create(name, priority, TASK_SSTACK_SIZE, TASK_USTACK_SIZE, 0, tid);
    if (rc != 0) 
        return rc;
    rc = t_start(*tid, T_SUPV|T_PREEMPT|T_TSLICE, task, p);
    if (rc != 0) { t_delete(*tid); return rc; }
    return 0;
}

static void MT90826Test(CommTestStruct *pct, CommTestRsltStruct *pctr)
{
    TSTestStruct tsc,tsr;
    volatile int rc;
    int i;
    if(pct->WrTest == 1){
 
    }
    if(pct->OnLineTest == 1){
        //pctr->OnLineTest = ((tsr.ts1==SDE_OK)&&(tsr.ts2==SDE_OK))?SDE_OK:SDE_FAIL;
    }
    if(pct->FacTest == 1){
        memset(&(tsc.ts[0]),1,MAX_TS_NUM);
        tsc.ParamLen = sizeof(TSTestStruct);
        memset(&(tsc.ts[0]),-1,MAX_TS_NUM);
        tsr.ParamLen = sizeof(TSTestStruct);
        rc = MT90826MsgModeTest(&tsc, &tsr);
        for(i=0;i<MAX_TS_NUM;i++){
        	if(tsr.t[i]!=SDE_OK){
        		pctr->FacTest=SDE_MSG_FAIL;
        		break;
        	}
        	pctr->FacTest=SDE_OK;
        }
        memset(&(tsc.ts[0]),1,MAX_TS_NUM);
        tsc.ParamLen = sizeof(TSTestStruct);
        memset(&(tsc.ts[0]),-1,MAX_TS_NUM);
        tsr.ParamLen = sizeof(TSTestStruct);
        rc = MT90826LoopTest(&tsc, &tsr);
        for(i=0;i<MAX_TS_NUM;i++){
        	if(tsr.t[i]!=SDE_OK){
        		pctr->FacTest=SDE_LOOP_FAIL;
        		break;
        	}
        	pctr->FacTest=SDE_OK;
        }
    }
}
static int MT90826MsgModeTest(TSTestStruct *ptt, TSTestStruct *pttr)
{
	volatile int rc;
    int i, j;
    SDCConfigTsStruct Cfg;
    if((ptt->ParamLen < sizeof(TSTestStruct)) | (pttr->ParamLen < sizeof(TSTestStruct)))
        return SDE_INVALID_ARG;
    
    
}

static int MT90826LoopTest(TSTestStruct *ptt, TSTestStruct *pttr)
{
    volatile int rc;
    int i, j;
    SDCConfigTsStruct Cfg;
    
    if((ptt->ParamLen < sizeof(TSTestStruct)) | (pttr->ParamLen < sizeof(TSTestStruct)))
        return SDE_INVALID_ARG;
    
    for(i = 0; i < MAX_TS_NUM; i++){
    	if(*(&(ptt->ts[0]) + i) == 1){
	        Cfg.StreamIn = 19;
	        Cfg.ChanIn = i;
	        Cfg.StreamOut = 3;
	        Cfg.ChanOut = i;
	        rc = sd_cntrl(SDN_MT90826, SDC_CONFIG_TS, &Cfg, sizeof(SDCConfigTsStruct));
	        Cfg.StreamIn = 3;
	        Cfg.ChanIn = i;
	        Cfg.StreamOut = 19;
	        Cfg.ChanOut = i;
	        rc = sd_cntrl(SDN_MT90826, SDC_CONFIG_TS, &Cfg, sizeof(SDCConfigTsStruct));
	    }
    }    
    QMCTest(ptt, pttr);
    return SDE_OK;
}

static void QMCTest(TSTestStruct *ptt, TSTestStruct *pttr)
{
    volatile int rc, SendCount=0;
    int i, j, CurDev;
    SDCEventQueueStruct eq;
    
    for(i = 0; i < MAX_TS_NUM; i++){
        if(*(&(ptt->ts[0]) + i) == 1){
            CurDev = SDN_TRM_OM1 + i;
            rc = sd_cntrl(CurDev, SDC_SET_TEST_MODE, &eq, sizeof(SDCEventQueueStruct));
            tm_wkafter(5);
            for(j = 0; j < 16; j++){     /* clear receive buffer */
                rc = sd_read(CurDev, pRecvBuf, MAX_TEST_BUF_LEN);
                if(rc == SDE_BUF_EMPTY) break;
            }
        }
    }
    
    for(i = 0; i < MAX_TEST_BUF_LEN; i++)
        pSendBuf[i] = (char)rand();
    
    SendCount = 0;
    for(i = 0; i < MAX_TS_NUM; i++){
        if(*(&(ptt->ts[i]) == 0)
            continue;
        
        CurDev = SDN_TRM_OM1 + i;
        rc = sd_write(CurDev, pSendBuf, MAX_TEST_BUF_LEN);
        tm_wkafter(5);
        rc = sd_read(CurDev, pRecvBuf, MAX_TEST_BUF_LEN);
        if (memcmp(pSendBuf, pRecvBuf, MAX_TEST_BUF_LEN) == 0){
            *(&(pttr->ts[i]) = SDE_OK;
        }
        else {
            i--;
            SendCount++;
            if(SendCount == MAX_SEND_TIMES){
                *(&(pttr->ts[i+1]) = SDE_FAIL;
                SendCount = 0;
                i++;
            }
        }
    }
    
    for(i = 0; i < MAX_TS_NUM; i++){
        if(*(&(ptt->ts[i]) == 1){
            CurDev = SDN_TRM_OM1 + i;
            rc = sd_cntrl(CurDev, SDC_SET_UNTEST_MODE, &eq, sizeof(SDCEventQueueStruct));
        }
    }
}

static void FlashTest(TestRsltStruct *ptr)
{
    int i, j, BytesToTest=20;
    SDCFlashAccessStruct FlashAccessWrite, FlashAccessRead;
    char *pReadBuf, pWriteBuf[20];
    volatile int rc, ErrCount=0;
        
    pReadBuf = (char *)malloc(BytesToTest);
    for(i = 0; i < BytesToTest; i++)
        pWriteBuf[i] = (char)rand();    
    
    for(i = 0; i < 2; i++){
        FlashAccessWrite.Offset = 4 + i * FLASH0_SIZE;
        FlashAccessWrite.Size = BytesToTest;
        FlashAccessWrite.Base = pWriteBuf;
        
        FlashAccessRead.Offset = 4+ i * FLASH0_SIZE;
        FlashAccessRead.Size = BytesToTest;
        FlashAccessRead.Base = pReadBuf;
        
        rc = sd_cntrl(SDN_FLASH, SDC_ERASE_SECTOR, &FlashAccessWrite.Offset, sizeof(ULONG)); 
        if(rc != 0) ptr->ErrInfo[ErrCount++] = SDE_FLASH0_ERASE_SECTOR_FAIL-i;
        rc = sd_cntrl(SDN_FLASH, SDC_WRITE_FLASH, &FlashAccessWrite, sizeof(SDCFlashAccessStruct));
        if(rc != 0) ptr->ErrInfo[ErrCount++] = SDE_FLASH0_WRITE_FAIL-i;
        rc = sd_cntrl(SDN_FLASH, SDC_READ_FLASH, &FlashAccessRead, sizeof(SDCFlashAccessStruct));
        if(rc != 0) ptr->ErrInfo[ErrCount++] = SDE_FLASH0_READ_FAIL-i;
        if(memcmp(FlashAccessWrite.Base, FlashAccessRead.Base, BytesToTest) != 0) ErrCount++;
    }
    ptr->TestRslt = (ErrCount==0)?SDE_OK:SDE_FAIL;

 /*   rc = sd_cntrl(SDN_FLASH, SDC_ERASE_CHIP, NULL, 0);*/
}


static void AlarmsTest(TestRsltStruct *ptr)
{
    ULONG temp;
    int ErrCount=0;
    
    temp=*(ULONG *)(CS7_BASE+8);
    
    if((temp&(1L<<(31-0)))==0)
        ptr->ErrInfo[ErrCount++] = SDE_FCLK_FAIL;
    if((temp&(1L<<(31-1)))==0)
        ptr->ErrInfo[ErrCount++] = SDE_OBCLK_FAIL;
    ptr->TestRslt = (ErrCount==0)?SDE_OK:SDE_FAIL;
}