/*************************************************************************
 *
 *  File: iotestram.c
 *
 *  $Header: /root/leakn64/depot/rf/sw/n64os20l/iosim/src/iotestram.c,v 1.2 2002/05/30 05:52:50 whs Exp $
 *
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdio.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#ifdef __sgi__
	#include <bstring.h>
#endif
#include <wait.h>

#include "trace.h"
#include "iomap.h"
#include "iotest.h"
#include "simipc.h"
#include "verify.h"

#include "gbi.h"

/***********************************************************************
 * Constants
 */
#define RDP_DL_TEST_BASE	10
#define START_REG_MSK           0x00ffffff
#define END_REG_MSK             0x00ffffff

#define HIDDEN_FACTOR           8
#define MAIN_MEMORY_SIZE        0x200000
#define HIDDEN_MEMORY_SIZE      (MAIN_MEMORY_SIZE/HIDDEN_FACTOR)
#define TOTAL_MEMORY_SIZE       (MAIN_MEMORY_SIZE + HIDDEN_MEMORY_SIZE)

/*
 * Global defines for alignment size (default is 8-byte alignment)
 */
#define ALIGN_2B          2       /*  2 bytes =  16-bit alignment */
#define ALIGN_4B          4       /*  4 bytes =  32-bit alignment */
#define ALIGN_8B          8       /*  8 bytes =  64-bit alignment */
#define ALIGN_16B         16      /* 16 bytes = 128-bit alignment */
#define ALIGN_32B         32      /* 32 bytes = 256-bit alignment */


/***************************************
 *
 * Macro definitions
 *
 */
/* Perform alignment on input 's' */
#define ALIGN(s, align)		(((unsigned int)(s) + (align-1)) & ~(align-1))
#define IS_ALIGN(s, align)	(((unsigned int)(s) & (align-1)) == 0)


/***********************************************************************
 * Local function prototypes
 */
static int LoadRaw2Mem(char *, unsigned int, int);
static int LoadDL2Mem(char *);
static int UnloadRaw2File(char *, unsigned int, int);
static int UnloadDL2File(char *);
static int MemAccess(int, unsigned int , unsigned int , char *);

#define ReadMem(a,s,b)	MemAccess(OP_READ,  a, s, b)
#define WriteMem(a,s,b)	MemAccess(OP_WRITE, a, s, b)


/***********************************************************************
 * Global definitions
 */
int VerifyMemory = 0;
int MemoryLoad   = 0;


/***********************************************************************
 * Static definitions
 */
static char fullFileName[256];

#ifndef __sgi__
void swap_verif_endian(VerifyInfo *vp)
{
    if (vp == NULL) return;

    vp->rspListAddr   = ntohl(vp->rspListAddr);
    vp->rspListSize   = ntohl(vp->rspListSize);
    vp->rspListType   = ntohl(vp->rspListType);
    vp->ucodeTextAddr = ntohl(vp->ucodeTextAddr);
   
    vp->ucodeDataAddr = ntohl(vp->ucodeDataAddr);
    vp->ucodeDataSize = ntohl(vp->ucodeDataSize);
    vp->dramStackAddr = ntohl(vp->dramStackAddr);
    vp->dramStackSize = ntohl(vp->dramStackSize);
   
    {
        unsigned long long tmp1, tmp2;
        tmp1 = vp->rdpListSize & 0xffffffff;
        tmp2 = (vp->rdpListSize >> 32) & 0xffffffff;
        tmp1 = ntohl(tmp1);
        vp->rdpListSize = (tmp1<<32) | (ntohl(tmp2));
    }
    vp->rdpListAddr   = ntohl(vp->rdpListAddr);
    vp->pad1          = ntohl(vp->pad1);

    vp->bootUcodeAddr = ntohl(vp->bootUcodeAddr);
    vp->width         = ntohs(vp->width);
    vp->height        = ntohs(vp->height);
    vp->frameBuffer0Addr = ntohl(vp->frameBuffer0Addr);
    vp->frameBuffer1Addr = ntohl(vp->frameBuffer1Addr);

    vp->zBufferAddr   = ntohl(vp->zBufferAddr);
    vp->magicNumber   = ntohl(vp->magicNumber);
    vp->version       = ntohl(vp->version);
    vp->frameBufferFormat = ntohl(vp->frameBufferFormat);

    vp->frameBufferSize = ntohl(vp->frameBufferSize);
    vp->staticSegAddr =  ntohl(vp->staticSegAddr);
    vp->staticSegSize = ntohl(vp->staticSegSize);

    return; 
}
#endif

