test.c

it is programed on dsk6455

/*H***************************************************************************
*
* $Archive:: /boards/dsk6455_v2/examples/test/test.c                          $
* $Revision:: 2                                                               $
* $Date:: 10/26/07 3:48p                                                      $
* $Author:: Shilpab                                                           $
*
* DESCRIPTION:
*
*   
* (C) Copyright 2005 by Spectrum Digital Incorporated
* All rights reserved
*
*H***************************************************************************/

/*------------------------------------------------------------------------*
 *  This is a test program that uses DSK6455A Board Support Library to
 *  perform a confidence test on a DSK6455A.  While it is running, it
 *  will display the current test index in binary on the LEDs.  If it
 *  fails a test, the test index will blink indefinitely to alert you to
 *  the failure.  If all tests pass, all of the LEDs will blink 3 times
 *  then stay on.
 *
 *  The following tests are performed:
 *
 *  Index    Description
 *    1      Internal memory Version
 *    2      External memory(SDRAM)
 *    3      Flash
 *    4      Codec
 *    5      UserIO
 *    6      MemPattern(Fill pattern)
 *    7      MemPattern(Address Pattern)
 *    8      DSP
 *    9      LED/Swt
 *    10     Codec LoopBack
 *
 *  Please see the DSK6455A BSL Examples for more detailed information.

 *  DSP/BIOS is configured using the DSP/BIOS configuration tool.  Settings
 *  for this example are stored in a configuration file called test.cdb.  At
 *  compile time, Code Composer will auto-generate DSP/BIOS related files
 *  based on these settings.  A header file called testcfg.h contains the
 *  results of the autogeneration and must be included for proper operation.
 *  The name of the file is taken from test.cdb and adding cfg.h.
 *------------------------------------------------------------------------*/

#define test_c


/*****************************************************************************
* INCLUDE FILES
*****************************************************************************/
/*---- system and platform files -------------------------------------------*/

#include "testcfg.h"
/*
 *  The 6455 DSK Board Support Library is divided into several modules, each
 *  of which has its own include file.  The file dsk6455.h must be included
 *  in every program that uses the BSL.  This example also includes
 *  dsk6455_aic23.h, dsk6455_led.h and dsk6455_flash.h because it uses
 *  their respective BSL modules.
 */
#include "dsk6455.h"
#include "dsk6455_led.h"
#include "dsk6455_aic23.h"
#include "dsk6455_flash.h"
#include "dsk6455_eeprom.h"


/* Length of sine wave table */
#define SINE_TABLE_SIZE  48

Uint16 buffer[256];

/* Pre-generated sine wave data, 16-bit signed samples */
int sinetable[SINE_TABLE_SIZE] = {
    0x0000, 0x10b4, 0x2120, 0x30fb, 0x3fff, 0x4dea, 0x5a81, 0x658b,
    0x6ed8, 0x763f, 0x7ba1, 0x7ee5, 0x7ffd, 0x7ee5, 0x7ba1, 0x76ef,
    0x6ed8, 0x658b, 0x5a81, 0x4dea, 0x3fff, 0x30fb, 0x2120, 0x10b4,
    0x0000, 0xef4c, 0xdee0, 0xcf06, 0xc002, 0xb216, 0xa57f, 0x9a75,
    0x9128, 0x89c1, 0x845f, 0x811b, 0x8002, 0x811b, 0x845f, 0x89c1,
    0x9128, 0x9a76, 0xa57f, 0xb216, 0xc002, 0xcf06, 0xdee0, 0xef4c
};

/* Codec configuration settings */
DSK6455_AIC23_Config config = { \
    0x0017,  /* 0 DSK6455_AIC23_LEFTINVOL  Left line input channel volume */ \
    0x0017,  /* 1 DSK6455_AIC23_RIGHTINVOL Right line input channel volume */\
    0x00d8,  /* 2 DSK6455_AIC23_LEFTHPVOL  Left channel headphone volume */  \
    0x00d8,  /* 3 DSK6455_AIC23_RIGHTHPVOL Right channel headphone volume */ \
    0x0011,  /* 4 DSK6455_AIC23_ANAPATH    Analog audio path control */      \
    0x0001,  /* 5 DSK6455_AIC23_DIGPATH    Digital audio path control */     \
    0x0000,  /* 6 DSK6455_AIC23_POWERDOWN  Power down control */             \
    0x0043,  /* 7 DSK6455_AIC23_DIGIF      Digital audio interface format */ \
    0x0081,  /* 8 DSK6455_AIC23_SAMPLERATE Sample rate control */            \
    0x0001   /* 9 DSK6455_AIC23_DIGACT     Digital interface activation */   \
};

