test.c

ICETEK-DM642-EDUlabv1.3.rar

        MCBSP_FMKS(RCR, RFRLEN2, DEFAULT)       |
        MCBSP_FMKS(RCR, RWDLEN2, DEFAULT)       |
        MCBSP_FMKS(RCR, RCOMPAND, MSB)          |
        MCBSP_FMKS(RCR, RFIG, NO)               |
        MCBSP_FMKS(RCR, RDATDLY, 0BIT)          |
        MCBSP_FMKS(RCR, RFRLEN1, OF(0))         |
        MCBSP_FMKS(RCR, RWDLEN1, 16BIT)         |
        MCBSP_FMKS(RCR, RWDREVRS, DISABLE),

        MCBSP_FMKS(XCR, XPHASE, SINGLE)         |
        MCBSP_FMKS(XCR, XFRLEN2, DEFAULT)       |
        MCBSP_FMKS(XCR, XWDLEN2, DEFAULT)       |
        MCBSP_FMKS(XCR, XCOMPAND, MSB)          |
        MCBSP_FMKS(XCR, XFIG, NO)               |
        MCBSP_FMKS(XCR, XDATDLY, 0BIT)          |
        MCBSP_FMKS(XCR, XFRLEN1, OF(0))         |
        MCBSP_FMKS(XCR, XWDLEN1, 16BIT)         |
        MCBSP_FMKS(XCR, XWDREVRS, DISABLE),
        
        MCBSP_SRGR_DEFAULT,
        MCBSP_MCR_DEFAULT,
        MCBSP_RCERE0_DEFAULT,
        MCBSP_RCERE1_DEFAULT,
        MCBSP_RCERE2_DEFAULT,
        MCBSP_RCERE3_DEFAULT,
        MCBSP_XCERE0_DEFAULT,
        MCBSP_XCERE1_DEFAULT,
        MCBSP_XCERE2_DEFAULT,
        MCBSP_XCERE3_DEFAULT,
        
        MCBSP_FMKS(PCR, XIOEN, DEFAULT)         |
        MCBSP_FMKS(PCR, RIOEN, DEFAULT)         |
        MCBSP_FMKS(PCR, FSXM, INTERNAL)         |
        MCBSP_FMKS(PCR, FSRM, DEFAULT)          |
        MCBSP_FMKS(PCR, CLKXM, OUTPUT)          |
        MCBSP_FMKS(PCR, CLKRM, INPUT)           |
        MCBSP_FMKS(PCR, CLKSSTAT, DEFAULT)      |
        MCBSP_FMKS(PCR, DXSTAT, DEFAULT)        |
        MCBSP_FMKS(PCR, FSXP, DEFAULT)          |
        MCBSP_FMKS(PCR, FSRP, DEFAULT)          |
        MCBSP_FMKS(PCR, CLKXP, DEFAULT)         |
        MCBSP_FMKS(PCR, CLKRP, DEFAULT)           
    };
            
    /* Initialize source data, zero dest */
    for (i = 0; i < N; i++) {
        src[i] = (i << 8) | i + 1;
        dst[i] = 0;
    }

    /* Open the McBSP */
    hMcbsp = MCBSP_open(devid, MCBSP_OPEN_RESET);
    
    /* Configure the McBSP for loopback mode */
    MCBSP_config(hMcbsp, &mcbspCfg_loopback);

    /* Start the McBSP */
    MCBSP_start(hMcbsp, MCBSP_RCV_START | MCBSP_XMIT_START |
        MCBSP_SRGR_START | MCBSP_SRGR_FRAMESYNC, MCBSP_SRGR_DEFAULT_DELAY);
        
    /* Data transfer loop */
    for (i = 0; i < (N + delayed); i++) {
        /* Wait for XRDY signal before writing data to DXR */
        while (!MCBSP_xrdy(hMcbsp));       
                 
        /* Write 16 bit data value to DXR */
        MCBSP_write(hMcbsp,src[i]);       
 
        /* Wait for RRDY signal to read data from DRR */
        while (!MCBSP_rrdy(hMcbsp));

        /* Read 16 bit value from DRR */
        receivedata = MCBSP_read(hMcbsp);
        if (i >= delayed)
            dst[i - delayed] = receivedata;               
    }

    /* Close the McBSP */
    MCBSP_close(hMcbsp);

    /* Check data to make sure transfer was successful */
    for (i = 0; i < N; i++)
        if (dst[i] != src[i])
            return 1;
    
    /* Test passed */
    return 0;
}

