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