debughwi.c

ARM入门的好帮手.包含了从简单到相对较复杂的程序.

/* -*-C-*-
 *
 * $Revision: 1.9.4.3 $
 *   $Author: rivimey $
 *     $Date: 1998/01/15 11:43:30 $
 *
 * Copyright (c) 1995 Advanced RISC Machines Limited
 * All Rights Reserved.
 *
 * debughwi.c: This file contains the target independant debug
 * handler functions for Angel.
 */
#include "angel.h"
#include "adp.h"
#include "channels.h"
#include "debug.h"
#include "debugos.h"
#include "endian.h"
#include "debughwi.h"
#include "logging.h"
#include "msgbuild.h"
#include "devconf.h"
#include "buffers.h"

int 
gendbg_unimplemented(p_Buffer * buffer, void *stateptr)
{
    IGNORE(buffer);
    IGNORE(stateptr);

    return -1;
}

static int 
gendbg_unrecognised(p_Buffer * buffer, void *stateptr)
{
    int reason, debugID, OSinfo1, OSinfo2;

    IGNORE(stateptr);

    LogInfo(LOG_DEBUGHWI, ( "gendbg_unrecognised\n"));

    unpack_message(BUFFERDATA(*buffer), "%w%w%w%w", &reason, &debugID, &OSinfo1,
                   &OSinfo2);

    return msgsend(CI_HADP, "%w%w%w%w%w", (ADP_HADPUnrecognised | TtoH),
                   debugID, OSinfo1, OSinfo2, reason);
}

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

/*
 * Information message handler functions
 */
static int 
gendbg_info(p_Buffer * buffer, void *stateptr)
{
    int subreason, err;

    subreason = PREAD(LE, BUFFERDATA(*buffer) + 16);
    subreason &= 0xFFFF;        /* Mask out channel information. */

    LogInfo(LOG_DEBUGHWI, ( "gendbg_info(subreason = %d)\n", subreason));


    /* Range check subreason code. */
    if (subreason < info_hfptr_max)
        err = info_hfptr[subreason] (buffer, stateptr);
    else
        err = -1;

    return err;
}

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

/*
 * Control message handler functions
 */
static int 
gendbg_ctrl(p_Buffer * buffer, void *stateptr)
{
    int subreason, err;

    subreason = PREAD(LE, (unsigned int *)(BUFFERDATA(*buffer) + 16));
    subreason &= 0xFFFF;        /* Mask out channel information. */
    
    LogInfo(LOG_DEBUGHWI, ( "gendbg_ctrl(subreason %d)\n", subreason));

    /* Range check subreason code. */
    if (subreason < ctrl_hfptr_max)
        err = ctrl_hfptr[subreason] (buffer, stateptr);
    else
        err = -1;

    return err;
}

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

/*
 * General debugging message handler functions
 */
static int 
gendbg_read(p_Buffer * buffer, void *stateptr)
{
    /* Reads an area of memory. */
    p_Buffer rbuff;
    int debugID, OSinfo1, OSinfo2;
    word address, nbytes;

    IGNORE(stateptr);

    unpack_message(BUFFERDATA(*buffer) + 4, "%w%w%w%w%w", &debugID, &OSinfo1,
                   &OSinfo2, &address, &nbytes);
    LogInfo(LOG_DEBUGHWI, ( "gendbg_read(address = 0x%x, nbytes = %d)\n", address, nbytes));

    rbuff = angel_ChannelAllocBuffer(Angel_ChanBuffSize);
    if (rbuff != NULL)
    {
        int count;
        word bytesread;
        word status = RDIError_Error;

        count = msgbuild(BUFFERDATA(rbuff), "%w%w%w%w%w%w", (ADP_Read | TtoH),
                         debugID, OSinfo1, OSinfo2, status, 0);

        status = angelOS_MemRead(OSinfo1, OSinfo2, address, nbytes,
                                 BUFFERDATA(rbuff) + count, &bytesread);

        /* Write status field to buffer. */
        PUT32LE(BUFFERDATA(rbuff) + 16, status);

        /* Write number of bytes not read into buffer. */
        PUT32LE(BUFFERDATA(rbuff) + 20, nbytes - bytesread);

        count += bytesread;
        
        angel_ChannelSend(CH_DEFAULT_DEV, CI_HADP, rbuff, count);
    }
    else
        LogError(LOG_DEBUGHWI, ( "ERROR: Couldn't allocate buffer in 'gendbg_read'.\n"));

    return 0;
}