/* Define buffers for host side communication */
#pragma DATA_SECTION(cmdbuf , "CMD_BUFFER")
Uint16  cmdbuf[512];
#pragma DATA_SECTION(databuf , "DATA_BUFFER")
Uint16  databuf[512];


/*--------------------------------ACCESSORY FUNCTIONS-------------------------------------*/
/*F***************************************************************************
* NAME:  TEST_sleep(Int16 sleeptime) 
*
* DESCRIPTION: Accessory Function
*
* NOTES:
*   
*F***************************************************************************/
void TEST_sleep(Int16 sleeptime)
{
	DSK6455_waitusec( sleeptime * 1000 );
}
/*----------------------------END ACCESSORY FUNCTIONS-------------------------------------*/
/*-----------------------------LED FUNCTIONS-----------------------------------------------*/
/*F***************************************************************************
* NAME:  LED_binary(Int16 ledmask) 
*
* DESCRIPTION:
*
* NOTES:
*   
*F***************************************************************************/
void LED_binary(Int16 ledmask)
{
    Int16 i, bit;

    /* Walk through the bits in num setting corresponding LEDs */
    bit = 1;
    for (i = 0; i < 4; i++)
    {
        if (ledmask & bit)
            DSK6455_LED_on(i);
        else
            DSK6455_LED_off(i);
        bit = bit << 1;
    }

}

/*F***************************************************************************
* NAME:  LED_blink(Int16 ledmask, Int16 count)  
*
* DESCRIPTION:
*
* NOTES:
*   
*F***************************************************************************/
void LED_blink(Int16 ledmask, Int16 count)
{
    while (count > 0)
    {
        LED_binary(ledmask);
        TEST_sleep(100);
        LED_binary(0);
        TEST_sleep(150);
        count--;
    }
}

/*F***************************************************************************
* NAME:  void LED_error(Int16 ledmask)  
*
* DESCRIPTION:
*
* NOTES:
*   
*F***************************************************************************/
void LED_error(Int16 ledmask)
{
    while(1)
        LED_blink(ledmask, 1);
}
/*-----------------------------END OF LED FUNCTIONS-----------------------------------------------*/
/*-----------------------------MEMORY FUNCTIONS---------------------------------------------------*/
/*F***************************************************************************
* NAME:  MEM_fill(Uint32 start, Uint32 len, Uint32 val) 
*
* DESCRIPTION:
*
* NOTES:
*   
*F***************************************************************************/
Int16 MEM_fill(Uint32 start, Uint32 len, Uint32 val)
{
    Uint32 i, end;

    /* Calculate end of range */
    end = start + len;

    /* Fill a range with a value */
    for (i = start; i < end; i+=sizeof(Uint32))
    {
        *((Uint32 *)i) = val;
    }

    /* Verify the data */
    for (i = start; i < end; i+=sizeof(Uint32))
    {
        if (*((Uint32 *)i) != val)
            return 1;
    }

    return 0;
}
/*F***************************************************************************
* NAME:  MEM_addr(Uint32 start, Uint32 len)  
*
* DESCRIPTION:
*
* NOTES:
*   
*F***************************************************************************/
Int16 MEM_addr(Uint32 start, Uint32 len)
{
    Uint32 i, end;

    /* Calculate end of range */
    end = start + len;

    /* Fill the range with its address */
    for (i = start; i < end; i+=sizeof(Uint32))
    {
        *((Uint32 *)i) = i;
    }

    /* Verify the data */
    for (i = start; i < end; i+=sizeof(Uint32))
        if (*((Uint32 *)i) != i)
            return 1;

    return 0;
}
/*F***************************************************************************
* NAME: MEM_addrInv(Uint32 start, Uint32 len)  
*
* DESCRIPTION:
*
* NOTES:
*   
*F***************************************************************************/
Int16 MEM_addrInv(Uint32 start, Uint32 len)
{
    Uint32 i, end;

    /* Calculate end of range */
    end = start + len;

    /* Fill the range with its address */
    for (i = start; i < end; i+=sizeof(Uint32))
    {
        *((Uint32 *)i) = ~i;
    }

    /* Verify the data */
    for (i = start; i < end; i+=sizeof(Uint32))
        if (*((Uint32 *)i) != (~i))
            return 1;

    return 0;
}