int
LoadFile(char *fileName, unsigned int address, int size)
{
    int ret = 0;

    if (size > 0) 
        ret = LoadRaw2Mem(fileName, address, size);
    else
        ret = LoadDL2Mem(fileName);
    return(ret);

}  /* LoadFile */


int
UnloadFile(char *fileName, unsigned int address, int size)
{
    int ret = 0;

    if (size > 0) 
        ret = UnloadRaw2File(fileName, address, size); 
    else
       ret = UnloadDL2File(fileName);
    return(ret);

}  /* UnloadFile */


/*
 * Load contents of Verify Info struct (display list, static segment, ...)
 * from a .rdram file into actual rdram memory. The argument rdramFileName
 * must not include the postfix ".rdram".
 */
static int 
LoadDL2Mem(char *rdramFileName)
{
#ifdef __sgi__
    VerifyInfo verif;
#else
    VerifyInfo verif, vv;
#endif
    char *displayList, *staticSegment, *displayListCmp, *staticSegmentCmp;
    FILE *fp;
    char sysCommand[256];
    struct stat statbuf;
    unsigned i;
    unsigned status;

    unsigned long rdpListSize, staticSegSize;

    int errcount = 0;


    sprintf(fullFileName, "%s%s", rdramFileName, ".rdram");

    _TRACE(DLOG, fprintf(LogFp, "LoadDL2Mem: file=%s\n", fullFileName));

#ifdef RDRAM_GCLR
    /* rdramgclr */
    sprintf(sysCommand, "$ROOT/usr/sbin/rdramgclr %s", rdramFileName);
    _TRACE(DLOG, fprintf(LogFp, "\t%s\n", sysCommand));
    status = system(sysCommand); 
    if (!((status != -1) && WIFEXITED(status) && (WEXITSTATUS(status) == 0))) {
        _TRACE(DERROR, fprintf(LogFp, "ERROR: rdramgclr failed\n"));
        return(-1);
    }
#endif

    /* make writeable */
    sprintf(sysCommand, "chmod 777 %s", fullFileName);
    _TRACE(DLOG, fprintf(LogFp, "\t%s\n", sysCommand));
    status = system(sysCommand); 
    if (!((status != -1) && WIFEXITED(status) && (WEXITSTATUS(status) == 0))) {
        _TRACE(DERROR, fprintf(LogFp, "ERROR: .rdram not writeable\n"));
        return(-1);
    }

    /* open rdram file */
    stat(fullFileName, &statbuf);
    fp = fopen(fullFileName, "r+b");
    if (fp == NULL) {
        _TRACE(DERROR, fprintf(LogFp, "ERROR: Unable to open rdram file: %s\n", 
	    fullFileName));
        return(-1);
    }

    /* extract the verify_info structure from .rdram file */
    bzero(&verif, sizeof(VerifyInfo));
    fseek(fp, VERIFY_INFO_PHYSADDR, SEEK_SET);
    fread(&verif, sizeof(VerifyInfo), 1, fp);
#ifndef __sgi__
    memcpy(&vv, &verif, sizeof(VerifyInfo));
    swap_verif_endian(&verif);
#endif
    _TRACE(DLOG, fprintf(LogFp, "\tVerifyInfo: magic = 0x%08x\n", 
        verif.magicNumber));	/* 0x102594 */
    _TRACE(DLOG, fprintf(LogFp,
        "\trdpList[Addr:Size]\t= 0x%08x 0x%08x 0x%llx\n",
        verif.rdpListAddr,(unsigned long)verif.rdpListSize,verif.rdpListSize));
    _TRACE(DLOG, fprintf(LogFp, "\tstaticSeg[Addr:Size]\t= 0x%08x 0x%08x\n", 
        verif.staticSegAddr, verif.staticSegSize));
    _TRACE(DLOG, fprintf(LogFp, "\tframeBuffer[Addr:Size]\t= 0x%08x 0x%08x\n", 
        verif.frameBuffer0Addr, verif.frameBufferSize));
    _TRACE(DLOG, fprintf(LogFp, "\tzBuffer[Addr]\t\t= 0x%08x\n", 
        verif.zBufferAddr));
    _TRACE(DLOG, fprintf(LogFp, "\twidth:height\t\t= 0x%08x 0x%08x\n", 
        verif.width, verif.height));

    _TRACE(DLOG, fprintf(LogFp, "\tWriting verify info struct into rdram\n"));
#ifdef __sgi__
    errcount += WriteMem(VERIFY_INFO_PHYSADDR, sizeof(VerifyInfo), 
                    (char *)&verif);
#else
    errcount += WriteMem(VERIFY_INFO_PHYSADDR, sizeof(VerifyInfo),
                 (char *)&vv);
#endif

    rdpListSize   = ALIGN((unsigned long) verif.rdpListSize, ALIGN_4B);
    staticSegSize = ALIGN((unsigned long) verif.staticSegSize, ALIGN_4B);

    /* extract displayList and staticSegment data from .rdram file */
    displayList = calloc((unsigned long) rdpListSize, sizeof(char));
    fseek(fp, verif.rdpListAddr, SEEK_SET);
    fread(displayList, sizeof(char), (unsigned long) rdpListSize, fp);

    staticSegment = calloc(staticSegSize, sizeof(char));
    fseek(fp, verif.staticSegAddr, SEEK_SET);
    fread(staticSegment, sizeof(char), staticSegSize, fp);

    _TRACE(DLOG, fprintf(LogFp, "\tWriting display list into rdram\n"));
    errcount += WriteMem(verif.rdpListAddr, (unsigned long) rdpListSize, 
                    displayList);

    if (VerifyMemory) {
        /* read display list back and compare */
        displayListCmp = calloc((unsigned long)rdpListSize, sizeof(char));
        _TRACE(DLOG, fprintf(LogFp,
            "\tVerifying display list from rdram...\n"));
        errcount += ReadMem(verif.rdpListAddr, 
                        (unsigned long) rdpListSize, displayListCmp);
        if (memcmp(displayList, displayListCmp, 
            (unsigned long) rdpListSize)) {
            _TRACE(DERROR, fprintf(LogFp, 
                "ERROR: Write of DL to RDRAM Failed\n"));
            fclose(fp);
            free(displayList);
            free(staticSegment);
            free(displayListCmp);
            return(-1);
        }
        _TRACE(DLOG, fprintf(LogFp, "\tDisplay list is verified -> OK\n"));
        free(displayListCmp);
     }

     /* load static segment from .rdram file into rdram */
     _TRACE(DLOG, fprintf(LogFp, "\tWriting static segment into rdram\n"));
     errcount += WriteMem(verif.staticSegAddr, staticSegSize, 
                     staticSegment);

    if (VerifyMemory) {
        /* read static segment back and compare */
        staticSegmentCmp = calloc(staticSegSize, sizeof(char));
        _TRACE(DLOG, fprintf(LogFp, 
            "\tVerifying static segment from rdram...\n"));
        errcount += ReadMem(verif.staticSegAddr, staticSegSize, 
                         staticSegmentCmp);
        if (memcmp(staticSegment, staticSegmentCmp, staticSegSize)) {
            _TRACE(DERROR, fprintf(LogFp, 
                "ERROR: Write of Static Segment to RDRAM Failed\n"));
            fclose(fp);
            free(displayList);
            free(staticSegment);
            free(staticSegmentCmp);
            return(-1);
        }
        _TRACE(DLOG, fprintf(LogFp, "\tStatic segment is verified -> OK\n"));
        free(staticSegmentCmp);
    }
    fclose(fp);
    free(displayList);
    free(staticSegment);

    printf(" Load ... * * * *  \n");
    return(errcount);

}  /* LoadDL2Mem */


