fmu.c

ARM入门的好帮手.包含了从简单到相对较复杂的程序.

//*----------------------------------------------------------------------------
//*      ATMEL Microcontroller Software Support  -  ROUSSET  -
//*----------------------------------------------------------------------------
//* The software is delivered "AS IS" without warranty or condition of any
//* kind, either express, implied or statutory. This includes without
//* limitation any warranty or condition with respect to merchantability or
//* fitness for any particular purpose, or against the infringements of
//* intellectual property rights of others.
//*----------------------------------------------------------------------------
//* File Name           : fmu.c
//* Object              : AT91
//* 1.0 17/04/00 EL     : AT91 FLash Memory Uploader
//* 1.1 03/07/00 EL     : Reset command and clean up
//* 1.2 04/09/00 EL     : Version 2.2 (cstarutp modification)
//* 1.3 15/11/00 EL     : Clean UP
//* 1.4 31/01/02 PFi    : Test signal on pin PIO1, 2 and 4 has been removed.
//*                     : Port to ARM ADS v1.1
//*----------------------------------------------------------------------------
#include    "term1.h"
#include    "parts/m42800/lib_m42800.h"
#include    "parts/m42800/reg_m42800.h"
#include    "protocol.h"
#include    "flash_16x4.h"
#include    "targets/eb42/eb42.h"


#define AT91_LOADER_VERSION 0x0203

#define USART0 0
#define USART1 1


/* 8-bit Flash Data type */
typedef volatile unsigned char flash_byte ;

extern void at91_irq_handler(void);
extern void pioa_asm_irq_handler(void);
extern u_char command_lng;

//* Terminal declaration
TerminalDataDesc    terminal_data_1;
TerminalDesc        terminal_1;

//* Command declaration
ATS_Command *ats_pt;
SPEED_Command *speed_pt;
ERASE_Command *erase_pt;
WRITE_Command *write_pt;
READ_Command *read_pt;
VERIFY_Command *verify_pt;

//* Flags
volatile  char PIO_IRQ_Flag;
volatile char Buffer1_state;
volatile char Buffer2_state;
volatile char NewCommand;
volatile char use_usart;

//* counter
int i = 0;

//* pointers
volatile u_char *command;
volatile u_char *command_pgm;
flash_byte *addr;
flash_word *address;
flash_word *base_addr;
flash_word *load_addr;

//* data
flash_word device_code = 0x00C0;
flash_word manuf_code = 0x001F;
flash_word data;
flash_word version;
u_int checksum, chk, length;
u_char c;

//*----------------------------------------------------------------------------
//* Function Name       : pio_c_irq_handler
//* Object              : PIO interrupt handler
//* Input Parameters    : None
//* Output Parameters   : None
//*----------------------------------------------------------------------------
void pioa_c_irq_handler (void)
//* Begin
{
    //* Determines interrupt source (default USART0)
    if ((PIOA_ISR & PA10) == PA10)
    use_usart = USART1;
    else
    use_usart = USART0;

    //* set PIO_IRQ_Flag
    PIO_IRQ_Flag = TRUE;

    //* change edge detection
    AIC_BASE->AIC_SMR[13] = 0x60 | AIC_PRIOR;
}
//* End


//*----------------------------------------------------------------------------
//* Function Name       : speed_detection
//* Object              : CD calculation
//* Input Parameters    : None
//* Output Parameters   : CD value
//*----------------------------------------------------------------------------
u_int speed_detection ( void )
//* Begin
{
u_int timer_value[4];

    //* Timer Counter initialisation
    at91_tc_open(&TC0_DESC, TC_CLKS_MCK8 ,FALSE, FALSE);

    //* PIO configuration
    //* RxD0, TxD0
    at91_pio_open(&PIOA_DESC,PA7,PIO_INPUT_IRQ_ON);
    at91_pio_open(&PIOA_DESC,PA6,PIO_OUTPUT);
    at91_pio_write(&PIOA_DESC,PA6,PIO_SET_OUT);

    //* RxD1, TxD1
    at91_pio_open(&PIOA_DESC,PA10,PIO_INPUT_IRQ_ON);
    at91_pio_open(&PIOA_DESC,PA9,PIO_OUTPUT);
    at91_pio_write(&PIOA_DESC,PA9,PIO_SET_OUT);

    //* PIO IRQ configuration
    at91_irq_open(PIOA_DESC.periph_id, AIC_PRIOR ,0x40, pioa_asm_irq_handler);

    //* Open PIO Clock
    at91_clock_open(PIOA_DESC.periph_id);

    //* Reset PIO IRQ Flag
    PIO_IRQ_Flag = PIOA_ISR;
    PIO_IRQ_Flag = FALSE;

    //* Wait IRQ
    while(PIO_IRQ_Flag == FALSE);

     //* Start timer
    at91_tc_trig_cmd(&TC0_DESC, TC_TRIG_CHANNEL);

    //* Reset PIO IRQ Flag
    PIO_IRQ_Flag = FALSE;

    //* Wait IRQ
    while(PIO_IRQ_Flag == FALSE);

    //* Reset PIO IRQ Flag
    PIO_IRQ_Flag = FALSE;

    //* Stop timer
    at91_tc_read(&TC0_DESC, timer_value);

    //* CD calculation
    return(timer_value[3] >> 4);  //* synchro = 0x80
}
//* End