/*F***************************************************************************
* NAME:  MEM_test(Uint32 start, Uint32 len, Int16 patterntype)  
*
* DESCRIPTION:
*
* NOTES:
*   
*F***************************************************************************/
Int16 MEM_test(Uint32 start, Uint32 len, Int16 patterntype)
{
    Int16 status = 0;

    if (!patterntype)
    {
        /* Run the fill tests */
        status |= MEM_fill(start, len, 0x00000000);
        status |= MEM_fill(start, len, 0x55555555);
        status |= MEM_fill(start, len, 0xAAAAAAAA);
        status |= MEM_fill(start, len, 0xFFFFFFFF);
    } else
    {
        /* Run the address tests */
        status |= MEM_addr(start, len);
        status |= MEM_addrInv(start, len);
    }

    return status;
}
/*F***************************************************************************
* NAME:  MEM_walking(Uint32 add)
*
* DESCRIPTION:
*
* NOTES:
*   
*F***************************************************************************/
Int16 MEM_walking(Uint32 add)
{
    Int16 i;
    Uint32 mask, *pdata;

    pdata = (Uint32 *)add;

    /* Walking ones and zeros */
    mask = 1;
    for (i = 0; i < 32; i++)
    {
        /* Test one in bit position i */
        *pdata = mask;
        if (*pdata != mask)
            return 1;

        /* Test zero in bit position i */
        *pdata = ~mask;
        if (*pdata != (~mask))
            return 1;

        mask = mask << 1;
    }

    return 0;
}
/*F***************************************************************************
* NAME:  MEM_walking(Uint32 add)
*
* DESCRIPTION:
*
* NOTES:
*   
*F***************************************************************************/
Int16 MEM_bytestrobe(Uint32 add)
{
    Uint32 *pdata;
    Uint8 *pcheck;

    /* Write pattern */
    pdata = (Uint32 *)add;
    *pdata = 0x12345678;

    /* Do dummy write */
    pdata = (Uint32 *)DSK6455_FLASH_BASE;
    *pdata = 0x80808080;

    /* Check pattern */
    pcheck = (Uint8 *)add;
    if (*pcheck++ != 0x78)
        return 0x10;
    if (*pcheck++ != 0x56)
        return 0x20;
    if (*pcheck++ != 0x34)
        return 0x40;
    if (*pcheck++ != 0x12)
        return 0x80;

    return 0;
}

/*---------------------------END OF MEMORY FUNCTIONS------------------------------------------*/

/*---------------------------FLASH FUNCTIONS--------------------------------------------------*/
/*F***************************************************************************
* NAME:  TEST_flashID()
*
* DESCRIPTION:
*
* NOTES:
*   
*F***************************************************************************/
Int16 TEST_flashID()
{
    Uint8 MfgId,DevId;
    Int16 i;

    /* Reset flash */
    *((Uint8 *)DSK6455_FLASH_BASE) = 0xf0;

    /* Configure to read manufacturer ID */
    *((Uint8 *)DSK6455_FLASH_BASE) = 0xaa;
    *((Uint8 *)DSK6455_FLASH_BASE) = 0x55;
    *((Uint8 *)DSK6455_FLASH_BASE) = 0x90;

    /* Insert small delay for device to respond */
    for (i = 0; i < 10; i++);

    /* Read IDs */
    MfgId = *((Uint8 *)DSK6455_FLASH_BASE);
    DevId = *((Uint8 *)DSK6455_FLASH_BASE + 1);

    /* Reset flash */
    *((Uint8 *)DSK6455_FLASH_BASE) = 0xf0;

    /* Check IDs */
    if ((MfgId != 0x0001) || (DevId != 0xa3))
        return 1;

    /* Test passed */
    return 0;
}
/*---------------------------END OF FLASH FUNCTIONS-------------------------------------------*/
/*---------------------------DMA FUNCTIONS----------------------------------------------------*/
/*F***************************************************************************
* NAME:  TEST_dma()
*
* DESCRIPTION:
*
* NOTES:
*   
*F***************************************************************************/
Int16 TEST_dma()
{
    /* Test passed */
    return 0;
}
/*---------------------------END DMA FUNCTIONS------------------------------------------------*/

/*---------------------------TIMER FUNCTIONS--------------------------------------------------*/
/*F***************************************************************************
* NAME:  TEST_timer()
*
* DESCRIPTION:
*
* NOTES:
*   
*F***************************************************************************/
Int16 TEST_timer()
{
    /* Wait for 100 timer interrupts */
    TEST_sleep(100);
    
    return 0;
}
/*---------------------------END TIMER FUNCTIONS----------------------------------------------*/
/*---------------------------McBSP FUNCTIONS--------------------------------------------------*/
/*F***************************************************************************
* NAME:  TEST_mcbsp(Int16 devid, Int16 delayed)
*
* DESCRIPTION:
*
* NOTES:
*   
*F***************************************************************************/
Int16 TEST_mcbsp(Int16 devid, Int16 delayed)
{

    /* Test passed */
    return 0;
}
/*F***************************************************************************
* NAME:  TEST_mcbsp0()
*
* DESCRIPTION:
*
* NOTES:
*   
*F***************************************************************************/
Int16 TEST_mcbsp0()
{
    /* Do an internal loopback test on McBSP0 */
    return 0;
}
/*F***************************************************************************
* NAME:  TEST_mcbsp1()
*
* DESCRIPTION:
*