ARM-DSP Bridge

Following ioctl commands are defined.

Reads data from DSP internal memory space

Writes data to the DSP internal memory space

Seeks in the DSP's internal memory

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <fcntl.h>

#include "arm-dsp_bridge.h"

int main(int argc, char **argv) {
    int fd;
    unsigned short* buf;

    buf = (unsigned short *)malloc(sizeof(short));

    if ((fd = open(DSPMEMDEVNM, O_RDWR)) < 0) {
        perror("open memory device");
        return -1;
    }

    lseek(fd, 0x264, SEEK_SET);
    if (read(fd,buf,sizeof(short)) != sizeof(short)) {
        perror("read memory device");
        free(buf);
        return -1;
    }
    printf("value at word address 0x264: 0x%x\n", *buf);
    free(buf);

    return 0;
}

Check if read and/or write call will become blocking. A read call blocks if the circular read buffer is empty. A write call blocks if the circular write buffer is full.

Writes data to the circular write buffer. A program on the DSP must make a _hpib_read call to transfer this data from the circular write buffer to a buffer on the DSP. This call becomes blocking if the write buffer is full, and stays blocking until the DSP reads the previous data. Because the write() uses DMA transfers internally, transfer sizes have to be a multitude of 4 bytes (32 bit) as demanded by the HPIB DMA controller (the write call will fail otherwise).

NB: You will not be notified if the data reaches the DSP correctly. So you will need to implement this functionality yourself if needed.

Reads data from the circular read buffer. A program on the DSP must make a _hpib_write call to transfer data from a buffer on the DSP to this circular read buffer first. This call becomes blocking if the circular read buffer is empty, and stays blocking until the DSP places data in the buffer. Because the read() uses DMA transfers internally, transfer sizes have to be a multitude of 4 bytes (32 bit) as demanded by the HPIB DMA controller (the write call will fail otherwise).

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <fcntl.h>

#include "arm-dsp_bridge.h"

int main(int argc, char **argv) {
    int fd;
    int i = 0;
    unsigned short* writebuf;
    unsigned short* readbuf;

    char str1[]="Hello World from the DSP: through the DMA void!!";
    char str2[]="ffffffffffffffffffffffffffffffffffffffffffffffff";
    /** 
     * Number of chars is an even number so transfer size will be a
     * multitude of 4 bytes
     */
    writebuf = (unsigned short *)malloc(strlen(str1)*sizeof(short));
    readbuf = (unsigned short *)malloc(strlen(str2)*sizeof(short));
    
    if ((fd = open(DSPCOMDEVNM, O_RDWR)) < 0) {
        perror("open communications device");
        free(writebuf);
        free(readbuf);
        return -1;
    }

    for(i=0; i < strlen(str1); ++i){
        writebuf[i]=str1[i];
    }

    if (write(fd,writebuf,strlen(str1)*sizeof(short)) != strlen(str1)*sizeof(short)) {
        perror("write com device");
        free(writebuf);
        free(readbuf);
        return -1;
    }

    if (read(fd,readbuf,strlen(str2)*sizeof(short)) != strlen(str2)*sizeof(short)) {
        perror("write com device");
        free(writebuf);
        free(readbuf);
        return -1;
    }

    for(i=0; i < strlen(str2); ++i){
        str2[i] = readbuf[i];
    }

    printf("Read from DSP: %s\n",str2);

    free(writebuf);
    free(readbuf);

    close(fd);

    return 0;
}

Currently implements the counterparts of the read() and write() calls of the bridge communication device on the ARM (Linux) side. At the end of this section there's an example application using the _hpib_read and _hpib_write functions. These functions use the _hpiDma_transfer (for internal use only) to transfer the bytes between SDRAM and Internal DSP memory.

Currently implements only the _debug function.

;*-----------------------------------------------------------------------------*
;*  Main Program                                                               *
;*-----------------------------------------------------------------------------*
            .mmregs
;*--------------------------- YOUR CODE STARTS HERE ---------------------------*
            ; Any definitions or references you need to add go here
            .include "main.inc"
            .global _inputBuffer
            .bss    _inputBuffer,__INPUT_BUFFER_LEN,0,0

            .global _memset
            .global _debug
            .global _hpib_read
            .global _hpib_write

