hbrktab.c

motorola 针对coldfire 5275 评估板的Dbug bootloader源程序

/*
 * File:        hbrktab.c
 * Purpose:     Hardware Breakpoint table management routines.
 *
 * Notes:
 *
 */

#include "src/include/dbug.h"
#include "src/uif/uif.h"

/********************************************************************/

/*
 * Data structure used to maintain break points and trace
 * information.
 */
typedef struct
{
    ADDRESS     address;
    int         valid;  /* and type info */
} HBRKENT;

HBRKENT hbrktab[UIF_MAX_HBRKPTS];

/********************************************************************/
static void
hbreakpoint_clear (int index)
{
    if ((index >= 0) && (index < UIF_MAX_HBRKPTS))
    {
        hbrktab[index].address = NULL;
        hbrktab[index].valid = BKPT_NONE;
        switch(index){
            case 0:
                mpc5xx_wr_cmpa(0x00000000); /*clear address of hardware breakpoint*/
                mpc5xx_wr_ictrl(mpc5xx_rd_ictrl() & 0x1FF3F7FF); /*turn off compare type of CMPA*/
                printf("Cleared Hardware Breakpoint A\n");
                break;
            case 1:
                mpc5xx_wr_cmpb(0x00000000); /*clear address of hardware breakpoint*/
                mpc5xx_wr_ictrl(mpc5xx_rd_ictrl() & 0xEFFDFBFF); /*turn off compare type of CMPB*/
                printf("Cleared Hardware Breakpoint Bn");
                break;
            case 2:
                mpc5xx_wr_cmpc(0x00000000); /*clear address of hardware breakpoint*/
                mpc5xx_wr_ictrl(mpc5xx_rd_ictrl() & 0xFDFF7DFF); /*turn off compare type of CMPC*/
                printf("Cleared Hardware Breakpoint C\n");
                break;
            case 3:
                mpc5xx_wr_cmpd(0x00000000); /*clear address of hardware breakpoint*/
                mpc5xx_wr_ictrl(mpc5xx_rd_ictrl() & 0xFFBFDEFF); /*turn off compare type of CMPD*/
                printf("Cleared Hardware Breakpoint D\n");
                break;
        }                   
        
    }
}

/********************************************************************/
void
hbreakpoint_init (void)
{
    int index;

    for (index = 0; index < UIF_MAX_HBRKPTS; index++)
        hbreakpoint_clear(index);
}

/********************************************************************/
static int
hbreakpoint_find (ADDRESS address)
{
    /*
     * This function searches the breakpoint table for `address'.
     * If it is found, then an index into the table is returned,
     * otherwise -1 is returned.
     */
    int index;
    for (index = 0; index < UIF_MAX_HBRKPTS; index++)
    {
        if (hbrktab[index].address == address)
            return index;
    }
    return -1;
}

/********************************************************************/
static void
hbreakpoint_display_info (int index)
{
    if ((index >= 0) && (index < UIF_MAX_HBRKPTS))
    {
        printf("%08X\n",hbrktab[index].address);
    }
}

/********************************************************************/
static void
hbreakpoint_display (int argc, char **argv)
{
    ADDRESS address;
    int i,j;

    (void)argc;

    printf(" Address \n");
    /* break points are listed one by one starting at argv[1]  */
    /* if no break points listed, argv[1] == NULL, display all */
    if (argv[1] == NULL)
    {
        /* display all */
        for (i = 0; i < UIF_MAX_HBRKPTS; i++)
        {
            if (hbrktab[i].valid)
                hbreakpoint_display_info(i);
        }
    }
    else
    {
        i = 1;
        while (argv[i] != NULL)
        {
            address = (ADDRESS)strtoul(argv[i],NULL,16);
            for (j = 0; j < UIF_MAX_HBRKPTS; j++)
            {
                if (hbrktab[j].address == address)
                    hbreakpoint_display_info(j);
            }
            i++;
        }
    }
}

/********************************************************************/
void
hbreakpoint_remove (ADDRESS address)
{
    int index;
    if ((index = hbreakpoint_find(address)) != -1)
    {
        hbreakpoint_clear(index);
    }
}

