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