ssio_sample.c

oki67500系列arm工程例程源代码

/**************************************************************************/
/*                                                                        */
/*     Copyright (C) 2003 Oki Electric Industry Co., LTD.                 */
/*                                                                        */
/*     System Name  :  ML675001 series                                    */
/*     Module Name  :  Ssio sample program                                */
/*     File   Name  :  ssio_sample.c                                      */
/*     Revision     :  01.01                                              */
/*     Date         :  2003/08/18                                         */
/*                                                                        */
/**************************************************************************/
#include   "ML675001.h"
#include   "common.h"
#include   "cache.h"

/* constants */
#define    BUFF_SIZE            256
#define    SSIO_LED_NORMAL      LED_NORMAL_END_PATTERN  /* OK pattern */
#define    SSIO_LED_OERR        0x5d  /* overrun error pattern */
#define    SSIO_LED_COMP_ERR    0x58  /* compare error pattern */
#define    SSIO_END_PATTERN     0x00  /* data-end pattern */
#define    DUMMY_DATA           0xff  /* Dummy data pattern */

/* functions */
int     main(void);             /* main routine */
void    init_ssio(void);        /* initialize SSIO */
int     ssio_cont(void);        /* SSIO send/receive control */
void    ssio_send(UBYTE);       /* SSIO send process */
UBYTE   ssio_receive(void);     /* SSIO receive process */
void    led_on(UHWORD);         /* LED on */
void    init_led(void);         /* initialize LED */
/* global variables */
volatile  unsigned  char  send_buff[BUFF_SIZE+1];  /* send buffer */
volatile  unsigned  char  receive_buff[BUFF_SIZE+1];  /* receive buffer */

volatile  int  error_flag;  /* =SSIO_LED_NORMAL:no error,
                                SSIO_LED_OERR:overrun error,
                                SSIO_LED_COMP_ERR:compare error */
/******************************************************************/
/*  Entry point                                                   */
/*  Function : main                                               */
/*      Parameters                                                */
/*          Input  :  Nothing                                     */
/*          Output :  0                                           */
/******************************************************************/
int main(void)
{
    HWORD	i;


    init_cache();  /* Initialize CACHE memory */
    cache_on(CACHE_BANK0);  /* Bank0 : Cache enable */

    for(i=0;i<BUFF_SIZE;i++) {
    	send_buff[i] = i+1;
    	receive_buff[i] = 0;
    }
    init_ssio();                /* initialize ssio */

    /***  initialize led  ***/
    init_led();                 /* set output mode */
    led_on(LED_START_PATTERN);  /* light led start pattern */

    put_value(SSIOTSCON ,SSIOTSCON_LBTST);  /* set loopback-test mode */
    error_flag = ssio_cont();   /* SSIO send/receive control */
    put_value(SSIOTSCON ,SSIOTSCON_NOTST);  /* set no-test mode */
    if(error_flag == SSIO_LED_NORMAL) {     /* no error */
        for(i = 0; send_buff[i] != SSIO_END_PATTERN ; i ++) {   /* loop4 */
            if(send_buff[i] != receive_buff[i]) {   /* data unmach ? */
                error_flag = SSIO_LED_COMP_ERR;
                break;
            }
        }   /* loop4 end */
    }
    led_on(error_flag); /* turn on lower square LED */

    return 0;
}

/******************************************************************/
/*  Initialize SSIO                                               */
/*  Function : init_ssio                                          */
/*      Parameters                                                */
/*          Input  :  Nothing                                     */
/*          Output :  Nothing                                     */
/******************************************************************/
void init_ssio()
{
    UBYTE   work_dt;

    /***********************************************************
        Setup of SSIO
        CON_SLMSB    corresponds to LSBfast
        CON_SFTSLV   corresponds to master
        CON_SFTCLK   corresponds to 1/8cclk
    ***********************************************************/
    put_value(SSIOCON ,SSIOCON_SLLSB | SSIOCON_MASTER | SSIOCON_8CCLK);

    /***********************************************************
        Set Loopback test mode
    ***********************************************************/
    put_value(SSIOTSCON ,SSIOTSCON_LBTST);

    /***********************************************************
        Clear Status
    ***********************************************************/
    put_value(SSIOST,0x00);

    /***********************************************************
        Dummy Data to Send & Receive
    ***********************************************************/
    ssio_send(DUMMY_DATA);          /* Dummy Data Send */

    work_dt = ssio_receive();       /* Dummy Data Receive */

    /***********************************************************
        Reset Loopback test mode
    ***********************************************************/
    put_value(SSIOTSCON ,SSIOTSCON_NOTST);

    /***********************************************************
        Clear interrupt bit TRCMP & RXCMP
    ***********************************************************/
    put_value(SSIOINT ,SSIOCON_TXCMP | SSIOCON_RXCMP);

    /* data-end pattern set */
    send_buff[BUFF_SIZE] = SSIO_END_PATTERN;

    return;
}

/******************************************************************/
/*  SSIO-Data send/receive control                                */
/*  Function : ssio_cont                                          */
/*      Parameters                                                */
/*          Input  :  Nothing                                     */
/*          Output :  OK/NG                                       */
/******************************************************************/
int     ssio_cont(void)
{
    int     chk_flag;
    int     i;
    UBYTE   read_data;

    chk_flag = SSIO_LED_NORMAL;

    for(i = 0;send_buff[i] != SSIO_END_PATTERN; i ++) { /* (loop1) */
        /* send empty ? (loop2) */
        while((get_value(SSIOINT) & SSIOCON_TREMP) != SSIOCON_TREMP)
            ;
        ssio_send(send_buff[i]);        /* Data send */

        read_data = ssio_receive();     /* Data receive */
        /* Over-run error ? */
        if((get_value(SSIOST) & SSIOSTA_OERR) == SSIOSTA_OERR) {
            chk_flag = SSIO_LED_OERR;
            break;
        }
        receive_buff[i] = read_data;    /* Receive data save */
    }   /* loop1 end */

    return(chk_flag);
}

/******************************************************************/
/*  SSIO data send                                                */
/*  Function : ssio_send                                          */
/*      Parameters                                                */
/*          Input  :  send data                                   */
/*          Output :  Nothing                                     */
/******************************************************************/
void    ssio_send(UBYTE send_data)
{

    put_value(SSIOINT, SSIOCON_TREMP);  /* clean TREMP bit */
    put_value(SSIOBUF, send_data);      /* Set send data */

    return;
}

/******************************************************************/
/*  SSIO data receive                                             */
/*  Function : ssio_receive                                       */
/*      Parameters                                                */
/*          Input  :  Nothing                                     */
/*          Output :  receive data                                */
/******************************************************************/
UBYTE   ssio_receive(void)
{
    UBYTE   read_data;

    /* receive empty ? (loop3) */
    while((get_value(SSIOINT) & SSIOCON_RXCMP) != SSIOCON_RXCMP)
        ;

    read_data = get_value(SSIOBUF);     /* Read receive data */
    put_value(SSIOINT, SSIOCON_RXCMP);  /* clean RXCMP bit */

    return(read_data);
}