//*----------------------------------------------------------------------------
//* Function Name       : send_command
//* Object              : send the command
//* Input Parameters    : command identifier, command length
//* Output Parameters   : None
//*----------------------------------------------------------------------------
void send_command (char command_id, char length)
{

    //* Number of byte to transmit
    terminal_1.term_data->tx_cnt = length;

    switch(command_id)
    {
        case ACK :  //* send ACK
                    terminal_1.term_data->tx_in_pt[COMMAND_CODE] = ACK;
                    break;

        case ATS :  //* send ATS
            ats_pt = (ATS_Command *) terminal_1.term_data->tx_in_pt;
                    ats_pt->code = ATS;
                    ats_pt->chip = 0x1;
                    ats_pt->manuf = manuf_code;
                    ats_pt->flash = device_code;
                    ats_pt->version  = version;
                    ats_pt->cd = terminal_1.baud_rate;
                    ats_pt->addr = (u_int) base_addr;
                    break;

        case DATA :  //* send DATA
                    terminal_1.term_data->tx_in_pt[COMMAND_CODE] = DATA;
                    break;

        case NACK : //* send NACK
                    terminal_1.term_data->tx_in_pt[COMMAND_CODE] = NACK;
                    break;

        case ERROR : //* send ERROR
                    terminal_1.term_data->tx_in_pt[COMMAND_CODE] = ERROR;
                    break;
    }

    terminal_1.term_data->tx_out_pt = terminal_1.term_data->tx_in_pt;

    //* enable TXRDY interrupt
    terminal_1.usart_desc->usart_base->US_IER = 0x02;

}


//*----------------------------------------------------------------------------
//* Function Name       : do_synchronisation
//* Object              : implements synchronisation protocol
//* Input Parameters    : None
//* Output Parameters   : 1 if synchronisation OK
//*----------------------------------------------------------------------------
u_char do_synchronisation (void)
{

char synchro;
u_int timeout;
u_int baud_rate;

    synchro = FALSE;
    timeout = 0;

    while(synchro == FALSE)
    {
        //* reset timeout
        timeout = 0;

        //* USART baud rate configuration
        baud_rate = speed_detection();

        //* Open terminal (USART0 or USART1)
        if(use_usart != USART0)
        terminal_1.usart_desc = &USART1_DESC;
        terminal_1.baud_rate = baud_rate;
        at91_term1_open(&terminal_1);

        //* USART IRQ initialisation
        at91_irq_open(terminal_1.usart_desc->periph_id,7,0x40,at91_irq_handler);

        //* Flash identification
        //at91_flash_identify(base_addr, &manuf_code, &device_code);

        //* send ATS command
        send_command(ATS, LEN_ATS_COMMAND);

        //* enable RXRDY
        terminal_1.usart_desc->usart_base->US_IER = 0x03;

        //* Wait synchro command
        while ((synchro == FALSE) && timeout < 10000)
        {
            if(NewCommand == TRUE)
            {
                if (command[COMMAND_CODE] == ACK)
                {
                    //* Speed detected
                    synchro = TRUE;

                    //* send ACK
                    send_command(ACK, LEN_ACK_COMMAND);
                }
                else
                {
                    timeout = 100000;

                    //* send NACK
                    send_command(NACK, LEN_NACK_COMMAND);
                }

            //* wait end of transmission
            while((terminal_1.usart_desc->usart_base->US_CSR & 0x200 ) == 0);
            }

            //* increment timeout
            //timeout++;

        if (timeout >= 100000)
        {
                at91_term1_close(&terminal_1);
        NewCommand = FALSE;
        }
        }
    }
return(1);
}