static int 
gendbg_write(p_Buffer * buffer, void *stateptr)
{
    /* Writes an area of memory. */
    int reason, debugID, OSinfo1, OSinfo2, count;
    word address, nbytes;
    word byteswritten, status;

    IGNORE(stateptr);

    count = unpack_message(BUFFERDATA(*buffer), "%w%w%w%w%w%w", &reason,
                           &debugID, &OSinfo1, &OSinfo2, &address, &nbytes);
    
    LogInfo(LOG_DEBUGHWI, ( "gendbg_write(address = 0x%x, nbytes = %d)\n", address, nbytes));

    status = angelOS_MemWrite(OSinfo1, OSinfo2, address, nbytes,
                              BUFFERDATA(*buffer) + count, &byteswritten);

    /* We make sure we release the buffer here as it may be the long one */
    angel_ChannelReleaseBuffer(*buffer);
    *buffer = NULL;

    return msgsend(CI_HADP, "%w%w%w%w%w%w", (ADP_Write | TtoH),
                   debugID, OSinfo1, OSinfo2, status,
                   nbytes - byteswritten);
}

static int 
gendbg_cpread(p_Buffer * buffer, void *stateptr)
{
    /* Reads values from a co-processor. */
    p_Buffer rbuff;
    int debugID, OSinfo1, OSinfo2;
    byte cpnum;
    word mask;

    IGNORE(stateptr);

    unpack_message(BUFFERDATA(*buffer) + 4, "%w%w%w%b%w", &debugID, &OSinfo1,
                   &OSinfo2, &cpnum, &mask);
    LogInfo(LOG_DEBUGHWI, ( "gendbg_cpread(cpnum %d, mask 0x%x)\n", cpnum, mask));

    rbuff = angel_ChannelAllocBuffer(Angel_ChanBuffSize);
    if (rbuff != NULL)
    {
        int count;
        word status = RDIError_Error;
        word nbytes;

        count = msgbuild(BUFFERDATA(rbuff), "%w%w%w%w%w", (ADP_CPread | TtoH),
                         debugID, OSinfo1, OSinfo2, status);
        status = angelOS_CPRead(OSinfo1, OSinfo2, cpnum, mask,
                                (word *) (BUFFERDATA(rbuff) + count), &nbytes);

        /* Write status field to buffer. */
        PUT32LE(BUFFERDATA(rbuff) + 16, status);

        count += nbytes;
        angel_ChannelSend(CH_DEFAULT_DEV, CI_HADP, rbuff, count);
    }
    else
        LogError(LOG_DEBUGHWI, ( "ERROR: Couldn't allocate buffer in 'gendbg_cpread'.\n"));

    return 0;
}

static int 
gendbg_cpwrite(p_Buffer * buffer, void *stateptr)
{
    /* Writes values to a co-processor. */
    int reason, debugID, OSinfo1, OSinfo2, count;
    byte cpnum;
    word mask;
    word nbytes, status;

    IGNORE(stateptr);

    count = unpack_message(BUFFERDATA(*buffer), "%w%w%w%w%b%w", &reason,
                           &debugID, &OSinfo1, &OSinfo2, &cpnum, &mask);

    LogInfo(LOG_DEBUGHWI, ( "gendbg_cpwrite(cpnum %d, mask 0x%x)\n", cpnum, mask));

    status = angelOS_CPWrite(OSinfo1, OSinfo2, cpnum, mask,
                             (word *) (BUFFERDATA(*buffer) + count), &nbytes);

    return msgsend(CI_HADP, "%w%w%w%w%w", (ADP_CPwrite | TtoH),
                   debugID, OSinfo1, OSinfo2, status);
}

