dspc270.c

dm270 source code

/*
    DM270 ARM Evaluation Software

    (c)Texas Instruments 2003
*/

/**
    \file dspc270.c
    \brief DSP Control Related APIs
*/
#include <dspc270.h>

#define DSP_PAGE_1_PROGRAM_AREA_ADDR 0xC000

static STATUS DSPC_hpiAddrValidate(Uint32 dspAddr, Uint8 read);

/**
    \brief  Reset DSP

    \return if success, \c E_PASS, else error code
*/
STATUS DSPC_reset() {
    DSPC_FSET( HPIBCTL, DRST, 0);
    DSPC_FSET( HPIBCTL, DRST, 1);
    return E_PASS;
}

/**
    \brief Strobe INT0 signal, i.e send INT0 interrupt to DSP

    \return if success, \c E_PASS, else error code
*/
STATUS DSPC_strobeINT0() {
    DSPC_FSET( HPIBCTL, DINT0, 0);
    DSPC_FSET( HPIBCTL, DINT0, 1);
    return E_PASS;
}

/**
    \brief Strobe NMI signal, i.e send NMI interrupt to DSP

    \return if success, \c E_PASS, else error code
*/
STATUS DSPC_strobeNMI() {
    DSPC_FSET( HPIBCTL, HPNMI, 0);
    DSPC_FSET( HPIBCTL, HPNMI, 1);
    return E_PASS;
}

/**
    \brief Assert hold signal to DSP

    \return if success, \c E_PASS, else error code
*/
STATUS DSPC_assertHOLD() {
    DSPC_FSET( HPIBCTL, DHOLD, 0);
    return E_PASS;
}

/**
    \brief Release the hold signal that was asserted to DSP

    \return if success, \c E_PASS, else error code
*/
STATUS DSPC_releaseHOLD() {
    DSPC_FSET( HPIBCTL, DHOLD, 1);
    return E_PASS;
}

/**
    \brief Check if HOLD acknowledge signal received from DSP

    \return TRUE: HOLD ACK received, FALSE: HOLD ACK not received
*/
BOOL   DSPC_checkHOLDACK() {
    return DSPC_FGET( HPIBSTAT, HOLDA ) == 0 ? TRUE : FALSE;
}

/**
    \brief Enable/Disable byte swapping when transferring data over HPI interface

    \param enable   Byte swap, TRUE: enable, FALSE: disable

    \return if success, \c E_PASS, else error code
*/
STATUS DSPC_byteSwap(BOOL enable) {
    DSPC_FSET( HPIBCTL, EXCHG, enable == TRUE ? 1 : 0 );
    return E_PASS;
}

/**
    \brief Enable/Disable HPI interface

    \param enable   HPI interface, TRUE: enable, FALSE: disable

    \return if success, \c E_PASS, else error code
*/
STATUS DSPC_hpiEnable(BOOL enable) {
    DSPC_FSET( HPIBCTL, EXCHG, enable == FALSE ? 0 : 1 );
    return E_PASS;
}

/**
    \brief Get HPI interface status register HPIBSTAT (0x30602)

    \return register HPIBSTAT (0x30602)
*/
Uint16 DSPC_hpiStatus() {
    return DSPC_RGET( HPIBSTAT );
}

/**
    \brief Write data from ARM address space to DSP address space

    Memory map in DSP address space is as follows:
    \code
         Address        Access      Description
    Start       End
    0x0         0x7F    R           DSP specific memory area, read only (128W)
    0x80        0x7FFF  R/W         DSP on-chip RAM, mapped on both program and data space  (~32KW)
    0x8000      0xBFFF  R/W         DSP on-chip RAM, mapped on data space only  (16KW)
    0xC000      0x1BFFF -           Not accessible via HPI interface
    0x1C000     0x1FFFF R/W         DSP on-chip RAM, mapped on program space only (16KW)
    \endcode

    \param address      Absolute address in ARM address space, must be 16-bit aligned
    \param size         Size of data to be written, in units of 16-bit words
    \param dspAddr      Absolute address in DSP address space, 0x0 .. 0xFFFF. \n When dspAddr = 0xC000...0xFFFF, data is loaded to DSP area 0x1C000...0x1FFFF

    \return if success, \c E_PASS, else error code
*/
STATUS DSPC_writeData(char *address, Uint32 size, Uint32 dspAddr) {

    if(size==0)
        return E_PASS;

    if((Uint32)address & 0x1 )
        return E_INVALID_INPUT;

    if( DSPC_hpiAddrValidate(dspAddr, 0) != E_PASS )
        return E_INVALID_INPUT;

    {
        Uint16 *hpiAddr;
        Uint16 *armAddr;

        hpiAddr=(Uint16*)HPI_DSP_START_ADDR;
        armAddr=(Uint16*)address;

        if(dspAddr >= DSP_PAGE_1_PROGRAM_AREA_ADDR ) {
            hpiAddr += (0x18000/2) + (dspAddr - DSP_PAGE_1_PROGRAM_AREA_ADDR );
        } else {
            hpiAddr += dspAddr;
        }

        while(size--)
            *hpiAddr++ = *armAddr++;
    }
    return E_PASS;
}