Int16 TEST_mcbsp0()
{
    /* Do an internal loopback test on McBSP0 */
    return TEST_mcbsp(MCBSP_DEV0, 0);
}

Int16 TEST_mcbsp1()
{
    /* Do an internal loopback test on McBSP1 */
    return TEST_mcbsp(MCBSP_DEV1, 0);
}

Int16 TEST_dma()
{
    Int16 i;
    EDMA_Handle hEdmaCha8;
    EDMA_Config edmaCfg8 = {
        EDMA_FMKS(OPT, PRI, URGENT)           |
        EDMA_FMKS(OPT, ESIZE, 16BIT)          |
        EDMA_FMKS(OPT, 2DS, NO)               |
        EDMA_FMKS(OPT, SUM, INC)              |
        EDMA_FMKS(OPT, 2DD, NO)               |
        EDMA_FMKS(OPT, DUM, INC)              |
        EDMA_FMKS(OPT, TCINT, YES)            |
        EDMA_FMK (OPT, TCC, 8)                |
        EDMA_FMKS(OPT, TCCM, DEFAULT)         |
        EDMA_FMKS(OPT, ATCINT, NO)            |
        EDMA_FMKS(OPT, ATCC, DEFAULT)         |
        EDMA_FMKS(OPT, PDTS, DEFAULT)         |
        EDMA_FMKS(OPT, PDTD, DEFAULT)         |
        EDMA_FMKS(OPT, LINK, NO)              |
        EDMA_FMKS(OPT, FS, YES),

        (Uint32)src,
        
        EDMA_FMKS(CNT, FRMCNT, OF(0))         |
        EDMA_FMKS(CNT, ELECNT, OF(16)),
        
        (Uint32)dst,
        
        EDMA_FMKS(IDX, FRMIDX, DEFAULT)       |
        EDMA_FMKS(IDX, ELEIDX, DEFAULT),
        
        EDMA_FMKS(RLD, ELERLD, DEFAULT)       |
        EDMA_FMKS(RLD, LINK, DEFAULT)
    };
    
    /* Set src values and clear destination */
    for (i = 0; i < N; i++) {
        src[i] = i;                   
        dst[i] = 0;
    }

    /* Configure EDMA */
    hEdmaCha8 = EDMA_open(8, EDMA_OPEN_RESET);
    EDMA_config(hEdmaCha8, &edmaCfg8);

    /* Start CPU initiated EDMA transfer by setting bit 24 in ESR */
    EDMA_setChannel(hEdmaCha8);
      
    /* Poll DMA interrupt too see if its done */
    while (!EDMA_intTest(8));
    {
    	;
    }

    /* We are done, so close DMA channel */
    EDMA_close(hEdmaCha8);
    
    /* Check data */
    for (i = 0; i < N; i++)
        if (dst[i] != src[i])
            return 1;

    /* Test passed */
    return 0; 
}

Int16 TEST_timer()
{
    /* Wait for 100 timer interrupts */
    TEST_sleep(100);
    
    return 0;
}

Int16 TEST_syncbus()
{
    return MEM_walking(EVMDM642_SYNC_BASE);
}

Int16 TEST_led()
{
    Uint32 i, j;
    
    EVMDM642_LED_init();
    for (i = 0; i < 64; i++)
    {
        LED_binary(0xaa);
        for (j = 0; j < 1000000; j++);
        LED_binary(0x55);  
        for (j = 0; j < 1000000; j++);
    }
    LED_binary(0xff);
    
    return 0;
}

