firmware/debug.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2002 by Linus Nielsen Feltzing
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21
  22 #include <string.h>
  23 #include <stdio.h>
  24 #include <stdarg.h>
  25 #include "config.h"
  26 #include "cpu.h"
  27 #ifdef HAVE_GDB_API
  28 #include "gdb_api.h"
  29 #endif
  30
  31 #ifdef DEBUG
  32 static char debugmembuf[200];
  33 #if CONFIG_CPU == SH7034
  34 static char debugbuf[400];
  35 #endif
  36 #endif
  37
  38 #include "kernel.h"
  39 #include "system.h"
  40 #include "debug.h"
  41
  42 #ifdef DEBUG
  43 #if CONFIG_CPU == SH7034 /* these are still very SH-oriented */
  44 void debug_init(void)
  45 {
  46     /* Clear it all! */
  47     SSR1 &= ~(SCI_RDRF | SCI_ORER | SCI_PER | SCI_FER);
  48
  49     /* This enables the serial Rx interrupt, to be able to exit into the
  50        debugger when you hit CTRL-C */
  51     SCR1 |= 0x40;
  52     SCR1 &= ~0x80;
  53     IPRE |= 0xf000; /* Set to highest priority */
  54 }
  55
  56 static int debug_tx_ready(void)
  57 {
  58     return (SSR1 & SCI_TDRE);
  59 }
  60
  61 static void debug_tx_char(char ch)
  62 {
  63     while (!debug_tx_ready())
  64     {
  65         ;
  66     }
  67
  68     /*
  69      * Write data into TDR and clear TDRE
  70      */
  71     TDR1 = ch;
  72     SSR1 &= ~SCI_TDRE;
  73 }
  74
  75 static void debug_handle_error(char ssr)
  76 {
  77     (void)ssr;
  78     SSR1 &= ~(SCI_ORER | SCI_PER | SCI_FER);
  79 }
  80
  81 static int debug_rx_ready(void)
  82 {
  83    char ssr;
  84
  85    ssr = SSR1 & ( SCI_PER | SCI_FER | SCI_ORER );
  86    if ( ssr )
  87       debug_handle_error ( ssr );
  88    return SSR1 & SCI_RDRF;
  89 }
  90
  91 static char debug_rx_char(void)
  92 {
  93    char ch;
  94    char ssr;
  95
  96    while (!debug_rx_ready())
  97    {
  98       ;
  99    }
 100
 101    ch = RDR1;
 102    SSR1 &= ~SCI_RDRF;
 103
 104    ssr = SSR1 & (SCI_PER | SCI_FER | SCI_ORER);
 105
 106    if (ssr)
 107       debug_handle_error (ssr);
 108
 109    return ch;
 110 }
 111
 112 static const char hexchars[] = "0123456789abcdef";
 113
 114 static char highhex(int  x)
 115 {
 116    return hexchars[(x >> 4) & 0xf];
 117 }
 118
 119 static char lowhex(int  x)
 120 {
 121    return hexchars[x & 0xf];
 122 }
 123
 124 static void putpacket (const char *buffer)
 125 {
 126     register  int checksum;
 127
 128     const char *src = buffer;
 129
 130    /* Special debug hack. Shut off the Rx IRQ during I/O to prevent the debug
 131       stub from interrupting the message */
 132     SCR1 &= ~0x40;
 133
 134     debug_tx_char ('$');
 135     checksum = 0;
 136
 137     while (*src)
 138     {
 139         int runlen;
 140
 141         /* Do run length encoding */
 142         for (runlen = 0; runlen < 100; runlen ++)
 143         {
 144             if (src[0] != src[runlen] || runlen == 99)
 145             {
 146                 if (runlen > 3)
 147                 {
 148                     int encode;
 149                     /* Got a useful amount */
 150                     debug_tx_char (*src);
 151                     checksum += *src;
 152                     debug_tx_char ('*');
 153                     checksum += '*';
 154                     checksum += (encode = runlen + ' ' - 4);
 155                     debug_tx_char (encode);
 156                     src += runlen;
 157                 }
 158                 else
 159                 {
 160                     debug_tx_char (*src);
 161                     checksum += *src;
 162                     src++;
 163                 }
 164                 break;
 165             }
 166         }
 167     }
 168
 169
 170     debug_tx_char ('#');
 171     debug_tx_char (highhex(checksum));
 172     debug_tx_char (lowhex(checksum));
 173
 174     /* Wait for the '+' */
 175     debug_rx_char();
 176
 177     /* Special debug hack. Enable the IRQ again */
 178     SCR1 |= 0x40;
 179 }
 180
 181
 182 /* convert the memory, pointed to by mem into hex, placing result in buf */
 183 /* return a pointer to the last char put in buf (null) */
 184 static char *mem2hex (const char *mem, char *buf, int count)
 185 {
 186     int i;
 187     int ch;
 188     for (i = 0; i < count; i++)
 189     {
 190         ch = *mem++;
 191         *buf++ = highhex (ch);
 192         *buf++ = lowhex (ch);
 193     }
 194     *buf = 0;
 195     return (buf);
 196 }
 197
 198 static void debug(const char *msg)
 199 {
 200     debugbuf[0] = 'O';
 201
 202     mem2hex(msg, &debugbuf[1], strlen(msg));
 203     putpacket(debugbuf);
 204 }
 205 #elif defined(HAVE_GDB_API)
 206 static void *get_api_function(int n)
 207 {
 208     struct gdb_api *api = (struct gdb_api *)GDB_API_ADDRESS;
 209     if (api->magic == GDB_API_MAGIC)
 210         return api->func[n];
 211     else
 212         return NULL;
 213 }
 214
 215 void breakpoint(void)
 216 {
 217     void (*f)(void) = get_api_function(0);
 218     if (f) (*f)();
 219 }
 220
 221 static void debug(char *msg)
 222 {
 223     void (*f)(char *) = get_api_function(1);
 224     if (f) (*f)(msg);
 225 }
 226
 227 void debug_init(void)
 228 {
 229 }
 230 #else /* !SH7034 && !HAVE_GDB_API */
 231 void debug_init(void)
 232 {
 233 }
 234
 235 static inline void debug(char *msg)
 236 {
 237     (void)msg;
 238 }
 239 #endif
 240
 241 #endif /* end of DEBUG section */
 242
 243 #ifdef __GNUC__
 244 void debugf(const char *fmt, ...)
 245 #endif
 246 {
 247 #ifdef DEBUG
 248     va_list ap;
 249
 250     va_start(ap, fmt);
 251     vsnprintf(debugmembuf, sizeof(debugmembuf), fmt, ap);
 252     va_end(ap);
 253     debug(debugmembuf);
 254 #else
 255     (void)fmt;
 256 #endif
 257 }
 258