;*--------------------------- YOUR CODE ENDS HERE -----------------------------*
            ; External Functions
            .global _init_dspCom

            .text
            ; Internal functions
            .global _main
_main:
;*--------------------------- YOUR CODE STARTS HERE ---------------------------*
            ; Call any hardware initialization routines here

;*--------------------------- YOUR CODE ENDS HERE -----------------------------*
            CALL    #_init_dspCom           ; Initiliaze DSP Communication struct

;*--------------------------- YOUR CODE STARTS HERE ---------------------------*
            ; Your main program starts here

            ; Clear input buffer
            STM     #_inputBuffer,AR1       ; Starting at location of _dspComBuffer
            NOP
            PSHM    AR1                     ; Store it on the stack
            STM     #0,AR1                  ; Set value to 0
            NOP
            PSHM    AR1                     ; Store it on the stack
            STM     #__INPUT_BUFFER_LEN,AR1 ; Set length to __INPUT_BUFFER_LEN
            NOP
            PSHM    AR1                     ; Store it on the stack
            CALL    #_memset                ; Call memset function 

            ; Call read function
            STM     #_inputBuffer,AR1 
            NOP
            PSHM    AR1
            STM     #__INPUT_BUFFER_LEN,AR1
            NOP
            ; __INPUT_BUFFER_LEN is in words, so multiply by 2
            LDM     AR1,A
            SFTL    A,#1,A
            STLM    A,AR1
            PSHM    AR1
            CALL    #_hpib_read

            POPM    AR1                     ; Get return value from _hpib_read
            PSHM    AR1                     ; And put it back on the stack

            ; debug("Read finished")
            STM     #__SL1,AR1
            NOP
            PSHM    AR1
            CALL    #_debug
            
            ; debug(&_inputBuffer)
            STM     #_inputBuffer,AR1
            NOP
            PSHM    AR1
            CALL    #_debug

            ; Write back the content of _inputBuffer
            POPM    AR2                     ; Get return value from previous _hpib_read
            STM     #_inputBuffer,AR1
            NOP
            PSHM    AR1
            PSHM    AR2
            CALL    #_hpib_write

            POPM    AR1                     ; Get return value from _hpib_write         

            ; Just loop forever
MAIN_LOOP:
            B       MAIN_LOOP

;*--------------------------- YOUR CODE ENDS HERE -----------------------------*

            RET

            .sect   ".const"
;*--------------------------- YOUR CODE STARTS HERE ---------------------------*
            ; Put any strings here
__SL1:      .string "Read finished",0
;*--------------------------- YOUR CODE ENDS HERE -----------------------------*

This file gets called when the program is loaded and started. It sets the stack pointer and start your _main function. If your _main function isn't a loop, it will return to this file and will loop forever in the _exit function. If you want to change the stack size, this file is the place to do that; the current default stack size is 1000 words.

This is where your _main function will reside and is called once the stack size is set. Any further hardware initialisations should occur here.

This is the interrupt vector table of the C5409 DSP, currently only four interrupts are plugged with interrupt handlers: reset, nmi, int0 and hpib_dma. You should leave these interrupts as they are, unless you know what you're doing. These four interrupts are enabled by the _init_dspCom called in _main.

This file contains the functions _handle_int0 and _handle_nmi. If you want to implement these handles then you should uncomment the CONTEXT_SAVE and CONTEXT_RESTORE macro's and place the functionality between those two macro's.

This interrupt handler gets called whenever a DMA transfer finished. This handler could for example start a new _hpib_read or _hpib_write function once a DMA transfer finishes. Be careful though that these functions block and that you're working in an interrupt context.

An include file used by the inner workings of the bridge communication functions. It describes certain constants and the communication structure.

Contains the CONTEXT_SAVE and CONTEXT_RESTORE macro's (which basically push and pop all the registers)

Linker command specification file for Binutils linker. It defines where the different memory sections will be placed in DSP memory.

Basic makefile that builds a COFF2 executable of the framework files.