Int16 TEST_spdif()
{
    Uint32 i, j, data, *pdata;
    
    /* Open and configure the McASP */
    EVMDM642_AIC23_hMcASP = MCASP_open(MCASP_DEV0, MCASP_OPEN_RESET);
    MCASP_config(EVMDM642_AIC23_hMcASP, &mcaspCfgDataSpdif);

    /* Configure DIT status and user registers */
    pdata = (Uint32 *)0x1b4c0;
    for (i = 0; i < 24; i++)
        *pdata++ = 0xffffffff;

    /* Enable transmit clocks and serializers */
    MCASP_RSETH(EVMDM642_AIC23_hMcASP, GBLCTL, 0x00000200);
    while (MCASP_RGETH(EVMDM642_AIC23_hMcASP, GBLCTL) != 0x00000200);

    /* Enable transmit clocks and serializers */
    MCASP_RSETH(EVMDM642_AIC23_hMcASP, GBLCTL, 0x00000300);
    while (MCASP_RGETH(EVMDM642_AIC23_hMcASP, GBLCTL) != 0x00000300);
    for (i = 0; i < 1000; i++);

    /* Enable transmit and receive clocks and serializers */
    MCASP_RSETH(EVMDM642_AIC23_hMcASP, GBLCTL, 0x00000700);
    while (MCASP_RGETH(EVMDM642_AIC23_hMcASP, GBLCTL) != 0x00000700);
    
    /* Put some data in the transmit buffer */
    MCASP_RSETH(EVMDM642_AIC23_hMcASP, XBUF2, 0);
    
    /* Release transmit and receive state machines */
    MCASP_RSETH(EVMDM642_AIC23_hMcASP, GBLCTL, 0x00000f00);
    while (MCASP_RGETH(EVMDM642_AIC23_hMcASP, GBLCTL) != 0x00000f00);
        
    /* Release transmit and receive state machines */
    MCASP_RSETH(EVMDM642_AIC23_hMcASP, GBLCTL, 0x00001f00);
    
    /* Generate 1KHz sine wave for 5 seconds*/
    for (i = 0; i < 5000; i++)
    {
        for (j = 0; j < SINE_TABLE_SIZE; j++)
        {
            data = sinetable[j];
            
            /* Wait until serializer ready to transmit */
            while ((MCASP_RGETH(EVMDM642_AIC23_hMcASP, SRCTL2) & 0x10) == 0);
 
            /* Transmit data */
            MCASP_RSETH(EVMDM642_AIC23_hMcASP, XBUF2, data);

            /* Wait until serializer ready to transmit */
            while ((MCASP_RGETH(EVMDM642_AIC23_hMcASP, SRCTL2) & 0x10) == 0);
 
            /* Transmit data */
            MCASP_RSETH(EVMDM642_AIC23_hMcASP, XBUF2, data);
        }
    }
    
    MCASP_close(EVMDM642_AIC23_hMcASP);

    return 0;
}

Int16 TEST_audioclks()
{
    Uint32 testtime;
    Int16 status;
    TIMER_Handle hTimer1;
    TIMER_Config timerCfg1 = {
        TIMER_FMKS(CTL, INVINP, NO)             |
        TIMER_FMKS(CTL, CLKSRC, CPUOVR8)        |
        TIMER_FMKS(CTL, CP, PULSE)              |
        TIMER_FMKS(CTL, HLD, YES)               |
        TIMER_FMKS(CTL, GO, NO)                 |
        TIMER_FMKS(CTL, PWID, ONE)              |
        TIMER_FMKS(CTL, DATOUT, 0)              |
        TIMER_FMKS(CTL, INVOUT, NO)             |
        TIMER_FMKS(CTL, FUNC, TOUT),
        
        TIMER_FMKS(PRD, PRD, OF(75)),
        TIMER_FMKS(CNT, CNT, OF(0))
    };
    
    status = 0;

    /* Enable GPIO on VDAC pin */
    GPIO_pinEnable(EVMDM642_GPIO_hGPIO, GPIO_PIN8);

    /* Configure as output */
    GPIO_pinDirection(EVMDM642_GPIO_hGPIO, GPIO_PIN8, GPIO_OUTPUT);

    /* Open the timer */
    hTimer1 = TIMER_open(TIMER_DEV1, TIMER_OPEN_RESET);
    
    /* Configure the timer in one-shot mode */
    TIMER_config(hTimer1, &timerCfg1);

    /* Get Event Id associated with Timer 1, for use with */
    /* CSL interrupt enable functions.                    */         
    eventId1 = TIMER_getEventId(hTimer1);

    /* Map the logical event to a physical interrupt */
    IRQ_map(eventId1, 15);

    /* Clear any pending Timer interrupts */
    IRQ_clear(eventId1);
 
    /* Enable timer interrupt */
    IRQ_enable(eventId1);
    
  	/* Make sure global interrupts are enabled */
  	IRQ_globalEnable();   

    /* Start timer 1 */
    TIMER_start(hTimer1);

    /* Set audio PLL to 18.432 MHz, VDAC low */
    EVMDM642_APLL_rset(EVMDM642_APLL_FSG0);
    GPIO_pinWrite(EVMDM642_GPIO_hGPIO, GPIO_PIN8, 0);
    sleepCount = 0;
    
    /* Check test duration against timer */
    TEST_spdif();
    
    testtime = sleepCount;
    printf("       Timer1 count -> %d\n", testtime);
    
    if (testtime > 4999900)
    {
        status = 1;
        goto SPDIF_END;
    }

    /* Drive VDAC high */
    GPIO_pinWrite(EVMDM642_GPIO_hGPIO, GPIO_PIN8, 1);
    sleepCount = 0;

    /* Check test duration against timer */
    TEST_spdif();
    
    testtime = sleepCount;
    printf("       Timer2 count -> %d\n", testtime);
    
    if (testtime < 5000280)
    {
        status = 2;
        goto SPDIF_END;
    }

    /* Set audio PLL to 16.9344 MHz */
    EVMDM642_APLL_rset(EVMDM642_APLL_FSG1);
    GPIO_pinWrite(EVMDM642_GPIO_hGPIO, GPIO_PIN8, 0);
    sleepCount = 0;
    
    /* Check test duration against timer */
    TEST_spdif();
    
    testtime = sleepCount;
    printf("       Timer3 count -> %d\n", testtime);
    
    if (testtime > 5442070)
    {
        status = 3;
        goto SPDIF_END;
    }

    /* Drive VDAC high */
    GPIO_pinWrite(EVMDM642_GPIO_hGPIO, GPIO_PIN8, 1);
    sleepCount = 0;
    
    /* Check test duration against timer */
    TEST_spdif();

    testtime = sleepCount;
    printf("       Timer4 count -> %d\n", testtime);    
    
    if (testtime < 5442470)
    {
        status = 4;
        goto SPDIF_END;
    }
        
SPDIF_END:
    TIMER_close(hTimer1);
    
    return status;
}

