1 /* ----------------------------------------------------------------------------
\r
2 * SAM Software Package License
\r
3 * ----------------------------------------------------------------------------
\r
4 * Copyright (c) 2013, Atmel Corporation
\r
6 * All rights reserved.
\r
8 * Redistribution and use in source and binary forms, with or without
\r
9 * modification, are permitted provided that the following conditions are met:
\r
11 * - Redistributions of source code must retain the above copyright notice,
\r
12 * this list of conditions and the disclaimer below.
\r
14 * Atmel's name may not be used to endorse or promote products derived from
\r
15 * this software without specific prior written permission.
\r
17 * DISCLAIMER: THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR
\r
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
\r
19 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
\r
20 * DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR ANY DIRECT, INDIRECT,
\r
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
\r
22 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
\r
23 * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
\r
24 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
\r
25 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
\r
26 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
\r
27 * ----------------------------------------------------------------------------
\r
33 * Implements DBGU console.
\r
37 /*----------------------------------------------------------------------------
\r
39 *----------------------------------------------------------------------------*/
\r
46 /*----------------------------------------------------------------------------
\r
48 *----------------------------------------------------------------------------*/
\r
50 /** The Pheripheral has no HW ID */
\r
51 #define ID_NOTUSED 0xFF
\r
53 /** Usart Hw ID (ID_USART0) */
\r
54 #define CONSOLE_ID (pDbgPort->bID)
\r
55 /** Usart Hw interface used by the console (USART0). */
\r
56 #define CONSOLE_DBGU ((Dbgu*)pDbgPort->pHw)
\r
57 /** Pins description list */
\r
58 #define CONSOLE_PINLIST (pDbgPort->pPioList)
\r
59 /** Pins description list size */
\r
60 #define CONSOLE_PINLISTSIZE (pDbgPort->bPioListSize)
\r
62 /*----------------------------------------------------------------------------
\r
64 *----------------------------------------------------------------------------*/
\r
69 typedef struct _DbgPort {
\r
71 const Pin* pPioList;
\r
72 const uint8_t bPioListSize;
\r
76 /*----------------------------------------------------------------------------
\r
78 *----------------------------------------------------------------------------*/
\r
80 /** Pins for DBGU */
\r
81 static const Pin pinsDbgu[] = {PINS_DBGU};
\r
82 /** Pins for USART0 */
\r
83 static const Pin pinsUs0[] = {PIN_USART0_TXD, PIN_USART0_RXD};
\r
84 /** Pins for USART1 */
\r
85 static const Pin pinsUs1[] = {PIN_USART1_TXD, PIN_USART1_RXD};
\r
86 /** Pins for USART3 */
\r
87 static const Pin pinsUs3[] = {PIN_USART3_TXD, PIN_USART3_RXD};
\r
89 /** Uses DBGU as debug port */
\r
90 static sDbgPort dbgpDbgu =
\r
93 pinsDbgu, PIO_LISTSIZE(pinsDbgu),
\r
96 /** Uses USART0 as debug port */
\r
97 static sDbgPort dbgpUs0 =
\r
100 pinsUs0, PIO_LISTSIZE(pinsUs0),
\r
104 /** Uses USART0 as debug port */
\r
105 static sDbgPort dbgpUs1 =
\r
108 pinsUs1, PIO_LISTSIZE(pinsUs1),
\r
111 /** Uses USART0 as debug port */
\r
112 static sDbgPort dbgpUs3 =
\r
115 pinsUs3, PIO_LISTSIZE(pinsUs3),
\r
119 /** Current used debug port */
\r
120 static sDbgPort *pDbgPort = &dbgpUs3;
\r
121 /** Console initialize status */
\r
122 uint8_t _bConsoleIsInitialized = 0;
\r
125 * \brief Select USART0 as DBGU port.
\r
127 void DBGU_ConsoleUseUSART0(void)
\r
129 pDbgPort = &dbgpUs0;
\r
130 _bConsoleIsInitialized = 0;
\r
133 * \brief Select USART1 as DBGU port.
\r
135 void DBGU_ConsoleUseUSART1(void)
\r
137 pDbgPort = &dbgpUs1;
\r
138 _bConsoleIsInitialized = 0;
\r
142 * \brief Select USART3 as DBGU port.
\r
144 void DBGU_ConsoleUseUSART3(void)
\r
146 pDbgPort = &dbgpUs3;
\r
147 _bConsoleIsInitialized = 0;
\r
150 * \brief Select DBGU as DBGU port.
\r
152 void DBGU_ConsoleUseDBGU(void)
\r
154 pDbgPort = &dbgpDbgu;
\r
155 _bConsoleIsInitialized = 0;
\r
159 * \brief Configures an DBGU peripheral with the specified parameters.
\r
161 * \param baudrate Baudrate at which the DBGU should operate (in Hz).
\r
162 * \param masterClock Frequency of the system master clock (in Hz).
\r
164 extern void DBGU_Configure( uint32_t baudrate, uint32_t masterClock)
\r
167 /* Configure PIO */
\r
168 PIO_Configure(CONSOLE_PINLIST, CONSOLE_PINLISTSIZE);
\r
170 if ( ID_NOTUSED != CONSOLE_ID )
\r
172 //PMC_SetPeriMaxClock(CONSOLE_ID, BOARD_MCK);
\r
173 PMC_EnablePeripheral(CONSOLE_ID);
\r
176 /* Configure mode register */
\r
177 if (CONSOLE_DBGU!= DBGU ) {
\r
178 CONSOLE_DBGU->DBGU_MR = DBGU_MR_CHMODE_NORM | DBGU_MR_PAR_NONE | US_MR_CHRL_8_BIT;
\r
181 CONSOLE_DBGU->DBGU_MR = DBGU_MR_CHMODE_NORM | DBGU_MR_PAR_NONE;
\r
183 /* Reset and disable receiver & transmitter */
\r
184 CONSOLE_DBGU->DBGU_CR = DBGU_CR_RSTRX | DBGU_CR_RSTTX;
\r
185 CONSOLE_DBGU->DBGU_IDR = 0xFFFFFFFF;
\r
186 CONSOLE_DBGU->DBGU_CR = DBGU_CR_RXDIS | DBGU_CR_TXDIS;
\r
187 /* Configure baudrate */
\r
188 CONSOLE_DBGU->DBGU_BRGR = (masterClock/2 / baudrate) / 16;
\r
189 /* Enable receiver and transmitter */
\r
190 CONSOLE_DBGU->DBGU_CR = DBGU_CR_RXEN | DBGU_CR_TXEN;
\r
191 _bConsoleIsInitialized = 1 ;
\r
192 #if defined(__GNUC__)
\r
193 setvbuf(stdout, (char*)NULL, _IONBF, 0);
\r
198 * \brief Outputs a character on the DBGU line.
\r
200 * \note This function is synchronous (i.e. uses polling).
\r
201 * \param c Character to send.
\r
203 extern void DBGU_PutChar( uint8_t c )
\r
205 if ( !_bConsoleIsInitialized )
\r
207 DBGU_Configure(CONSOLE_BAUDRATE, BOARD_MCK);
\r
210 /* Wait for the transmitter to be ready */
\r
211 while ( (CONSOLE_DBGU->DBGU_SR & DBGU_SR_TXEMPTY) == 0 ) ;
\r
213 /* Send character */
\r
214 CONSOLE_DBGU->DBGU_THR=c ;
\r
218 * \brief Input a character from the DBGU line.
\r
220 * \note This function is synchronous
\r
221 * \return character received.
\r
223 extern uint32_t DBGU_GetChar( void )
\r
225 if ( !_bConsoleIsInitialized )
\r
227 DBGU_Configure(CONSOLE_BAUDRATE, BOARD_MCK);
\r
230 while ( (CONSOLE_DBGU->DBGU_SR & DBGU_SR_RXRDY) == 0 ) ;
\r
231 return CONSOLE_DBGU->DBGU_RHR ;
\r
235 * \brief Check if there is Input from DBGU line.
\r
237 * \return true if there is Input.
\r
239 extern uint32_t DBGU_IsRxReady( void )
\r
241 if ( !_bConsoleIsInitialized )
\r
243 //DBGU_Configure( CONSOLE_BAUDRATE, BOARD_MCK ) ;
\r
245 return (CONSOLE_DBGU->DBGU_SR & DBGU_SR_RXRDY) > 0 ;
\r
249 * Displays the content of the given frame on the DBGU.
\r
251 * \param pucFrame Pointer to the frame to dump.
\r
252 * \param dwSize Buffer size in bytes.
\r
254 extern void DBGU_DumpFrame( uint8_t* pucFrame, uint32_t dwSize )
\r
258 for ( dw=0 ; dw < dwSize ; dw++ )
\r
260 printf( "%02X ", pucFrame[dw] ) ;
\r
267 * Displays the content of the given buffer on the DBGU.
\r
269 * \param pucBuffer Pointer to the buffer to dump.
\r
270 * \param dwSize Buffer size in bytes.
\r
271 * \param dwAddress Start address to display
\r
273 extern void DBGU_DumpMemory( uint8_t* pucBuffer, uint32_t dwSize, uint32_t dwAddress )
\r
277 uint32_t dwLastLineStart ;
\r
280 for ( i=0 ; i < (dwSize / 16) ; i++ )
\r
282 printf( "0x%08X: ", (unsigned int )(dwAddress + ( i * 16) )) ;
\r
283 pucTmp = (uint8_t*)&pucBuffer[i*16] ;
\r
285 for ( j=0 ; j < 4 ; j++ )
\r
287 printf( "%02X%02X%02X%02X ", pucTmp[0], pucTmp[1], pucTmp[2], pucTmp[3] ) ;
\r
291 pucTmp=(uint8_t*)&pucBuffer[i*16] ;
\r
293 for ( j=0 ; j < 16 ; j++ )
\r
295 DBGU_PutChar( *pucTmp++ ) ;
\r
301 if ( (dwSize%16) != 0 )
\r
303 dwLastLineStart=dwSize - (dwSize%16) ;
\r
305 printf( "0x%08X: ", (unsigned int ) (dwAddress + dwLastLineStart )) ;
\r
306 for ( j=dwLastLineStart ; j < dwLastLineStart+16 ; j++ )
\r
308 if ( (j!=dwLastLineStart) && (j%4 == 0) )
\r
315 printf( "%02X", pucBuffer[j] ) ;
\r
324 for ( j=dwLastLineStart ; j < dwSize ; j++ )
\r
326 DBGU_PutChar( pucBuffer[j] ) ;
\r
336 * \param pdwValue Pointer to the uint32_t variable to contain the input value.
\r
338 extern uint32_t DBGU_GetInteger( uint32_t* pdwValue )
\r
342 uint32_t dwValue=0 ;
\r
346 ucKey=DBGU_GetChar() ;
\r
347 DBGU_PutChar( ucKey ) ;
\r
349 if ( ucKey >= '0' && ucKey <= '9' )
\r
351 dwValue = (dwValue * 10) + (ucKey - '0');
\r
356 if ( ucKey == 0x0D || ucKey == ' ' )
\r
360 printf( "\n\rWrite a number and press ENTER or SPACE!\n\r" ) ;
\r
366 *pdwValue=dwValue ;
\r
373 printf( "\n\r'%c' not a number!\n\r", ucKey ) ;
\r
382 * Reads an integer and check the value
\r
384 * \param pdwValue Pointer to the uint32_t variable to contain the input value.
\r
385 * \param dwMin Minimum value
\r
386 * \param dwMax Maximum value
\r
388 extern uint32_t DBGU_GetIntegerMinMax( uint32_t* pdwValue, uint32_t dwMin, uint32_t dwMax )
\r
390 uint32_t dwValue=0 ;
\r
392 if ( DBGU_GetInteger( &dwValue ) == 0 )
\r
397 if ( dwValue < dwMin || dwValue > dwMax )
\r
399 printf( "\n\rThe number have to be between %u and %u\n\r", (unsigned int)dwMin, (unsigned int)dwMax ) ;
\r
406 *pdwValue = dwValue ;
\r
412 * Reads an hexadecimal number
\r
414 * \param pdwValue Pointer to the uint32_t variable to contain the input value.
\r
416 extern uint32_t DBGU_GetHexa32( uint32_t* pdwValue )
\r
420 uint32_t dwValue = 0 ;
\r
422 for ( dw=0 ; dw < 8 ; dw++ )
\r
424 ucKey = DBGU_GetChar() ;
\r
425 DBGU_PutChar( ucKey ) ;
\r
427 if ( ucKey >= '0' && ucKey <= '9' )
\r
429 dwValue = (dwValue * 16) + (ucKey - '0') ;
\r
433 if ( ucKey >= 'A' && ucKey <= 'F' )
\r
435 dwValue = (dwValue * 16) + (ucKey - 'A' + 10) ;
\r
439 if ( ucKey >= 'a' && ucKey <= 'f' )
\r
441 dwValue = (dwValue * 16) + (ucKey - 'a' + 10) ;
\r
445 printf( "\n\rIt is not a hexa character!\n\r" ) ;
\r
454 *pdwValue = dwValue ;
\r
459 #if defined __ICCARM__ /* IAR Ewarm 5.41+ */
\r
461 * \brief Outputs a character on the DBGU.
\r
463 * \param c Character to output.
\r
465 * \return The character that was output.
\r
467 extern WEAK signed int putchar( signed int c )
\r
469 DBGU_PutChar( c ) ;
\r
473 #endif // defined __ICCARM__
\r