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