Int16 TEST_flashAddr()
{
    Int16 i;
    
    for (i = 0; i < 8; i++)
    {
        EVMDM642_rset(EVMDM642_FLASHPAGE, i);
    }
    
    return 0;
}

Int16 TEST_eeprom()
{
    Uint16 page, i;
    Uint8 *pdata;
    
    /* Write a pattern */
    for (page = 0; page < 4; page++)
    {
        pdata = (Uint8 *)buffer;
        for (i = 0; i < 64; i++)
            *pdata++ = (page + i) & 0xff;
        EVMDM642_EEPROM_write((Uint32)buffer, page << 6, 64);
    }
    
    /* Verify the pattern */
    for (page = 0; page < 4; page++)
    {
        EVMDM642_EEPROM_read(page << 6, (Uint32)buffer, 64);
        pdata = (Uint8 *)buffer;
        for (i = 0; i < 64; i++)
            if (*pdata++ != (page + i) & 0xff)
                return 1;  // Fail
    }
    
    return 0;
}

Int16 TEST_null()
{
    return 0;
}

/* ------------------ Start Debug Code -------------------------------*/

void DEBUG_memLoop()
{
    volatile Uint8 *pdata, data;
    
    pdata = (Uint8 *)0x90080000;
    while(1)
    {
        data = *pdata;
    }
}

/* ------------------  End Debug Code --------------------------------*/

void TEST_execute(Int16 (*funchandle)(), char *testname, Int16 ledmask, Int16 insertdelay)
{
    Int16 status;
    
    /* Display test ID */
    printf("%02d  Testing %s...\n", ledmask, testname);
    
    /* Call test function */
    status = funchandle();
    
    /* Check for test fail */
    if (status > 0)
    {
        /* Print error message */
        printf("     FAIL... error code %d... quitting\n", status, testname);
        
        /* Software breakpoint */
        asm(" .long 0x10000000");
    } else
    {
        /* Print error message */
        printf("    PASS\n", testname);
    }
}

main()
{
    /* Call BSL init */
    EVMDM642_init();
    
    /* Set initial LED state */
    EVMDM642_LED_init();
    
    /* Run the tests sequentially */
    TEST_execute(TEST_led,       "LEDs",            1, 0);
    TEST_execute(TEST_audioclks, "SPDIF/APLL/VCXO", 2, 0);
    TEST_execute(TEST_syncbus,   "Sync Bus",        3, 0);
    TEST_execute(TEST_extMem,    "SDRAM",           4, 0);
    TEST_execute(TEST_flashID,   "Flash ID",        5, 1);
    TEST_execute(TEST_eeprom,    "I2C EEPROM",      6, 0);

    /* Success */
    printf("\n*** All tests PASS ***\n");
    
    /* Disable interrupts */
    IRQ_globalDisable();

    /* Software breakpoint */
    asm(" .long 0x10000000");
}