static int 
gendbg_cpuread(p_Buffer * buffer, void *stateptr)
{
    /* Reads values from the CPU. */
    p_Buffer rbuff;
    int debugID, OSinfo1, OSinfo2;
    word mask;
    byte mode;

    IGNORE(stateptr);

    LogInfo(LOG_DEBUGHWI, ( "gendbg_cpuread:\n"));
    unpack_message(BUFFERDATA(*buffer) + 4, "%w%w%w%b%w", &debugID, &OSinfo1,
                   &OSinfo2, &mode, &mask);

    rbuff = angel_ChannelAllocBuffer(Angel_ChanBuffSize);
    if (rbuff != NULL)
    {
        int count, i;
        word status = RDIError_Error;

        count = msgbuild(BUFFERDATA(rbuff), "%w%w%w%w%w", (ADP_CPUread | TtoH),
                         debugID, OSinfo1, OSinfo2, status);
        status = angelOS_CPURead(OSinfo1, OSinfo2, mode, mask,
                                 BUFFERDATA(rbuff) + count);

        LogInfo(LOG_DEBUGHWI, ( "CPU read mask %x mode %x status = %x\n", mask, mode, status));

        /*
         * Increment count by the number of registers we have.
         */
        for (i = 0; i < 20; i++)
            if (mask & (1L << i))
                count += 4;

        /* Write status to buffer. */
        PUT32LE(BUFFERDATA(rbuff) + 16, status);

        angel_ChannelSend(CH_DEFAULT_DEV, CI_HADP, rbuff, count);
    }
    else
        LogError(LOG_DEBUGHWI, ( "ERROR: Couldn't allocate buffer in 'gendbg_cpuread'.\n"));

    return 0;
}

static int 
gendbg_cpuwrite(p_Buffer * buffer, void *stateptr)
{
    /* Writes values to the CPU. */
    int reason, debugID, OSinfo1, OSinfo2;
    int count;
    byte mode;
    word mask;
    word status;

    IGNORE(stateptr);

    LogInfo(LOG_DEBUGHWI, ( "gendbg_cpuwrite:\n"));
    count = unpack_message(BUFFERDATA(*buffer), "%w%w%w%w%b%w", &reason,
                           &debugID, &OSinfo1, &OSinfo2, &mode, &mask);

    LogInfo(LOG_DEBUGHWI, ( "CPU write mask %x mode %x\n", mask, mode));

    status = angelOS_CPUWrite(OSinfo1, OSinfo2, mode, mask,
                              BUFFERDATA(*buffer) + count);

    LogInfo(LOG_DEBUGHWI, ( "status = %x\n", status));

    return msgsend(CI_HADP, "%w%w%w%w%w%w", (ADP_CPUwrite | TtoH),
                   debugID, OSinfo1, OSinfo2, status);
}

static int 
gendbg_setbreak(p_Buffer * buffer, void *stateptr)
{
    /* Sets a breakpoint. */
    int reason, debugID, OSinfo1, OSinfo2;
    int count;
    struct SetPointValue spv;
    struct PointValueReturn pvr;
    word status;

    IGNORE(stateptr);

    LogInfo(LOG_DEBUGHWI, ( "DEBUG: Entered function gendbg_setbreak.\n"));
    count = unpack_message(BUFFERDATA(*buffer), "%w%w%w%w%w%b", &reason,
                           &debugID, &OSinfo1, &OSinfo2, &spv.pointAddress,
                           &spv.pointType);

    if ((spv.pointType & 0x7) > 4)
        unpack_message(BUFFERDATA(*buffer) + count, "%w", &spv.pointBound);

    status = angelOS_SetBreak(OSinfo1, OSinfo2, &spv, &pvr);

    return msgsend(CI_HADP, "%w%w%w%w%w%w%w%w",
                   (ADP_SetBreak | TtoH), debugID, OSinfo1, OSinfo2, status,
                   pvr.pointHandle, pvr.pointRaddress, pvr.pointRbound);
}

static int 
gendbg_clearbreak(p_Buffer * buffer, void *stateptr)
{
    /* Clears a breakpoint. */
    int reason, debugID, OSinfo1, OSinfo2;
    word handle;
    word status;

    IGNORE(stateptr);

    LogInfo(LOG_DEBUGHWI, ( "gendbg_clearbreak:\n"));
    unpack_message(BUFFERDATA(*buffer), "%w%w%w%w%w", &reason, &debugID,
                   &OSinfo1, &OSinfo2, &handle);

    status = angelOS_ClearBreak(OSinfo1, OSinfo2, handle);

    return msgsend(CI_HADP, "%w%w%w%w%w", (ADP_ClearBreak | TtoH),
                   debugID, OSinfo1, OSinfo2, status);
}

static int 
gendbg_setwatch(p_Buffer * buffer, void *stateptr)
{
    /* Sets a watch point. */
    int reason, debugID, OSinfo1, OSinfo2;
    int count;
    word status;
    struct SetPointValue spv;
    struct PointValueReturn pvr;

    IGNORE(stateptr);

    LogInfo(LOG_DEBUGHWI, ( "gendbg_setwatch:\n"));