/*
 * Load the contents of a .rdram file into actual rdram memory. 
 */
static int 
LoadRaw2Mem(char *rdramFileName, unsigned int address, int nbytes)
{
    FILE *fp;
    char *buf, *bufCmp;
    struct stat statbuf;
    int size;
    int errcount = 0;


    sprintf(fullFileName, "%s%s", rdramFileName, ".rdram");

    _TRACE(DLOG, fprintf(LogFp, 
        "LoadRaw2Mem: file=%s, addr=0x%08x, nbytes=%d\n", 
        fullFileName, address, nbytes));

    /* open rdram file */
    stat(fullFileName, &statbuf);
    fp = fopen(fullFileName, "r+b");
    if (fp == NULL) {
        _TRACE(DERROR, fprintf(LogFp, "ERROR: Unable to open file: %s\n", 
	    fullFileName));
        return(-1);
    }

    size = ALIGN(nbytes, ALIGN_4B);
    buf  = calloc(size, sizeof(char));
    fseek(fp, address, SEEK_SET);
    fread(buf, sizeof(char), size, fp);

    _TRACE(DLOG, fprintf(LogFp, "\tWriting data into rdram\n"));
    errcount += WriteMem(address, size, buf);

    if (VerifyMemory) {
        /* read back data and compare */
        bufCmp = calloc(size, sizeof(char));
        _TRACE(DLOG, fprintf(LogFp, "\tVerifying data from rdram...\n"));
        errcount += ReadMem(address, size, bufCmp);
        if (memcmp(buf, bufCmp, size)) {
            _TRACE(DERROR, fprintf(LogFp, 
                "ERROR: Write of data to RDRAM Failed\n"));
            fclose(fp);
            free(buf);
            free(bufCmp);
            return(-1);
        }
        _TRACE(DLOG, fprintf(LogFp, "\tData is verified -> OK\n"));
        free(bufCmp);
     }

    fclose(fp);
    free(buf);

    printf(" Unload ... * * * *  \n");
    return(errcount);

}  /* LoadRaw2Mem */


