drv/kdebug.c

   1 /*!
   2  * \file
   3  * <!--
   4  * Copyright 2003,2004 Develer S.r.l. (http://www.develer.com/)
   5  * Copyright 2000,2001,2002 Bernardo Innocenti <bernie@codewiz.org>
   6  * This file is part of DevLib - See devlib/README for information.
   7  * -->
   8  *
   9  * \brief General pourpose debug functions.
  10  *
  11  * \version $Id$
  12  *
  13  * \author Bernardo Innocenti <bernie@develer.com>
  14  * \author Stefano Fedrigo <aleph@develer.com>
  15  */
  16
  17 /*
  18  * $Log$
  19  * Revision 1.4  2004/06/06 18:09:51  bernie
  20  * Import DSP56800 changes; Print broken wall bricks in hex.
  21  *
  22  * Revision 1.3  2004/06/03 11:27:09  bernie
  23  * Add dual-license information.
  24  *
  25  * Revision 1.2  2004/05/23 18:21:53  bernie
  26  * Trim CVS logs and cleanup header info.
  27  *
  28  */
  29
  30 #include "kdebug.h"
  31 #include "hw.h"
  32 #include "config.h"
  33
  34 #include <mware/formatwr.h> /* for _formatted_write() */
  35
  36 #ifdef _DEBUG
  37
  38 #if defined(_EMUL)
  39         #include <stdio.h>
  40         #define KDBG_WAIT_READY()      do {/*nop*/} while(0)
  41         #define KDBG_WRITE_CHAR(c)     putchar((c))
  42         #define KDBG_MASK_IRQ(old)     do {/*nop*/} while(0)
  43         #define KDBG_RESTORE_IRQ()     do {/*nop*/} while(0)
  44 #elif defined(__I196__)
  45         #include "Util196.h"
  46         #define KDBG_WAIT_READY()      do {} while (!(SP_STAT & (SPSF_TX_EMPTY | SPSF_TX_INT)))
  47         #define KDBG_WRITE_CHAR(c)     do { SBUF = (c); } while(0)
  48         #define KDBG_MASK_IRQ(old) \
  49                 do { \
  50                         (old) = INT_MASK1 & INT1F_TI; \
  51                         INT_MASK1 &= ~INT1F_TI; \
  52                 } while(0)
  53         #define KDBG_RESTORE_IRQ(old)  do { INT_MASK1 |= (old); }
  54 #elif defined(__AVR__)
  55         #include <avr/io.h>
  56         #if CONFIG_KDEBUG_PORT == 0
  57                 #ifndef __AVR_ATmega103__
  58                         #define UCR UCSR0B
  59                         #define UDR UDR0
  60                         #define USR UCSR0A
  61                 #endif
  62                 #define KDBG_WAIT_READY()     do { loop_until_bit_is_set(USR, UDRE); } while(0)
  63                 #define KDBG_WRITE_CHAR(c)    do { UCR |= BV(TXEN); UDR = (c); } while(0)
  64                 #define KDBG_MASK_IRQ(old)    do { (old) = UCR & BV(TXCIE); cbi(UCR, TXCIE); } while(0)
  65                 #define KDBG_RESTORE_IRQ(old) do { UCR |= (old); } while(0)
  66         #elif CONFIG_KDEBUG_PORT == 1
  67                 #define KDBG_WAIT_READY()     do { loop_until_bit_is_set(UCSR1A, UDRE); } while(0)
  68                 #define KDBG_WRITE_CHAR(c)    do { UCSR1B |= BV(TXEN); UDR1 = (c); } while(0)
  69                 #define KDBG_MASK_IRQ(old)    do { (old) = UCSR1B & BV(TXCIE); cbi(UCSR1B, TXCIE); } while(0)
  70                 #define KDBG_RESTORE_IRQ(old) do { UCSR1B |= (old); } while(0)
  71         #else
  72                 #error CONFIG_KDEBUG_PORT should be either 0 or 1
  73         #endif
  74 #elif defined(__MWERKS__) && (defined(__m56800E__) || defined(__m56800__))
  75         /* Debugging go through the JTAG interface. The MSL library already
  76            implements the console I/O correctly. */
  77         #include <stdio.h>
  78         #define KDBG_WAIT_READY()
  79         #define KDBG_WRITE_CHAR(c)        do { char ch=c; fwrite(&ch,1,1,stdout); } while (0)
  80         #define KDBG_MASK_IRQ(old)
  81         #define KDBG_RESTORE_IRQ(old)
  82 #else
  83         #error Unknown architecture
  84 #endif
  85
  86
  87 void kdbg_init(void)
  88 {
  89 #if defined(__I196__)
  90
  91         /* Set serial port for 19200bps 8N1 */
  92         INT_MASK1 &= ~(INT1F_TI | INT1F_RI);
  93         SP_CON = SPCF_RECEIVE_ENABLE | SPCF_MODE1;
  94         ioc1_img |= IOC1F_TXD_SEL | IOC1F_EXTINT_SRC;
  95         IOC1 = ioc1_img;
  96         BAUD_RATE = 0x33;
  97         BAUD_RATE = 0x80;
  98
  99 #elif defined(__AVR__)
 100
 101         /* Compute the baud rate */
 102         uint16_t period = (((CLOCK_FREQ / 16UL) + (CONFIG_KDEBUG_BAUDRATE / 2)) / CONFIG_KDEBUG_BAUDRATE) - 1;
 103
 104         #ifdef __AVR_ATmega64__
 105                 #if CONFIG_KDEBUG_PORT == 0
 106
 107                         /* Set the baud rate */
 108                         UBRR0H = (uint8_t)(period>>8);
 109                         UBRR0L = (uint8_t)period;
 110
 111                 #elif CONFIG_KDEBUG_PORT == 1
 112
 113                         UBRR1H = (uint8_t)(period>>8);
 114                         UBRR1L = (uint8_t)period;
 115
 116                 #else
 117                         #error CONFIG_KDEBUG_PORT should be either 0 or 1
 118                 #endif
 119         #elif defined (__AVR_ATmega103__)
 120
 121                 /* Set the baud rate */
 122                 UBRR = (uint8_t)period;
 123
 124         #else
 125                 #error Unknown arch
 126         #endif
 127
 128 #endif /* !__I196__ && !__AVR__ */
 129
 130         kputs("\n\n*** DBG START ***\n");
 131 }
 132
 133
 134 /*!
 135  * Output one character to the debug console
 136  */
 137 static void kputchar(char c, UNUSED(void *unused))
 138 {
 139         /* Poll while serial buffer is still busy */
 140         KDBG_WAIT_READY();
 141
 142         /* Send '\n' as '\r\n' for dumb terminals */
 143         if (c == '\n')
 144         {
 145                 KDBG_WRITE_CHAR('\r');
 146                 KDBG_WAIT_READY();
 147         }
 148
 149         KDBG_WRITE_CHAR(c);
 150 }
 151
 152
 153 void PGM_FUNC(kprintf)(const char * PGM_ATTR fmt, ...)
 154 {
 155         va_list ap;
 156
 157         /* Mask serial TX intr */
 158         unsigned char irqsave;
 159         KDBG_MASK_IRQ(irqsave);
 160
 161         va_start(ap, fmt);
 162         PGM_FUNC(_formatted_write)(fmt, kputchar, 0, ap);
 163         va_end(ap);
 164
 165         /* Restore serial TX intr */
 166         KDBG_RESTORE_IRQ(irqsave);
 167 }
 168
 169
 170 void PGM_FUNC(kputs)(const char * PGM_ATTR str)
 171 {
 172         char c;
 173
 174         /* Mask serial TX intr */
 175         unsigned char irqsave;
 176         KDBG_MASK_IRQ(irqsave);
 177
 178         while ((c = PGM_READ_CHAR(str++)))
 179                 kputchar(c, 0);
 180
 181         KDBG_RESTORE_IRQ(irqsave);
 182 }
 183
 184
 185 int PGM_FUNC(__assert)(const char * PGM_ATTR cond, const char *file, int line)
 186 {
 187         PGM_FUNC(kputs)(file);
 188         PGM_FUNC(kprintf)(PSTR(":%d: Assertion failed: \""), line);
 189         PGM_FUNC(kputs)(cond);
 190         PGM_FUNC(kputs)(PSTR("\"\n"));
 191         return 1;
 192 }
 193
 194
 195 int PGM_FUNC(__invalid_ptr)(void *value, const char * PGM_ATTR name, const char * PGM_ATTR file, int line)
 196 {
 197         PGM_FUNC(kputs)(file);
 198         PGM_FUNC(kprintf)(PSTR(":%d: Invalid pointer: "), line);
 199         PGM_FUNC(kputs)(name);
 200         PGM_FUNC(kprintf)(PSTR(" = 0x%x\n"), value);
 201         return 1;
 202 }
 203
 204
 205 void __init_wall(long *wall, int size)
 206 {
 207         while(size--)
 208                 *wall++ = WALL_VALUE;
 209 }
 210
 211
 212 int __check_wall(long *wall, int size, const char *name, const char *file, int line)
 213 {
 214         int i, fail = 0;
 215
 216         for (i = 0; i < size; i++)
 217         {
 218                 if (wall[i] != WALL_VALUE)
 219                 {
 220                         kprintf("%s:%d: Wall broken: %s[%d] (0x%p) = 0x%lx\n",
 221                                 file, line, name, i, wall + i, wall[i]);
 222                         fail = 1;
 223                 }
 224         }
 225
 226         return fail;
 227 }
 228
 229
 230 /*!
 231  * Dump binary data in hex
 232  */
 233 void kdump(const void *_buf, size_t len)
 234 {
 235         const unsigned char *buf = (const unsigned char *)_buf;
 236
 237         while (len--)
 238                 kprintf("%02X", *buf++);
 239         kputs("\n");
 240 }
 241
 242 #endif /* _DEBUG */