scutest.c

这是单板上DPRAM的驱动程序

#include <psos.h>
#include "board.h"
#include "bspcomm.h"
#include "bspspec.h"
#include "scutest.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;
    
    if(callback == NULL)
        return SDE_FAIL;
    
    pCallback = callback;
    
    rc = q_create("TstQ", 20, Q_LOCAL|Q_PRIOR|Q_LIMIT|Q_PRIBUF, &TestQueID);
    if(rc != 0){
        return SDE_CREATE_QUEUE_FAIL;
    }
    
    rc = CreateTask("TstT", TestTask, &TestTaskID, GPriority, 0);
    if(rc != 0){
        return SDE_CREATE_TASK_FAIL;
    }
    
    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) {
        if(q_receive(TestQueID, Q_WAIT, 0, QRecvMsgBuf) != 0) {
            tm_wkafter(1);
            continue;
        }
        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_MT8980_TEST:
                rc = sd_cntrl(SDN_MT8980, 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
                    MT8980Test(Ti.param, &ctr);
                To.cmd   = Ti.cmd;
                To.param = &ctr;
                To.len   = sizeof(CommTestRsltStruct);
                rc = sd_cntrl(SDN_MT8980, SDC_SET_UNTEST_MODE, 0, 0);
                break;
            case SDC_NIU_TEST:
                rc = sd_cntrl(SDN_NIU, 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
                    NiuTest(Ti.param, &ctr);
                To.cmd   = Ti.cmd;
                To.param = &ctr;
                To.len   = sizeof(CommTestRsltStruct);
                rc = sd_cntrl(SDN_NIU, SDC_SET_UNTEST_MODE, 0, 0);
                break;
            case SDC_SPI_TEST:
                rc = sd_cntrl(SDN_SPI, SDC_SET_TEST_MODE, &eq, sizeof(SDCEventQueueStruct));
                SpiTest(&tr);
                To.cmd   = Ti.cmd;
                To.param = &tr;
                To.len   = sizeof(TestRsltStruct);
                rc = sd_cntrl(SDN_SPI, SDC_SET_UNTEST_MODE, &eq, sizeof(SDCEventQueueStruct));
                break;
            case SDC_HPI_TEST:
                HpiTest(&tr);
                To.cmd   = Ti.cmd;
                To.param = &tr;
                To.len   = sizeof(TestRsltStruct);
                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_DS1620_TEST:
                rc = sd_cntrl(SDN_DS1620A, SDC_SET_TEST_MODE, 0, 0);
                rc = sd_cntrl(SDN_DS1620B, SDC_SET_TEST_MODE, 0, 0);
                rc = sd_cntrl(SDN_DS1620C, SDC_SET_TEST_MODE, 0, 0);
                rc = sd_cntrl(SDN_DS1620D, SDC_SET_TEST_MODE, 0, 0);
                DS1620Test(&tr);
                To.cmd   = Ti.cmd;
                To.param = &tr;
                To.len   = sizeof(TestRsltStruct);
                rc = sd_cntrl(SDN_DS1620A, SDC_SET_UNTEST_MODE, 0, 0);
                rc = sd_cntrl(SDN_DS1620B, SDC_SET_UNTEST_MODE, 0, 0);
                rc = sd_cntrl(SDN_DS1620C, SDC_SET_UNTEST_MODE, 0, 0);
                rc = sd_cntrl(SDN_DS1620D, 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;
            case SDC_FN_TEST:
                FNTest(&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, SCUTEST_TASK_SSTACK_SIZE, SCUTEST_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 NiuTest(CommTestStruct *pct, CommTestRsltStruct *pctr)
{
    int i;
    NiuTestStruct nt;
    NiuTestStruct nr;
    volatile int rc, ErrCount=0;
    
    nt.Niu0 = 1;
    nt.Niu1 = 1;
    nt.ParamLen = sizeof(NiuTestStruct);
     
    if(pct->WrTest == 1){
        nr.Niu0 = -1;
        nr.Niu1 = -1;
        nr.ParamLen = sizeof(NiuTestStruct);
        
        rc = NiuChipWRTest(&nt, &nr);
        if(rc == SDE_NIU_MODE_ERROR){
            pctr->WrTest = SDE_FAIL;
            pctr->ErrInfo[ErrCount++] = SDE_NIU_MODE_ERROR;
        }
        else{
            pctr->WrTest = ((nr.Niu0==SDE_OK)&&(nr.Niu1==SDE_OK))?SDE_OK:SDE_FAIL;
            if(pctr->WrTest == SDE_FAIL){
                if(nr.Niu0 == SDE_FAIL)
                    pctr->ErrInfo[ErrCount++] = SDE_NIU0_WR_FAIL;
                if(nr.Niu1 == SDE_FAIL)
                    pctr->ErrInfo[ErrCount++] = SDE_NIU1_WR_FAIL;
            }
        }
    }
    if(pct->OnLineTest == 1){
        nr.Niu0 = -1;
        nr.Niu1 = -1;
        nr.ParamLen = sizeof(NiuTestStruct);
        
        rc = NiuLoopTest(&nt, &nr, INLOOP);
        if(rc == SDE_NIU_MODE_ERROR){
             pctr->OnLineTest = SDE_FAIL;
             pctr->ErrInfo[ErrCount++] = SDE_NIU_MODE_ERROR;
        }
        else{
            pctr->OnLineTest = ((nr.Niu0==SDE_OK)&&(nr.Niu1==SDE_OK))?SDE_OK:SDE_FAIL;
            if(pctr->OnLineTest == SDE_FAIL){
                if(nr.Niu0 == SDE_FAIL)
                    pctr->ErrInfo[ErrCount++] = SDE_NIU0_ONLINE_TEST_FAIL;
                if(nr.Niu1 == SDE_FAIL)
                    pctr->ErrInfo[ErrCount++] = SDE_NIU1_ONLINE_TEST_FAIL;    
            }
        }
    }
    if(pct->FacTest == 1){
        nr.Niu0 = -1;
        nr.Niu1 = -1;
        nr.ParamLen = sizeof(NiuTestStruct);
        
        rc = NiuLoopTest(&nt, &nr, EXLOOP);
        if(rc == SDE_NIU_MODE_ERROR){
             pctr->FacTest = SDE_FAIL;
             pctr->ErrInfo[ErrCount++] = SDE_NIU_MODE_ERROR;
        }
        else{
            pctr->FacTest = ((nr.Niu0==SDE_OK)&&(nr.Niu1==SDE_OK))?SDE_OK:SDE_FAIL;
            if(pctr->FacTest == SDE_FAIL){
                if(nr.Niu0 == SDE_FAIL)
                    pctr->ErrInfo[ErrCount++] = SDE_NIU0_FAC_TEST_FAIL;
                if(nr.Niu1 == SDE_FAIL)
                    pctr->ErrInfo[ErrCount++] = SDE_NIU1_FAC_TEST_FAIL;    
            }
        }    
    }
}

static void MT8980Test(CommTestStruct *pct, CommTestRsltStruct *pctr)
{
    TSTestStruct tsc,tsr;
    volatile int rc;
    
    if(pct->WrTest == 1){
        pctr->WrTest = (MT8980ChipWRTest()==SDE_OK)?SDE_OK:SDE_FAIL;
    }
    if(pct->OnLineTest == 1){
        tsc.ts0 = 0;
        tsc.ts1 = 1;
        tsc.ts2 = 1;
        tsc.ParamLen = sizeof(TSTestStruct);
        
        tsr.ts0 = -1;
        tsr.ts1 = -1;
        tsr.ts2 = -1;
        tsr.ParamLen = sizeof(TSTestStruct);
        
        rc = MT8980LoopTest(&tsc, &tsr);
        pctr->OnLineTest = ((tsr.ts1==SDE_OK)&&(tsr.ts2==SDE_OK))?SDE_OK:SDE_FAIL;
    }
    if(pct->FacTest == 1){
        tsc.ts0 = 1;
        tsc.ts1 = 1;
        tsc.ts2 = 1;
        tsc.ParamLen = sizeof(TSTestStruct);
        
        tsr.ts0 = -1;
        tsr.ts1 = -1;
        tsr.ts2 = -1;
        tsr.ParamLen = sizeof(TSTestStruct);
        
        rc = MT8980LoopTest(&tsc, &tsr);
        pctr->FacTest = ((tsr.ts0==SDE_OK)&&(tsr.ts1==SDE_OK)&&(tsr.ts2==SDE_OK))?SDE_OK:SDE_FAIL;
    }
}

static void HpiTest(TestRsltStruct *ptr)
{
    int i, j, DspNum, MaxDspNum, TestBlocks=10, RamBlock=10, ErrCount=0, ErrCount0;
    ULONG RetValue, WriteRam[10], ReadRam[10];
    
    MaxDspNum = (IsBPU2Installed()==TRUE)?4:2;
    
    for(DspNum = 0; DspNum < MaxDspNum; DspNum++) {
        ErrCount0 = 0;
        HPIReset(DspNum);
        
        HPIWriteULONG(DspNum, 0x80000002, 0x77777777);
        RetValue = HPIReadULONG(DspNum, 0x80000002);
        if(RetValue != 0x77777777) {
            ErrCount0++;
        }
        
        for(i = 0; i < TestBlocks; i++) {
            for (j = 0; j < RamBlock; j++)
                WriteRam[j] = (char)rand();
    
            HPIWriteRam(DspNum, i * RamBlock+0x80000000, RamBlock, WriteRam);
            HPIReadRam(DspNum, i * RamBlock+0x80000000, RamBlock, ReadRam);
            if(memcmp(WriteRam, ReadRam, RamBlock*4) != 0)
                ErrCount0++;
        }
        
        if(ErrCount0 != 0)
            ptr->ErrInfo[ErrCount++] = SDE_DSP0_FAIL - DspNum;
 
        HPIRunning(DspNum);
    }
    ptr->TestRslt = (ErrCount==0)?SDE_OK:SDE_FAIL;
}

static void SpiTest(TestRsltStruct *ptr)
{
    volatile int rc;
    int i, Slave, OpCodeRead, OpCodeWrite, TestByte=10, ErrCount0, ErrCount=0, CurDev;
    char pData[20], WriteValue;
    
    CurDev = SDN_SPI;
    tm_wkafter(2);
    for(i = 0; i < 16; i++){                        /* clear receive buffer */
        rc = sd_read(CurDev, pRecvBuf, MAX_TEST_BUF_LEN);
        if(rc == SDE_BUF_EMPTY) break;
    }
    
    for(Slave = 0; Slave < 2; Slave++){
        ErrCount0 = 0;
        rc = sd_cntrl(CurDev, SDC_SEL_SLAVE, &Slave, sizeof(int));
        rc = sd_cntrl(CurDev, SDC_PROGRAM_MODE, &Slave, sizeof(int));
        tm_wkafter(100);
        
        for (i = 1024; i < 1024 + TestByte; i++){
            /*  program enable */
        	rc = sd_cntrl(CurDev, SDC_SEL_SLAVE, &Slave, sizeof(int));
            pData[0] = pData[1] = 0xAC;
        	pData[2] = pData[3] = 0x53;
        	pData[4] = pData[5] = 0x00;
        	rc = sd_write(CurDev, pData, 6);
        	tm_wkafter(2);    
            rc = sd_read(CurDev, pRecvBuf, 6);
        	
            if(i >= 0 && i <= 255) OpCodeRead = 0x05;          /* data: 0x05; code : 0x01 */
            else if (i >= 256 && i <= 511) OpCodeRead = 0x0d;  /* data: 0x0d; code : 0x09 */
            else if (i >= 512 && i <= 1023) OpCodeRead = 0x15; /* data: 0x15; code : 0x11 */
            else if (i >= 1024 && i <= 2047) OpCodeRead = 0x25;/* data: 0x25; code : 0x21 */
            OpCodeWrite = OpCodeRead + 1;
        	
        	/*  write data memory */
        	rc = sd_cntrl(CurDev, SDC_SEL_SLAVE, &Slave, sizeof(int));
            pData[0] = pData[1] = OpCodeWrite;
        	pData[2] = pData[3] = i % 256;
        	pData[4] = pData[5] = WriteValue = (char)rand();
        	rc = sd_write(CurDev, pData, 6);
        	tm_wkafter(2);  
        	rc = sd_read(CurDev, pRecvBuf, 6);
        	
        	/*  read data memory */
        	rc = sd_cntrl(CurDev, SDC_SEL_SLAVE, &Slave, sizeof(int));
            pData[0] = pData[1] = OpCodeRead;
        	pData[2] = pData[3] = i % 256;
        	pData[4] = pData[5] = 0x00;
        	rc = sd_write(CurDev, pData, 6);
        	tm_wkafter(4);
            rc = sd_read(CurDev, pRecvBuf, 6);
        	
            if(pRecvBuf[4] != WriteValue)
                ErrCount0++;
        }
        if(ErrCount0 != 0)
            ptr->ErrInfo[ErrCount++] = SDE_RFIU0_FAIL - Slave;
        rc = sd_cntrl(CurDev, SDC_CLOSE, &Slave, sizeof(int));
        rc = sd_cntrl(CurDev, SDC_RUN, &Slave, sizeof(int));
    }
    ptr->TestRslt = (ErrCount==0)?SDE_OK:SDE_FAIL;
}

static int MT8980ChipWRTest(void)
{
    int i, j, ErrCount=0;
    char ReadVal, WriteVal;
    
    for (i = 0; i < 8; i++) {
        WriteVal = (0x18 | (i & 0x7));
        REG8(MT8980_BASE) = WriteVal;                     /* Conn Mem High(11) */
        ReadVal = REG8(MT8980_BASE);
        if(ReadVal != WriteVal)
            ErrCount++;
            
        for (j = 0; j < 32; j++) {
            WriteVal = 0x1;
            REG8(MT8980_BASE + 0x20 + j) = WriteVal;
            ReadVal = REG8(MT8980_BASE + 0x20 + j);
            if(ReadVal != WriteVal)
                ErrCount++;
        }
        
        WriteVal = (0x10 | (i & 0x7));
        REG8(MT8980_BASE) = WriteVal;                     /* Conn Mem Low(10) */
        ReadVal = REG8(MT8980_BASE);
        if(ReadVal != WriteVal)
            ErrCount++;
            
        for (j = 0; j < 32; j++) {
            WriteVal = j;
            REG8(MT8980_BASE + 0x20 + j) = WriteVal; 
            ReadVal = REG8(MT8980_BASE + 0x20 + j);
            if(ReadVal != WriteVal)
                ErrCount++;
        }
    }
    return (ErrCount==0)?SDE_OK:SDE_FAIL;
}