/*
 * Unload RDP related-info from Verify Info struct in actual rdram memory 
 * into the binary file pointed by rdramFileName.
 */
static int
UnloadDL2File(char *rdramFileName)
{
    unsigned read_data;
    unsigned pixelSize;
#ifdef __sgi__
    VerifyInfo verif;
#else
    VerifyInfo verif, vv;
#endif
    char *frameBuffer, *zBuffer, *cvgBuffer, *zhBuffer;
    char fullFileName[256];
    FILE *fp;
    struct stat statbuf;
    unsigned i, bufSize, cvgSize;
    unsigned zhSize;
    unsigned nrdrams;
    unsigned hiddenAddr;

    int errcount = 0;


    sprintf(fullFileName, "%s%s", rdramFileName, ".rdram");

    /* open rdram file */
    stat(fullFileName, &statbuf);
    fp = fopen(fullFileName, "r+b");
    if (fp == NULL) {
        _TRACE(DERROR, fprintf(LogFp, "ERROR: Unable to open rdram file: %s\n", 
	    fullFileName));
        return(-1);
    }

    /* verifp = (VerifyInfo *)(PHYS_TO_K1(VERIFY_INFO_PHYSADDR)); */
    errcount += ReadMem(VERIFY_INFO_PHYSADDR, sizeof(verif), (char *)&verif);

#ifndef __sgi__
    memcpy(&vv, &verif, sizeof( VerifyInfo));
    swap_verif_endian(&verif);
#endif
    _TRACE(DLOG, fprintf(LogFp, "\tVerifyInfo: magic = 0x%08x\n", 
        verif.magicNumber));	/* 0x102594 */
    _TRACE(DLOG, fprintf(LogFp,
        "\trdpList[Addr:Size]\t= 0x%08x 0x%08x 0x%llx\n",
        verif.rdpListAddr,(unsigned long)verif.rdpListSize,verif.rdpListSize));
    _TRACE(DLOG, fprintf(LogFp, "\tstaticSeg[Addr:Size]\t= 0x%08x 0x%08x\n", 
        verif.staticSegAddr, verif.staticSegSize));
    _TRACE(DLOG, fprintf(LogFp, "\tframeBuffer[Addr:Size]\t= 0x%08x 0x%08x\n", 
        verif.frameBuffer0Addr, verif.frameBufferSize));
    _TRACE(DLOG, fprintf(LogFp, "\tzBuffer[Addr]\t\t= 0x%08x\n", 
        verif.zBufferAddr));
    _TRACE(DLOG, fprintf(LogFp, "\twidth:height\t\t= 0x%08x 0x%08x\n", 
        verif.width, verif.height));

    _TRACE(DLOG, fprintf(LogFp, "\tWriting verify info struct to file\n"));
    fseek(fp, VERIFY_INFO_PHYSADDR, SEEK_SET);
#ifdef __sgi__
    fwrite(&verify, sizeof(VerifyInfo), 1, fp);
#else
    fwrite(&vv, sizeof(VerifyInfo), 1, fp);
#endif
    fflush(fp);

    /* read frame buffer from rdram into .rdram file */
    pixelSize = (verif.frameBufferSize == G_IM_SIZ_16b) ? 
                    G_IM_SIZ_16b_BYTES : G_IM_SIZ_32b_BYTES;

    bufSize = verif.width * verif.height * pixelSize;
    frameBuffer = calloc(bufSize, sizeof(char));
    _TRACE(DLOG, fprintf(LogFp, "\tReading frame buffer from rdram\n"));
    errcount += ReadMem(verif.frameBuffer0Addr, bufSize, frameBuffer);
    fseek(fp, verif.frameBuffer0Addr, SEEK_SET);
    fwrite(frameBuffer, sizeof(char), bufSize, fp);
    fflush(fp);

    /* read Z buffer from rdram into .rdram file */
    bufSize = verif.width * verif.height * G_IM_SIZ_16b_BYTES;
    zBuffer = calloc(bufSize, sizeof(char));
    _TRACE(DLOG, fprintf(LogFp, "\tReading Z buffer (0x%08x) from rdram\n",
        verif.zBufferAddr));
    errcount += ReadMem(verif.zBufferAddr, bufSize, zBuffer);
    fseek(fp, verif.zBufferAddr, SEEK_SET);
    fwrite(zBuffer, sizeof(char), bufSize, fp);
    fflush(fp);

    /* read hidden bits from rdram into .rdram file */
    /* set ebus test mode in MI mode register */
    _TRACE(DLOG, fprintf(LogFp, "\tSetting EBUS test mode in MI\n"));
    MemWrite(MI_MODE_REG, MI_SET_EBUS, 0, 0);
    errcount += MemReadCompMask(MI_MODE_REG, MI_MODE_EBUS, MI_MODE_EBUS, 0);
   
    /* extract hidden coverage bits if cfb is 16-bit RGBA */
    if (verif.frameBufferSize == G_IM_SIZ_16b) {
        _TRACE(DLOG, fprintf(LogFp, 
            "\tReading framebuffer (0x%08x) from rdram\n",
            verif.frameBuffer0Addr));
        bufSize = verif.width * verif.height * pixelSize;
        errcount += ReadMem(verif.frameBuffer0Addr, bufSize, frameBuffer);
   
        /* extract 4 lsb's of each 4-byte word (they are the hidden bits) */
        cvgSize = bufSize / HIDDEN_FACTOR;
        cvgBuffer = calloc(cvgSize, sizeof(char));
	    
        for (i=0; i < cvgSize; i++) {
            cvgBuffer[i] = (frameBuffer[(i * 8) + 3] << 4) | 
                           (frameBuffer[(i * 8) + 7] & 0xf);
        }
   
        /* write cvgBuffer into .rdram file */
        nrdrams = (statbuf.st_size > TOTAL_MEMORY_SIZE) ? 2 : 1;
        hiddenAddr = (MAIN_MEMORY_SIZE * nrdrams);
        hiddenAddr += (verif.frameBuffer0Addr / HIDDEN_FACTOR);
   
        _TRACE(DLOG, fprintf(LogFp, 
            "\tReading hidden coverage bits (0x%08x) from rdram\n",
            hiddenAddr));

        fseek(fp, hiddenAddr, SEEK_SET);
        fwrite(cvgBuffer, sizeof(char), cvgSize, fp);
        fflush(fp);
        free(cvgBuffer);
    }  /* if */
   
    /* extract hidden z bits from RDRAM */
    _TRACE(DLOG, fprintf(LogFp, "\tReading Z buffer (0x%08x) from rdram\n",
        verif.zBufferAddr));
    bufSize = verif.width*verif.height * G_IM_SIZ_16b_BYTES;
    errcount += ReadMem(verif.zBufferAddr, bufSize, zBuffer);
   
    /* extract 4 lsb's of each 4-byte word (these are the hidden bits) */
    zhSize = bufSize / HIDDEN_FACTOR;
    zhBuffer = calloc(zhSize, sizeof(char));
          
    for (i=0; i < zhSize; i++) {
        zhBuffer[i] = (zBuffer[(i * 8) + 3] << 4) | 
                      (zBuffer[(i * 8) + 7] & 0xf);
    }
  
    /* write zhBuffer into .rdram file */
    nrdrams = (statbuf.st_size > TOTAL_MEMORY_SIZE) ? 2 : 1;
    hiddenAddr = (MAIN_MEMORY_SIZE * nrdrams);
    hiddenAddr += (verif.zBufferAddr / HIDDEN_FACTOR);
   
    _TRACE(DLOG, fprintf(LogFp,"\tReading hidden Z bits (0x%08x) from rdram\n",
        hiddenAddr));
    fseek(fp, hiddenAddr, SEEK_SET);
    fwrite(zhBuffer, sizeof(char), zhSize, fp);
    fflush(fp);
    free(zhBuffer);
   
    /* clear ebus test mode in MI mode register */
    _TRACE(DLOG, fprintf(LogFp, "\tClearing EBUS test mode in MI\n"));
    MemWrite(MI_MODE_REG, MI_CLR_EBUS, 0, 0);
    errcount += MemReadCompMask(MI_MODE_REG, 0x0, MI_MODE_EBUS, 0);

    free(frameBuffer);
    free(zBuffer);
    fclose(fp);
 
    return(errcount);

}  /* UnloadDL2File */