/**
    \brief Read data from DSP address space to ARM address space

    Memory map in DSP address space is as follows:
    \code
         Address        Access      Description
    Start       End
    0x0         0x7F    R           DSP specific memory area, read only (128W)
    0x80        0x7FFF  R/W         DSP on-chip RAM, mapped on both program and data space  (~32KW)
    0x8000      0xBFFF  R/W         DSP on-chip RAM, mapped on data space only  (16KW)
    0xC000      0x1BFFF -           Not accessible via HPI interface
    0x1C000     0x1FFFF R/W         DSP on-chip RAM, mapped on program space only (16KW)
    \endcode

    \param address      Absolute address in ARM address space, must be 16-bit aligned
    \param size         Size of data to be read, in units of 16-bit words
    \param dspAddr      Absolute address in DSP address space, 0x0 .. 0xFFFF. \n When dspAddr = 0xC000...0xFFFF, data is loaded to DSP area 0x1C000...0x1FFFF

    \return if success, \c E_PASS, else error code
*/
STATUS DSPC_readData(char *address, Uint32 size, Uint32 dspAddr) {

    if(size==0)
        return E_PASS;

    if((Uint32)address & 0x1 )
        return E_INVALID_INPUT;

    if( DSPC_hpiAddrValidate(dspAddr, 1) != E_PASS )
        return E_INVALID_INPUT;

    {
        Uint16 *hpiAddr;
        Uint16 *armAddr;

        hpiAddr=(Uint16*)HPI_DSP_START_ADDR;
        armAddr=(Uint16*)address;

        if(dspAddr >= DSP_PAGE_1_PROGRAM_AREA_ADDR ) {
            hpiAddr += (0x18000/2) + (dspAddr - DSP_PAGE_1_PROGRAM_AREA_ADDR );
        } else {
            hpiAddr += dspAddr;
        }

        while(size--)
            *armAddr++ = *hpiAddr++;
    }
    return E_PASS;
}

/**
    \brief  Similar to DSPC_writeData(), except that after writting it verifies the contents written to the DSP memory

    Memory map in DSP address space is as follows:
    \code
         Address        Access      Description
    Start       End
    0x0         0x7F    R           DSP specific memory area, read only (128W)
    0x80        0x7FFF  R/W         DSP on-chip RAM, mapped on both program and data space  (~32KW)
    0x8000      0xBFFF  R/W         DSP on-chip RAM, mapped on data space only  (16KW)
    0xC000      0x1BFFF -           Not accessible via HPI interface
    0x1C000     0x1FFFF R/W         DSP on-chip RAM, mapped on program space only (16KW)
    \endcode

    \param address      Absolute address in ARM address space, must be 16-bit aligned
    \param size         Size of data to be written, in units of 16-bit words
    \param dspAddr      Absolute address in DSP address space, 0x0 .. 0xFFFF. \n When dspAddr = 0xC000...0xFFFF, data is loaded to DSP area 0x1C000...0x1FFFF
    \param retryCount   Number of times to retry in case of failure in writting data to DSP memory

    \return if success, \c E_PASS, else error code
*/
STATUS DSPC_writeDataVerify(char *address, Uint32 size, Uint32 dspAddr, Uint16 retryCount) {

    if(size==0)
        return E_PASS;

    if((Uint32)address & 0x1 )
        return E_INVALID_INPUT;

    if( DSPC_hpiAddrValidate(dspAddr, 0) != E_PASS )
        return E_INVALID_INPUT;

    {
        volatile Uint16 *hpiAddr;
        volatile Uint16 *armAddr;

        hpiAddr=(Uint16*)HPI_DSP_START_ADDR;
        armAddr=(Uint16*)address;

        if(dspAddr >= DSP_PAGE_1_PROGRAM_AREA_ADDR ) {
            hpiAddr += (0x18000/2) + (dspAddr - DSP_PAGE_1_PROGRAM_AREA_ADDR );
        } else {
            hpiAddr += dspAddr;
        }
        {
            Uint16 i;
            volatile BOOL error;

            while(size--) {
                error = TRUE;
                for(i=0;i<retryCount;i++) {
                    *hpiAddr = *armAddr;
                    if(*hpiAddr==*armAddr) {
                        error=FALSE;
                        break;
                    }
                }
                if(error==TRUE)
                    return E_DEVICE;
                hpiAddr++;
                armAddr++;
            }
        }
    }
    return E_PASS;
}


static STATUS DSPC_hpiAddrValidate(Uint32 dspAddr, Uint8 read) {

    if(dspAddr <= 0xBFFF )
        return E_PASS;

    if(dspAddr >= DSP_PAGE_1_PROGRAM_AREA_ADDR && dspAddr  <= (DSP_PAGE_1_PROGRAM_AREA_ADDR + 0x3FFF))
        return E_PASS;

    return E_INVALID_INPUT;
}