mirror of
https://gitea.osmocom.org/sim-card/simtrace2.git
synced 2026-03-16 21:28:33 +03:00
d44cb80bc5
The DFU uses the UART peripheral (with IRQ/ISR) for the debug output console. Before starting the main application we should make sure this configuration is reset to avoid interference (particularly the IRQ/ISR). This is not too important though since the main application reconfigures the UART for console output. Other peripheral could also be disabled (e.g. all other PIO used by DFU), but most of them also get configured by the main application. Change-Id: I8234d1b85938ad6393094c08183f613ad09ee01b
432 lines
11 KiB
C
432 lines
11 KiB
C
/* ----------------------------------------------------------------------------
|
|
* ATMEL Microcontroller Software Support
|
|
* ----------------------------------------------------------------------------
|
|
* Copyright (c) 2009, Atmel Corporation
|
|
*
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
*
|
|
* - Redistributions of source code must retain the above copyright notice,
|
|
* this list of conditions and the disclaimer below.
|
|
*
|
|
* Atmel's name may not be used to endorse or promote products derived from
|
|
* this software without specific prior written permission.
|
|
*
|
|
* DISCLAIMER: THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
|
|
* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
|
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
|
|
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
* ----------------------------------------------------------------------------
|
|
*/
|
|
|
|
/**
|
|
* \file
|
|
*
|
|
* Implements UART console.
|
|
*
|
|
*/
|
|
|
|
/*----------------------------------------------------------------------------
|
|
* Headers
|
|
*----------------------------------------------------------------------------*/
|
|
|
|
#include "board.h"
|
|
|
|
#include <stdio.h>
|
|
#include <stdint.h>
|
|
|
|
#include "ringbuffer.h"
|
|
|
|
/*----------------------------------------------------------------------------
|
|
* Definitions
|
|
*----------------------------------------------------------------------------*/
|
|
|
|
/*----------------------------------------------------------------------------
|
|
* Variables
|
|
*----------------------------------------------------------------------------*/
|
|
|
|
/** Is Console Initialized. */
|
|
static uint8_t _ucIsConsoleInitialized=0;
|
|
/** Ring buffer to queue data to be sent */
|
|
static ringbuf uart_tx_buffer;
|
|
|
|
/**
|
|
* \brief Configures an USART peripheral with the specified parameters.
|
|
*
|
|
* \param baudrate Baudrate at which the USART should operate (in Hz).
|
|
* \param masterClock Frequency of the system master clock (in Hz).
|
|
*/
|
|
extern void UART_Configure( uint32_t baudrate, uint32_t masterClock)
|
|
{
|
|
const Pin pPins[] = CONSOLE_PINS;
|
|
Uart *pUart = CONSOLE_UART;
|
|
|
|
/* Configure PIO */
|
|
PIO_Configure(pPins, PIO_LISTSIZE(pPins));
|
|
|
|
/* Configure PMC */
|
|
PMC->PMC_PCER0 = 1 << CONSOLE_ID;
|
|
|
|
/* Reset and disable receiver & transmitter */
|
|
pUart->UART_CR = UART_CR_RSTRX | UART_CR_RSTTX
|
|
| UART_CR_RXDIS | UART_CR_TXDIS;
|
|
|
|
/* Configure mode */
|
|
pUart->UART_MR = UART_MR_PAR_NO;
|
|
|
|
/* Configure baudrate */
|
|
/* Asynchronous, no oversampling */
|
|
pUart->UART_BRGR = (masterClock / baudrate) / 16;
|
|
|
|
/* Disable PDC channel */
|
|
pUart->UART_PTCR = UART_PTCR_RXTDIS | UART_PTCR_TXTDIS;
|
|
|
|
/* Reset transmit ring buffer */
|
|
rbuf_reset(&uart_tx_buffer);
|
|
|
|
/* Enable TX interrupts */
|
|
pUart->UART_IER = UART_IER_TXRDY;
|
|
NVIC_EnableIRQ(CONSOLE_IRQ);
|
|
|
|
/* Enable receiver and transmitter */
|
|
pUart->UART_CR = UART_CR_RXEN | UART_CR_TXEN;
|
|
|
|
/* Remember the configuration is complete */
|
|
_ucIsConsoleInitialized=1 ;
|
|
}
|
|
|
|
/**
|
|
* \brief Disables the USART peripheral and related IRQ
|
|
*/
|
|
void UART_Exit(void)
|
|
{
|
|
if (!_ucIsConsoleInitialized) {
|
|
return;
|
|
}
|
|
|
|
Uart *pUart = CONSOLE_UART;
|
|
pUart->UART_IDR = UART_IDR_TXRDY;
|
|
pUart->UART_CR = UART_CR_RSTRX | UART_CR_RSTTX | UART_CR_RXDIS | UART_CR_TXDIS | UART_CR_RSTSTA;
|
|
PMC->PMC_PCDR0 = 1 << CONSOLE_ID;
|
|
NVIC_DisableIRQ(CONSOLE_IRQ);
|
|
}
|
|
|
|
/** Interrupt Service routine to transmit queued data */
|
|
void CONSOLE_ISR(void)
|
|
{
|
|
Uart *uart = CONSOLE_UART;
|
|
if (uart->UART_SR & UART_SR_TXRDY) {
|
|
if (!rbuf_is_empty(&uart_tx_buffer)) {
|
|
//uart->UART_IER = UART_IER_TXRDY;
|
|
uart->UART_THR = rbuf_read(&uart_tx_buffer);
|
|
} else {
|
|
uart->UART_IDR = UART_IER_TXRDY;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* \brief Outputs a character on the UART line.
|
|
*
|
|
* \note This function is synchronous (i.e. uses polling).
|
|
* \param c Character to send.
|
|
*/
|
|
extern void UART_PutChar( uint8_t c )
|
|
{
|
|
Uart *pUart = CONSOLE_UART ;
|
|
|
|
/* Initialize console is not already done */
|
|
if ( !_ucIsConsoleInitialized )
|
|
{
|
|
UART_Configure(CONSOLE_BAUDRATE, BOARD_MCK);
|
|
}
|
|
|
|
/* Only store input if buffer is not full, else drop it */
|
|
bool trigger_isr = false;
|
|
if (rbuf_is_empty(&uart_tx_buffer)) {
|
|
trigger_isr = true;
|
|
}
|
|
if (!rbuf_is_full(&uart_tx_buffer)) {
|
|
rbuf_write(&uart_tx_buffer, c);
|
|
}
|
|
if (trigger_isr) {
|
|
pUart->UART_IER = UART_IER_TXRDY;
|
|
CONSOLE_ISR();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* \brief Input a character from the UART line.
|
|
*
|
|
* \note This function is synchronous
|
|
* \return character received.
|
|
*/
|
|
extern uint32_t UART_GetChar( void )
|
|
{
|
|
Uart *pUart = CONSOLE_UART ;
|
|
|
|
if ( !_ucIsConsoleInitialized )
|
|
{
|
|
UART_Configure(CONSOLE_BAUDRATE, BOARD_MCK);
|
|
}
|
|
|
|
while ( (pUart->UART_SR & UART_SR_RXRDY) == 0 )
|
|
WDT_Restart(WDT);
|
|
|
|
return pUart->UART_RHR ;
|
|
}
|
|
|
|
/**
|
|
* \brief Check if there is Input from UART line.
|
|
*
|
|
* \return true if there is Input.
|
|
*/
|
|
extern uint32_t UART_IsRxReady( void )
|
|
{
|
|
Uart *pUart = CONSOLE_UART;
|
|
|
|
if ( !_ucIsConsoleInitialized )
|
|
{
|
|
UART_Configure( CONSOLE_BAUDRATE, BOARD_MCK ) ;
|
|
}
|
|
|
|
return (pUart->UART_SR & UART_SR_RXRDY) > 0 ;
|
|
}
|
|
|
|
/**
|
|
* Displays the content of the given frame on the UART0.
|
|
*
|
|
* \param pucFrame Pointer to the frame to dump.
|
|
* \param dwSize Buffer size in bytes.
|
|
*/
|
|
extern void UART_DumpFrame( uint8_t* pucFrame, uint32_t dwSize )
|
|
{
|
|
uint32_t dw ;
|
|
|
|
for ( dw=0 ; dw < dwSize ; dw++ )
|
|
{
|
|
printf( "%02X ", pucFrame[dw] ) ;
|
|
}
|
|
|
|
printf( "\n\r" ) ;
|
|
}
|
|
|
|
/**
|
|
* Displays the content of the given buffer on the UART0.
|
|
*
|
|
* \param pucBuffer Pointer to the buffer to dump.
|
|
* \param dwSize Buffer size in bytes.
|
|
* \param dwAddress Start address to display
|
|
*/
|
|
extern void UART_DumpMemory( uint8_t* pucBuffer, uint32_t dwSize, uint32_t dwAddress )
|
|
{
|
|
uint32_t i ;
|
|
uint32_t j ;
|
|
uint32_t dwLastLineStart ;
|
|
uint8_t* pucTmp ;
|
|
|
|
for ( i=0 ; i < (dwSize / 16) ; i++ )
|
|
{
|
|
printf( "0x%08X: ", (unsigned int)(dwAddress + (i*16)) ) ;
|
|
pucTmp = (uint8_t*)&pucBuffer[i*16] ;
|
|
|
|
for ( j=0 ; j < 4 ; j++ )
|
|
{
|
|
printf( "%02X%02X%02X%02X ", pucTmp[0], pucTmp[1], pucTmp[2], pucTmp[3] ) ;
|
|
pucTmp += 4 ;
|
|
}
|
|
|
|
pucTmp=(uint8_t*)&pucBuffer[i*16] ;
|
|
|
|
for ( j=0 ; j < 16 ; j++ )
|
|
{
|
|
UART_PutChar( *pucTmp++ ) ;
|
|
}
|
|
|
|
printf( "\n\r" ) ;
|
|
}
|
|
|
|
if ( (dwSize%16) != 0 )
|
|
{
|
|
dwLastLineStart=dwSize - (dwSize%16) ;
|
|
|
|
printf( "0x%08X: ", (unsigned int)(dwAddress + dwLastLineStart) ) ;
|
|
for ( j=dwLastLineStart ; j < dwLastLineStart+16 ; j++ )
|
|
{
|
|
if ( (j!=dwLastLineStart) && (j%4 == 0) )
|
|
{
|
|
printf( " " ) ;
|
|
}
|
|
|
|
if ( j < dwSize )
|
|
{
|
|
printf( "%02X", pucBuffer[j] ) ;
|
|
}
|
|
else
|
|
{
|
|
printf(" ") ;
|
|
}
|
|
}
|
|
|
|
printf( " " ) ;
|
|
for ( j=dwLastLineStart ; j < dwSize ; j++ )
|
|
{
|
|
UART_PutChar( pucBuffer[j] ) ;
|
|
}
|
|
|
|
printf( "\n\r" ) ;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Reads an integer
|
|
*
|
|
* \param pdwValue Pointer to the uint32_t variable to contain the input value.
|
|
*/
|
|
extern uint32_t UART_GetInteger( uint32_t* pdwValue )
|
|
{
|
|
uint8_t ucKey ;
|
|
uint8_t ucNbNb=0 ;
|
|
uint32_t dwValue=0 ;
|
|
|
|
while ( 1 )
|
|
{
|
|
ucKey=UART_GetChar() ;
|
|
UART_PutChar( ucKey ) ;
|
|
|
|
if ( ucKey >= '0' && ucKey <= '9' )
|
|
{
|
|
dwValue = (dwValue * 10) + (ucKey - '0');
|
|
ucNbNb++ ;
|
|
}
|
|
else
|
|
{
|
|
if ( ucKey == 0x0D || ucKey == ' ' )
|
|
{
|
|
if ( ucNbNb == 0 )
|
|
{
|
|
printf( "\n\rWrite a number and press ENTER or SPACE!\n\r" ) ;
|
|
return 0 ;
|
|
}
|
|
else
|
|
{
|
|
printf( "\n\r" ) ;
|
|
*pdwValue=dwValue ;
|
|
|
|
return 1 ;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
printf( "\n\r'%c' not a number!\n\r", ucKey ) ;
|
|
|
|
return 0 ;
|
|
}
|
|
}
|
|
WDT_Restart(WDT);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Reads an integer and check the value
|
|
*
|
|
* \param pdwValue Pointer to the uint32_t variable to contain the input value.
|
|
* \param dwMin Minimum value
|
|
* \param dwMax Maximum value
|
|
*/
|
|
extern uint32_t UART_GetIntegerMinMax( uint32_t* pdwValue, uint32_t dwMin, uint32_t dwMax )
|
|
{
|
|
uint32_t dwValue=0 ;
|
|
|
|
if ( UART_GetInteger( &dwValue ) == 0 )
|
|
{
|
|
return 0 ;
|
|
}
|
|
|
|
if ( dwValue < dwMin || dwValue > dwMax )
|
|
{
|
|
printf( "\n\rThe number have to be between %d and %d\n\r", (int)dwMin, (int)dwMax ) ;
|
|
|
|
return 0 ;
|
|
}
|
|
|
|
printf( "\n\r" ) ;
|
|
|
|
*pdwValue = dwValue ;
|
|
|
|
return 1 ;
|
|
}
|
|
|
|
/**
|
|
* Reads an hexadecimal number
|
|
*
|
|
* \param pdwValue Pointer to the uint32_t variable to contain the input value.
|
|
*/
|
|
extern uint32_t UART_GetHexa32( uint32_t* pdwValue )
|
|
{
|
|
uint8_t ucKey ;
|
|
uint32_t dw = 0 ;
|
|
uint32_t dwValue = 0 ;
|
|
|
|
for ( dw=0 ; dw < 8 ; dw++ )
|
|
{
|
|
ucKey = UART_GetChar() ;
|
|
UART_PutChar( ucKey ) ;
|
|
|
|
if ( ucKey >= '0' && ucKey <= '9' )
|
|
{
|
|
dwValue = (dwValue * 16) + (ucKey - '0') ;
|
|
}
|
|
else
|
|
{
|
|
if ( ucKey >= 'A' && ucKey <= 'F' )
|
|
{
|
|
dwValue = (dwValue * 16) + (ucKey - 'A' + 10) ;
|
|
}
|
|
else
|
|
{
|
|
if ( ucKey >= 'a' && ucKey <= 'f' )
|
|
{
|
|
dwValue = (dwValue * 16) + (ucKey - 'a' + 10) ;
|
|
}
|
|
else
|
|
{
|
|
printf( "\n\rIt is not a hexa character!\n\r" ) ;
|
|
|
|
return 0 ;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
printf("\n\r" ) ;
|
|
*pdwValue = dwValue ;
|
|
|
|
return 1 ;
|
|
}
|
|
|
|
#if defined __ICCARM__ /* IAR Ewarm 5.41+ */
|
|
/**
|
|
* \brief Outputs a character on the UART.
|
|
*
|
|
* \param c Character to output.
|
|
*
|
|
* \return The character that was output.
|
|
*/
|
|
extern WEAK signed int putchar( signed int c )
|
|
{
|
|
UART_PutChar( c ) ;
|
|
|
|
return c ;
|
|
}
|
|
#endif // defined __ICCARM__
|
|
|