/*
 * Unload contents of rdram memory to a .rdram file
 */
static int 
UnloadRaw2File(char *rdramFileName, unsigned int address, int nbytes)
{
    FILE *fp;
    char *buf, *bufCmp;
    struct stat statbuf;
    int size;
    int errcount = 0;


    sprintf(fullFileName, "%s%s", rdramFileName, ".rdram");

    _TRACE(DLOG, fprintf(LogFp, 
        "UnloadRaw2File: file=%s, addr=0x%08x, nbytes=%d\n", 
        fullFileName, address, nbytes));

    /* open rdram file */
    stat(fullFileName, &statbuf);
    fp = fopen(fullFileName, "r+b");
    if (fp == NULL) {
        _TRACE(DERROR, fprintf(LogFp, "ERROR: Unable to open file: %s\n", 
	    fullFileName));
        return(-1);
    }

    size = ALIGN(nbytes, ALIGN_4B);
    buf  = calloc(size, sizeof(char));

    _TRACE(DLOG, fprintf(LogFp, "\tReading data from rdram\n"));
    errcount += ReadMem(address, size, buf);

    _TRACE(DLOG, fprintf(LogFp, "\tWriting data to file\n"));
    fseek(fp, address, SEEK_SET);
    fwrite(buf, sizeof(char), size, fp);
    fflush(fp);

    if (VerifyMemory) {
        /* read back data and compare */
        bufCmp = calloc(size, sizeof(char));
        _TRACE(DLOG, fprintf(LogFp, "\tVerifying data from rdram...\n"));
        fseek(fp, address, SEEK_SET);
        fread(bufCmp, sizeof(char), size, fp);
        if (memcmp(buf, bufCmp, size)) {
            _TRACE(DERROR, fprintf(LogFp, 
                "ERROR: Read of data from RDRAM Failed\n"));
            fclose(fp);
            free(buf);
            free(bufCmp);
            return(-1);
        }
        _TRACE(DLOG, fprintf(LogFp, "\tData is verified -> OK\n"));
        free(bufCmp);
     }

    fclose(fp);
    free(buf);

    return(errcount);

}  /* UnloadRaw2File */


