logterm.c

AT91所有开发板的资料 AT91所有开发板的资料

 *   Purpose: UnPause Angel; allow it to progress after a pause.
 *
 *  Pre-conditions: none.
 *
 *    Params:
 *       Input: argc, argv - "main" argc/argv pair containing args. argv[0]
 *                           is name of command (i.e. "go").
 *
 *   Returns: 0.
 */
volatile static int log_paused = FALSE;

static int log_go(int argc, char **argv)
{
    UNUSED(argc);
    UNUSED(argv);

    if (log_paused)
        log_paused = FALSE;
    else
        log_emitstr("go: not paused\n");
    log_deferredprompt = TRUE;    
    return 0;
}

/*
 *  Function: log_restart
 *   Purpose: Reboot Angel.
 *
 *  Pre-conditions: none.
 *
 *    Params:
 *       Input: argc, argv - "main" argc/argv pair containing args. argv[0]
 *                           is name of command (i.e. "go").
 *
 *   Returns: 0.
 */
static int log_restart(int argc, char **argv)
{
    void (*addr)() = 0;
    int ok = 0;
    extern void (*__rom)();
    
    if (log_paused)
        log_paused = FALSE;

    if (argc == 1)
    {
        addr = __rom;
        ok = 1;
    }
    else
    {
        char *ep;
        addr = (void (*)())stoi(argv[1], &ep);
        
        if (ep == argv[1])
            log_emitstr("Invalid restart address\n");
        else
            ok = 1;
    }

    if (ok)
    {
        log_emitstr("\nRebooting...\n");
        addr();
    }
    
    return 0;
}

/*
 *  Function: log_pause
 *   Purpose: Pause Angel; don't allow it to progress. Terminated by 'go'
 *
 *  Pre-conditions: none.
 *
 *    Params:
 *       Input: argc, argv - "main" argc/argv pair containing args. argv[0]
 *                           is name of command (i.e. "pause").
 *
 *   Returns: 0.
 */

int log_pause(int argc, char **argv)
{
    int state, intStatus;

    UNUSED(argc);
    UNUSED(argv);
    
    if (log_paused)
    {
        log_emitstr("pause: Already paused\n");
        return 1;
    }

    state = Angel_DisableInterruptsFromSVC();
    log_paused = TRUE;
    while(log_paused)
    {
        unsigned char ch;

        intStatus = LOG_GET_STATUS(LOGTERM_PORT) ;
        if ( LOG_RX_DATA(intStatus) ) {
            ch = LOG_GET_CHAR(LOGTERM_PORT);
            log_processchar(ch, 0);        
        }
    }
    Angel_RestoreInterruptsFromSVC(state);
    
    return 0;
}

/*
 *  Function: log_echo
 *   Purpose: Debugging aid.
 *
 *  Pre-conditions: none.
 *
 *    Params:
 *       Input: argc, argv - "main" argc/argv pair containing args. argv[0]
 *                           is name of command (i.e. "ver").
 *
 *   Returns: 0.
 */

static int log_echo(int argc, char **argv)
{
    int i;
    for(i = 0; i < argc; i++)
    {
        log_emitch('\"');
        log_emitstr(argv[i]);
        log_emitch('\"');
        log_emitch(' ');
    }
    log_emitch('\n');
    return 0;
}

int buf_itoh(char *buf, unsigned long uval, int width, int padzero);

static void dump_buffer(unsigned int width, char *buffer, unsigned int length)
{
    unsigned int i, j ;
    char b[128] ;
    char *p ;

    if (width == 4)
    {
        for (i = 0; i < length; i += 16)
        {
            p = b;
            p += buf_itoh(p, (unsigned int)&buffer[i], 8, 1);
            *p++ = ':';
            *p++ = ' ';

            for (j = 0; j < 16 && (i + j) < length; j += 4)
            {
                unsigned int *ptr ;
                ptr = (unsigned int *)&buffer[i + j] ;
                p += buf_itoh(p, *ptr, 8, 1);
                *p++ = ' ';
            }

            for (; j < 16; j += 4)
            {
                *p++ = ' ';
                *p++ = ' ';
                *p++ = ' ';
                *p++ = ' ';
                *p++ = ' ';
                *p++ = ' ';
                *p++ = ' ';
                *p++ = ' ';
                *p++ = ' ';
            }

            for (j = 0; j < 16 && (i + j) < length; j++)
            {
                unsigned char c = buffer[i + j];

                *p++ = (c >= 0x20 && c < 0x7F) ? c : '.';
            }
            *p++ = '\0';
            log_printf("%s\n", b);
        }
    }
    else
    {
        /* Default width to 1 */
        for (i = 0; i < length; i +=16)
        {
            p = b;
            p += buf_itoh(p, i, 8, 1);
            *p++ = ':';
            *p++ = ' ';

            for (j = 0; j < 16 && (i + j) < length; j++)
            {
                p += buf_itoh(p, buffer[i + j] & 0xff, 2, 1);
                *p++ = ' ';
            }
            for (; j <= 16; j++)
            {
                *p++ = ' ';
                *p++ = ' ';
                *p++ = ' ';
            }
            for (j = 0; j < 16 && (i + j) < length; j++)
            {
            unsigned char c = buffer[i + j];

                *p++ = (c >= 0x20 && c < 0x7F) ? c : '.';
            }
            *p++ = '\0';
            log_printf("%s\n", b);
        }
    }
}