/********************************************************************/
void
hbreakpoint_add (ADDRESS address, int type)
{
    int i;
    /* first check to make sure not already in table */
    if (hbreakpoint_find(address) != -1)
        return;
    /*
     * Test for valid breakpoint address
     */
    if (!cpu_valid_insn_addr(address))
    {
        printf("Error:  Invalid breakpoint address!\n");
        return;
    }
    /* FIX THIS to check for overlap of dBUG code
     * Test for read-only memory
     */
     
    /* find an open slot and put it in table*/
    for (i = 0; i < UIF_MAX_HBRKPTS; i++)
    {
        if (!hbrktab[i].valid)
        break;
    }
    if (i == UIF_MAX_HBRKPTS)
    {
        printf("Hardware Break table full.\n");
        return;
    }
    else
    {
    /*program the CMP and ICTRL registers with the hardware breakpoint*/
        hbrktab[i].address = address;
        hbrktab[i].valid = type;
        //hbreakpoint_install (address);
        switch(i){
            case 0:
                mpc5xx_wr_cmpa(address); /*set address of hardware breakpoint*/
                mpc5xx_wr_ictrl(mpc5xx_rd_ictrl() | 0x80080800); /*set compare type of CMPA to "equal"*/
                printf("Added Hardware Breakpoint at %08X\n",address);
                break;
            case 1:
                mpc5xx_wr_cmpb(address); /*set address of hardware breakpoint*/
                mpc5xx_wr_ictrl(mpc5xx_rd_ictrl() | 0x10020400); /*set compare type of CMPB to "equal"*/
                printf("Added Hardware Breakpoint at %08X\n",address);
                break;
            case 2:
                mpc5xx_wr_cmpc(address); /*set address of hardware breakpoint*/
                mpc5xx_wr_ictrl(mpc5xx_rd_ictrl() | 0x02008200); /*set compare type of CMPC to "equal"*/
                printf("Added Hardware Breakpoint at %08X\n",address);
                break;
            case 3:
                mpc5xx_wr_cmpd(address); /*set address of hardware breakpoint*/
                mpc5xx_wr_ictrl(mpc5xx_rd_ictrl() | 0x00402100); /*set compare type of CMPD to "equal"*/
                printf("Added Hardware Breakpoint at %08X\n",address);
                break;
            default:
                printf("I'm lost");
                break;
        }                                               
    }
            
}

/********************************************************************/
int
hbreakpoint_install (ADDRESS address)
{
    /*
     * This function inserts the hardare breakpoints in user code.  Extensive
     * checking of breakpoints is done before entry into the table, so
     * all breakpoints in table should be OK to just implant.  If
     * a breakpoint with the same `address' is found, it is not
     * inserted, and TRUE is returned, otherwise FALSE.
     * This routine is generally called right before executing user
     * code.
     */
    int index, found = FALSE;
    for (index = 0; index < UIF_MAX_HBRKPTS; index++)
    {
        if (hbrktab[index].valid)
        {
                switch(index){
                    case 0:
                        mpc5xx_wr_cmpa(address); /*set address of hardware breakpoint*/
                        mpc5xx_wr_ictrl(mpc5xx_rd_ictrl() | 0x80080800); /*set compare type of CMPA to "equal"*/
                        break;
                    case 1:
                        mpc5xx_wr_cmpb(address); /*set address of hardware breakpoint*/
                        mpc5xx_wr_ictrl(mpc5xx_rd_ictrl() | 0x10020800); /*set compare type of CMPB to "equal"*/
                        break;
                    case 2:
                        mpc5xx_wr_cmpc(address); /*set address of hardware breakpoint*/
                        mpc5xx_wr_ictrl(mpc5xx_rd_ictrl() | 0x02008200); /*set compare type of CMPC to "equal"*/
                        break;
                    case 3:
                        mpc5xx_wr_cmpd(address); /*set address of hardware breakpoint*/
                        mpc5xx_wr_ictrl(mpc5xx_rd_ictrl() | 0x00402100); /*set compare type of CMPD to "equal"*/
                        break;
                    default:
                        printf("I'm lost");
                        break;
                }                                               
        }
    }
    return found;
}

/********************************************************************/
void
mpc5xx_hbr (int argc, char **argv)
{
    int i, success;
    ADDRESS hbrkpnt;

    hbrkpnt = (ADDRESS)-1;  /* improbable breakpoint address */
    if (argc == 1)
    {
        /* display all break points */
        hbreakpoint_display(argc,argv);
        return ;
    }

    /* parse through arguments */
    i = 1;
    while (i < argc)
    {
        if (argv[i][0] != '-')
        {
            /* must be a breakpoint address */
            hbrkpnt = get_value(argv[i],&success,16);
            if (success == 0)
            {
                printf("Error:  Bad Value:  %s\n",argv[i]);
                return;
            }
            /* add breakpont, if not already there */
            hbreakpoint_add(hbrkpnt, BKPT_PERM);
            i++;
        }
        else
        {
            /* must be an option of some sort */
            switch (argv[i][1])
            {
                case 'r':
                case 'R':
                    /* remove break points */
                    if (hbrkpnt == (ADDRESS)-1)
                    {
                        /* check for address given after '-r' */
                        if (argv[i+1] == NULL)
                            hbreakpoint_init();
                        else
                        {
                            while (++i < argc)
                            {
                                hbrkpnt = get_value(argv[i],&success,16);
                                if (success == 0)
                                    hbreakpoint_init();
                                else
                                    hbreakpoint_remove(hbrkpnt);
                            }
                        }
                    }
                    else
                    {
                        hbreakpoint_remove(hbrkpnt);
                    }
                    break;
                default:
                    printf("Error:  Invalid option:  %s\n",argv[1]);
                    break;
            }
            i++;
        }
    }
}

/********************************************************************/