/*
 * Transfer "nbytes" of data between "buffer" and rdram memory starting at 
 * address "startAddr". The "type" argument dictates the direction of
 * transfer: OP_READ is from rdram memory to buffer and OP_WRITE is from buffer
 * to rdram memory.
 * Note: For block write, the address must be aligned with the block!
 */
int MemAccess(int type, unsigned int startAddr, unsigned int nbytes, 
    char *buffer)
{
    register unsigned int cntr;
    register unsigned int addr;
    register unsigned int remainBytes;

    int (*memfuncp)(unsigned int, int, unsigned int *);

    int errcount = 0;   

    cntr = 0;
    addr = startAddr;
    remainBytes = nbytes;

    _TRACE(DLOG, fprintf(LogFp, 
        "\tMemAccess: type=%d addr=0x%08x, nbytes=%d, remains=%d\n", 
        type, addr, nbytes, remainBytes));

    memfuncp = (type == OP_READ) ? IoRead : IoWrite;

    while (remainBytes > 0) {
        if ((IS_ALIGN(addr, ALIGN_32B)) && (remainBytes >= 32)) {
            errcount+= memfuncp(addr, 32, (unsigned *)&buffer[cntr]);
            _TRACE(DLOG, fprintf(LogFp,
                "(32)\tmem addr = 0x%08x; buf [0x%08x] = 0x%08x; rem = %d\n",
                addr, cntr, *(unsigned *)&buffer[cntr], remainBytes));
            addr += 32;
            cntr += 32;
            remainBytes -= 32;
        }
        else if ((IS_ALIGN(addr, ALIGN_16B)) && (remainBytes >= 16)) {
            errcount+= memfuncp(addr, 16, (unsigned *)&buffer[cntr]);
            _TRACE(DLOG, fprintf(LogFp,
                "(16)\tmem addr = 0x%08x; buf [0x%08x] = 0x%08x; rem = %d\n",
                addr, cntr, *(unsigned *)&buffer[cntr], remainBytes));
            addr += 16;
            cntr += 16;
            remainBytes -= 16;
        }
        else if ((IS_ALIGN(addr, ALIGN_8B)) && (remainBytes >= 8)) {
            errcount+= memfuncp(addr, 8, (unsigned *)&buffer[cntr]);
            _TRACE(DLOG, fprintf(LogFp,
                "(8)\tmem addr = 0x%08x; buf [0x%08x] = 0x%08x; rem = %d\n",
                addr, cntr, *(unsigned *)&buffer[cntr], remainBytes));
            addr += 8;
            cntr += 8;
            remainBytes -= 8;
        }
        else { 
            /*
             * Assume that it's 4-byte aligned and has at least 4 bytes
             * remained
             */
            errcount+= memfuncp(addr, 4, (unsigned *)&buffer[cntr]);
            _TRACE(DLOG, fprintf(LogFp,
                "(4)\tmem addr = 0x%08x; buf [0x%08x] = 0x%08x; rem = %d\n",
                addr, cntr, *(unsigned *)&buffer[cntr], remainBytes));
            addr += 4;
            cntr += 4;
            remainBytes -= 4;
        }
    }  /* while */

    return (errcount);

}  /* MemAccess */