/*
 *  Function: log_dump
 *   Purpose: Print the contents of memory.
 *
 *  Pre-conditions: none.
 *
 *    Params:
 *       Input: argc, argv - "main" argc/argv pair containing args. argv[0]
 *                           is name of command (i.e. "ver").
 *
 *   Returns: 0.
 */

static int log_dump(int argc, char **argv)
{
    int addr1 = 0, addr2 = 0, len = 0;
    char *e;
    int width = 4;
    int i = 1;

    if (argc == 1 || argc > 4)
    {
        log_emitstr("dump: [b|w] addr1 [addr2 | +nbytes]\n");
        log_emitstr(" [b|w]  - byte or word wide (default word)\n");
        return 0;
    }

    if (argv[1][0] == 'b')
    {
        width = 1;
        i++;
    }
    else if (argv[1][0] == 'w')
    {
        width = 4;
        i++;
    }

    if (i < argc)
    {
        addr1 = stoi(argv[i++], &e);
        addr2 = addr1 + 64;
        len = 64;
    }

    if (i < argc)
    {
        if (argv[i][0] == '+')
        {
            len = stoi(argv[i]+1, &e);
            addr2 = addr1 + len;
        }
        else
        {
            addr2 = stoi(argv[i], &e);
            len = (addr2 - addr1) + 1;
        }
    }

    logterm_PreWarn(WL_INFO);

    log_printf("Memory from %lx to %lx\n", addr1, addr2);

    dump_buffer(width, (char*)addr1, len);

    logterm_PostWarn(0);

    return 0;
}
/*
 *  Function: log_list
 *   Purpose: Disassemble the contents of memory.
 *
 *  Pre-conditions: none.
 *
 *    Params:
 *       Input: argc, argv - "main" argc/argv pair containing args. argv[0]
 *                           is name of command (i.e. "ver").
 *
 *   Returns: 0.
 */

#ifdef HAVE_DISASS
static char* list_discb(dis_cb_type type, int32 offset, unsigned32 address,
                     int width, void *cb_arg, char *buffer)
{
    return buffer;
}

static int log_list(int argc, char **argv)
{
    unsigned int addr1 = 0, addr2 = 0;
    char *e;
    unsigned int *addr, instr;
    static char b[64];

    if (argc == 1 || argc > 3)
    {
        log_emitstr("list: addr1 [addr2 | +nbytes]\n");
        return 0;
    }

    if (argc == 2)
    {
        addr1 = stoi(argv[1], &e);
        addr2 = addr1 + 64;
    }
    else if (argc == 3)
    {
        addr1 = stoi(argv[1], &e);
        if (argv[2][0] == '+')
        {
            unsigned int len = 0;
            
            len = stoi(argv[2]+1, &e);
            addr2 = addr1 + len;
        }
        else
        {
            addr2 = stoi(argv[2], &e);
        }
    }
    
    logterm_PreWarn(WL_INFO);
    log_printf("Disassembly from %08lx to %08lx:\n", addr1, addr2);
    
    for(addr = (unsigned int *)addr1; addr < (unsigned int *)addr2; addr++)
    {
        instr = *addr;
        disass(instr, (unsigned int)addr, b, NULL, list_discb);
        log_printf("%08x: %08x  %s\n", addr, instr, b);
    }
    logterm_PostWarn(0);
    
    return 0;
}
#endif


/*
 *  Function: log_ver
 *   Purpose: Version command routine. Prints the Angel banner again.
 *
 *  Pre-conditions: none.
 *
 *    Params:
 *       Input: argc, argv - "main" argc/argv pair containing args. argv[0]
 *                           is name of command (i.e. "ver").
 *
 *   Returns: 0.
 */

static int log_ver(int argc, char **argv)
{
    UNUSED(argc);
    UNUSED(argv);
    
    log_emitstr(ANGEL_BANNER);
    return 0;
}

/*
 *  Function: log_format
 *   Purpose: Set the per-message info
 *
 *  Pre-conditions: none.
 *
 *    Params:
 *       Input: argc, argv - "main" argc/argv pair containing args. argv[0]
 *                           is name of command (i.e. "ver").
 *
 *   Returns: 0.
 */

static int log_format(int argc, char **argv)
{
    if (argc == 1)
    {
        log_emitstr("format: \"");
        log_emitstr(log_get_format_string());
        log_emitstr("\"\n");
    }
    else
    {
        if (argc == 2)
        {
            log_set_format_string(argv[1]);
        }
        else
        {
            log_emitstr("format: too many args\n");
        }
    }
    return 0;
}

