post.c

dsp6713开发板的许多例程.对入门特别有用

 */

Int16 TEST_intMem()
{
    Int16 status = 0;
    
    /* Check internal memory (byte 0x10000 to byte 0x40000) */
    status |= MEM_test(0x10000, 0x30000, 0);
    status |= MEM_test(0x10000, 0x30000, 1);
    status |= MEM_walking(0x10000);
      
    return status;
}

Int16 TEST_extMem()
{
    Int16 status = 0;
    
    /* Check external memory (8 Mb for ver. 1, 16 Mb for ver. 2) */
    if (DSK6713_getVersion() == 1)
    {
        status |= MEM_test(0x80000000, 0x0800000, 0);
        status |= MEM_test(0x80000000, 0x0800000, 1);
    } else
    {
        status |= MEM_test(0x80000000, 0x1000000, 0);
        status |= MEM_test(0x80000000, 0x1000000, 1);
    }
    status |= MEM_walking(0x80000000);
     
    return status;
}

Int16 TEST_flashID()
{
#if(0)  // Change to 1 to enable Flash ID test
    Uint16 MfgId,DevId;
    Int16 i;
    
    /* Reset flash */
    *((volatile Uint8 *)DSK6713_FLASH_BASE) = 0xf0;
 
    /* Configure to read manufacturer ID */
    *((volatile Uint8 *)DSK6713_FLASH_CTL555) = 0xaa;
    *((volatile Uint8 *)DSK6713_FLASH_CTL2AA) = 0x55;
    *((volatile Uint8 *)DSK6713_FLASH_CTL555) = 0x90; 

    /* Insert small delay for device to respond */
    for (i = 0; i < 100; i++);
    
    /* Read IDs */
    MfgId = *((Uint8 *)DSK6713_FLASH_BASE) & 0xff;
    DevId = *((Uint8 *)(DSK6713_FLASH_BASE + 1)) & 0xff;

    /* Reset flash */
    *((Uint16 *)DSK6713_FLASH_BASE) = 0xf0;

    /* Check IDs */
    if ((MfgId != 0x01) || (DevId != 0xb9))
        return 1;
#endif

    /* Test passed */
    return 0;
}

Int16 TEST_mcbsp(int devid, Int16 delayed)
{
    Int16 i;
    Uint16 receivedata;
    MCBSP_Handle hMcbsp;
    MCBSP_Config mcbspCfg_loopback = {
        MCBSP_FMKS(SPCR, FREE, NO)              |
        MCBSP_FMKS(SPCR, SOFT, NO)              |
        MCBSP_FMKS(SPCR, FRST, YES)             |
        MCBSP_FMKS(SPCR, GRST, YES)             |
        MCBSP_FMKS(SPCR, XINTM, XRDY)           |
        MCBSP_FMKS(SPCR, XSYNCERR, NO)          |
        MCBSP_FMKS(SPCR, XRST, YES)             |
        MCBSP_FMKS(SPCR, DLB, ON)               |
        MCBSP_FMKS(SPCR, RJUST, RZF)            |
        MCBSP_FMKS(SPCR, CLKSTP, DISABLE)       |
        MCBSP_FMKS(SPCR, DXENA, OFF)            |
        MCBSP_FMKS(SPCR, RINTM, RRDY)           |
        MCBSP_FMKS(SPCR, RSYNCERR, NO)          |
        MCBSP_FMKS(SPCR, RRST, YES),
        
        MCBSP_FMKS(RCR, RPHASE, SINGLE)         |
        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_RCER_DEFAULT,
        MCBSP_XCER_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, HIGH)             |
        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, 15)               |
        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_RSET(ESR, 0x00000100);
    
    /* Poll DMA interrupt too see if its done */
    while (!EDMA_intTest(15))
    {
    	;
    }

    /* 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_codec()
{
    DSK6713_AIC23_CodecHandle hCodec;
    Int16 i, j;

    /* Start the codec */
    hCodec = DSK6713_AIC23_openCodec(0, &config);
    
    /* Generate a 1KHz sine wave for 1 second */
    for (i = 0; i < 1000; i++)
    {
        for (j = 0; j < SINE_TABLE_SIZE; j++)
        {       
            while (!DSK6713_AIC23_write(hCodec, sinetable[j]));
            while (!DSK6713_AIC23_write(hCodec, sinetable[j]));
        }
    }
    
    /* Close codec */
    DSK6713_AIC23_closeCodec(hCodec);

    return 0;
}

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

Int16 TEST_null()
{
    return 0;
}

void TEST_execute(Int16 (*funchandle)(), Int16 ledmask, Int16 insertdelay)
{
    Int16 status;
    

    /* Display test ID */
    LED_binary(ledmask);
    
    /* Call test function */
    status = funchandle();

    /* Pause so LEDs can be read */
    if (insertdelay)
        TEST_sleep(100);
    
    /* Check for test fail */
    if (status)
        LED_error(ledmask);
}

main()
{
    /* Call BSL init */
    DSK6713_init();

    /* Set initial LED state */
    DSK6713_LED_init();

    /* Run the tests sequentially */
    TEST_execute(TEST_intMem,     1, 1);  /* Internal memory */
    TEST_execute(TEST_extMem,     2, 0);  /* External memory (typical) */
    TEST_execute(TEST_flashID,    3, 1);  /* External memory (flash) */
    TEST_execute(TEST_mcbsp0,     4, 1);  /* McBSP0 loopback */
    TEST_execute(TEST_mcbsp1,     5, 1);  /* McBSP1 loopback */
    TEST_execute(TEST_dma,        6, 1);  /* DMA test */
    TEST_execute(TEST_codec,      7, 0);  /* Codec test */
    TEST_execute(TEST_timer,      8, 0);  /* LED and timer test */

    /* All tests complete, board passes */
    LED_blink(0xf, 3);
    
    /* Leave all LEDs on */
    LED_binary(0xf);
    
    /* Disable interrupts */
    IRQ_globalDisable();
}