/*
 *  Function: log_help
 *   Purpose: Help command routine. Given a single arg, prints the help
 *            string for that command, if it exists.
 *
 *            With no args, prints all help available.
 *
 *  Pre-conditions: none.
 *
 *    Params:
 *       Input: argc, argv - "main" argc/argv pair containing args. argv[0]
 *                           is name of command (i.e. "help").
 *
 *   Returns: 0 if help found, 1 otherwise.
 */

static int log_help(int argc, char **argv)
{
    int i;

    if (argc > 1)
    {
        for (i = 0; i < log_ncmds; i++)
        {
            switch(__rt_strcmp(argv[1], log_cmds[i].str))
            {
                case 0: /* match ! */
                    log_emitstr(log_cmds[i].desc);
                    log_emitstr(log_cmds[i].helpstr);
                    return 0;

                case -1: /* no match found */
                    log_emitstr("No help found?\n");
                    return 1;
            }
        }
    }
    else
    {
        log_emitstr("Help Available:\n");
        for (i = 0; i < log_ncmds; i++)
        {
            log_emitstr(log_cmds[i].str);
            log_emitstr(" - ");
            log_emitstr(log_cmds[i].desc);
        }
    }
    return 0;
}


/*
 *  Function: log_trace
 *   Purpose: The trace action. trace syntax is:
 *       trace <on>|<off>    switch real-time tracing on or off
 *       trace <lines>       show <lines> worth of previous trace history
 *       trace               show currently traced modules
 *       trace <names>       change traced modules; <names> is space separated
 *                           list, with '-' before items to be removed. 'all'
 *                           can be used to specify all modules (so '-all'
 *                           means none).
 * 
 *  Pre-conditions: none.
 *
 *    Params:
 *       Input: argc, argv - "main" argc/argv pair containing args. argv[0]
 *                           is name of command (i.e. "trace").
 *
 *   Returns: 0
 */

static int log_trace(int argc, char **argv)
{
    int i, rem, n;
    char *p;

    if (argc == 1) /* no args */
    {
        n = log_get_num_ids();
        log_emitstr("trace: ");
        for(i = 0; i < n; i++)
        {
            if (log_get_log_id((log_id)i))
            {
                log_emitstr(log_tracename((log_id)i));
                log_emitch(' ');
            }
        }
        log_emitch('\n');
    }
    else if (argc >= 2) /* at least one arg */
    {
        if (argv[1][0] >= '0' && argv[1][0] <= '9')
        {
            int lines;
            char *ep;
            lines = stoi(argv[1], &ep);
            
	    log_emitstr("trace history:\n");

            if (/* ep > argv[1] && */ lines > 0 && lines < 10000)
            {
                /*
                 * don't want current and old output mixed together, do we?
                 */
                log_output(FALSE);
                log_showitems(&savebuf, lines); 
                log_output(TRUE);
            } 
            else 
                log_emitstr("trace: Bad number.\n"); 
        } 
        else if (__rt_strcmp(argv[1], "on") == 0)
        {
            log_emitstr("trace: on (was: "); 
            log_emitstr(log_tracing ? "on)\n" : "off)\n"); 
            log_tracing = TRUE;
        }
        else if (__rt_strcmp(argv[1], "off") == 0)
        {
            log_emitstr("trace: off (was: "); 
            log_emitstr(log_tracing ? "on)\n" : "off)\n"); 
            log_tracing = FALSE;
        }
        else
        {
            for(i = 1; i < argc; i++)
            {
                log_id id;

                if (argv[i][0] == '-')
                    rem = TRUE, p = argv[i]+1;
                else if (argv[i][0] == '+')
                    rem = FALSE, p = argv[i]+1;
                else
                    rem = FALSE, p = argv[i];

                id = log_tracebit(p);
                if (id != 0)
                {
                    log_set_log_id(id, !rem);
                }
                else
                {
                    log_emitstr("trace: unknown module ");
                    log_emitstr(p);
                    log_emitch('\n');
                }
            }
        }
    }
    return 0;
}


/*
 *  Function: log_RegblockName
 *   Purpose: The trace action. trace syntax is:
 *       task             show current task stats
 *       task <number>    show <number> prior task switches
 * 
 *  Pre-conditions: none.
 *
 *    Params:
 *       Input: argc, argv - "main" argc/argv pair containing args. argv[0]
 *                           is name of command (i.e. "trace").
 *
 *   Returns: 0
 */
struct angel_TaskLog
{
    int count;
    int id;
    angel_TaskQueueItem* taskblock;
    angel_RegBlock *regblock;
    int cur_CPSR;
    int cur_SP;
    int rb_PC;
    int rb_CPSR;
    int rb_SP;
    int rb_r0;
};