zrw.c

dump系统所有的寄存器

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#ifdef LINUX
#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/io.h>
#include <unistd.h>
#include <fcntl.h>
#endif

#define ZEVIO_IOSTART 0x90000000
#define ZEVIO_IOSIZE  0x00000200
#ifdef WIN32
static unsigned char io_virtualmemory[1024*1024];
#define pad(a)  *(unsigned long *)(io_va + (a) - io_pa)
#endif

static unsigned long  io_pa   =ZEVIO_IOSTART;
static unsigned long  io_size =ZEVIO_IOSIZE;
static unsigned char *io_va   =NULL;
static int            io_fd=0;
static int            is_bigendian=0;
static int            io_debug=0;

void byte_order_detect(void)
{
    union byte_order_test {
        unsigned long  ul;
        unsigned char  uc[4];
    }b;

    b.ul=0x550000AA;
    if(b.uc[0]==0xAA && b.uc[3]==0x55)
        is_bigendian = 0;
    else if(b.uc[0]==0x55 && b.uc[3]==0xAA)
        is_bigendian = 1;
}
#ifdef LINUX
#define pad(a)  *(volatile unsigned long *)(io_va + ((a) - io_pa))
#endif
static int  io_mmap(void)
{
#ifdef LINUX
    if(io_fd==0) {
        io_fd=open("/dev/mem",O_RDWR);
        if(io_fd<=0) {
            printf("Open /dev/mem fail = %d\n",io_fd);
            exit(1);
        }
    } else {
        return 0;
    }

    io_va = mmap(NULL, io_size, PROT_READ | PROT_WRITE , MAP_SHARED, io_fd, io_pa);

    if(!io_va || io_va == (unsigned char *)-1){
        printf("Fail map io space from %08lX size %08lX\n",io_pa,io_size);
        close(io_fd);
        exit(1);
    }
#endif
#ifdef WIN32
    io_va=(unsigned char *)io_virtualmemory;
#endif
    return 0;
}
static int io_unmap(void)
{
#ifdef LINUX
    if(io_va && io_va != (unsigned char *)-1) {
        if(io_debug) printf("unmap the io space\n");
        munmap(io_va,io_size);
    }
    if(io_fd>0) {
        if(io_debug) printf("close the /dev/mem file\n");
        close(io_fd);
    }
#endif
    io_va=NULL;
    io_fd=0;
    return 0;
}

#define ZOP_READ  'R'
#define ZOP_WRITE 'W'
int           zop=0;
unsigned long zop_address=0;
unsigned long zop_counter=0;
unsigned long zop_value=0;
int           zop_error=0;

char            zop_char[1024];
unsigned short *zop_short;
unsigned int   *zop_int;
unsigned long  *zop_long;
static unsigned long string_to_integer(char *fmt, char *str, int *data_length)
{
    #define ishchar(c) (('0'<=c&&c<='9') || ('a'<=c&&c<='f') || ('A'<=c&&c<='F'))
    #define isochar(c) ('0'<=c&&c<='7')
    #define chartoh(c) (('0'<=c&&c<='9')?c-'0':(('a'<=c&&c<='f')?c-'a'+10:c-'A'+10))
    int f=0;
    int base=16;
    int dlen=0;
    char c,*p=str;
    unsigned long val=0;

    if       (strcmp(fmt,"%a")==0) { f='a';
    } else if(strcmp(fmt,"%c")==0) { f='c';
    } else if(strcmp(fmt,"%v")==0) { f='v';
    } else {
    }

    if       (*p=='0' && (*(p+1)=='x' || *(p+1)=='X')) { p+=2; base=16;
    } else if(*p=='0' && (*(p+1)=='d' || *(p+1)=='D')) { p+=2; base=10;
    } else if(*p=='0' && (*(p+1)=='o' || *(p+1)=='O')) { p+=2; base=8;
    } else if(*p=='0' && (*(p+1)=='b' || *(p+1)=='B')) { p+=2; base=2;
    } else if(*p=='0') {
        c=*(p+1);
        if(isochar(c))
            base=8;
    }
    while((*p) && dlen<8) {
        c=*p;
        if(ishchar(c) && base==16){
            c=chartoh(c);
            val=(val*base)|c;
            dlen++;
        } else {
            zop_error++;
            break;
        }
        p++;
    }
    if((f=='a' || f=='v') && dlen<8){
        //val<<=4*(8-dlen);
    }

    if(*p) {
        zop_error++;
    }

    *data_length = dlen;

    return val;
}
static void zop_help(void)
{
    printf("Read/Write hardware register\n");
    printf("   Usage [ option ] address [block size/value]\n");
    printf("   -r            switch to read mode\n");
    printf("   -w            switch to write mode\n");
    printf("   -d            turn on debug mode\n");
#ifdef ZREAD
    printf("Default mode : read\n");
#endif
#ifdef ZWRITE
    printf("Default mode : write\n");
#endif
    printf("Help: System byte order is %s\n",is_bigendian?"big endian":"little endian");
}
static void zop_read(void)
{
    unsigned long count=zop_counter;
    unsigned long addr=zop_address;
    unsigned long done=0;
    unsigned long nr;
    unsigned long i;
    while(count) {
        done = count;
        if(done>sizeof(zop_char))
            done=sizeof(zop_char);
        nr = (done+3)/4;

        //read to temp memory
        for(i=0;i<nr;i++){
            zop_int[i] = pad(addr + i*4);
        }

        //display
        for(i=0;i<nr;i+=4){
            printf("%08lX ",addr+i*4);
            if(i  <nr) printf("%08X ",zop_int[i  ]);
            if(i+1<nr) printf("%08X ",zop_int[i+1]);
            if(i+2<nr) printf("%08X ",zop_int[i+2]);
            if(i+3<nr) printf("%08X ",zop_int[i+3]);
            printf("\n");
        }

        addr += nr*4;
        count-=done;
    }
}

static void zop_write(void)
{
    unsigned long addr=zop_address;
    unsigned long mask=0,masked=0;
    if(zop_counter<4) {
        zop_int[0]= pad(addr);
        if(is_bigendian) {
        } else {
        }
        if(zop_counter==1)      mask = 0xFFFFFF00;
        else if(zop_counter==2) mask = 0xFFFF0000;
        else if(zop_counter==3) mask = 0xFF000000;
        masked = (zop_int[0] & mask) | (zop_value & ~mask);
    } else {
        masked = zop_value;
    }
    pad(addr) = masked;
    printf("%08lX = %08lX\n",addr,masked);
}
static void zop_initialize_local(void)
{
#ifdef ZREAD
    zop = ZOP_READ;
#endif

#ifdef ZWRITE
    zop = ZOP_WRITE;
#endif

#ifdef WIN32
    {
        int i;
        zop_int  =(unsigned int   *)io_virtualmemory;
        for(i=0;i<sizeof(io_virtualmemory)/sizeof(zop_int);i++) {
            *zop_int++ = i+(i<<7) + (i<<15) + (i<<28);
        }
    }
#endif

    zop_short=(unsigned short *)zop_char;
    zop_int  =(unsigned int   *)zop_char;
    zop_long =(unsigned long  *)zop_char;
    byte_order_detect();
}
static void zop_symbollink_check(void)
{
    //leave it empty for next version
}
static void zop_parse_args(int argc, char **argv)
{
    int dummy;
    char *p;

    argc--;
    argv++;

    while(argc>0) {
        p=argv[0];
        if(*p=='-') {
            p++;
            if       (*p=='d') { io_debug=1;
            } else if(*p=='r') { zop = ZOP_READ;
            } else if(*p=='w') { zop = ZOP_WRITE;
            }
            argc--;
            argv++;
        } else {
            break;
        }
    }
    if(argc<1) {
        zop_error++;
        return;
    }
    zop_address = string_to_integer("%a",argv[0],&dummy);
    zop_counter = 4;
    argc--;
    argv++;

    if(zop==ZOP_READ) {
        if(argc>0) {
            zop_counter = string_to_integer("%c",argv[0],&dummy);
            zop_counter = (zop_counter+3UL)& ~3UL;
            argc--;
            argv++;
        }
    } else if(zop==ZOP_WRITE) {
        if(argc>0) {
            zop_value = string_to_integer("%v",argv[0],&dummy);
            zop_counter = (dummy+1)/2;
            argc--;
            argv++;
        } else {
            zop_error++;
        }
    }
}

int main(int argc, char **argv)
{
    zop_initialize_local();
    zop_symbollink_check();
    zop_parse_args(argc,argv);

    if(argc>1) {
        if(zop_address & 3) {
            printf("Error : address 0x%08lX invalid, not 4 bytes alignment\n",zop_address);
            zop_error++;
        }
        if(zop_counter==0) {
            printf("Error : counter 0x%08lX\n",zop_counter);
            zop_error++;
        }
    }
#ifdef WIN32
    if(zop_counter>sizeof(io_virtualmemory)) {
        printf("Error : operate bytes 0x%08lX too bigger than %08lX\n",zop_counter,sizeof(io_virtualmemory));
        zop_error++;
    }
#endif
    io_pa   = zop_address & ~0x0FFFUL;
    io_size = (((zop_address+zop_counter+0x0FFFUL)>>12) - (zop_address>>12)) << 12;

    if(!zop || zop_error) {
        zop_help();
        return -1;
    }

    io_mmap();

    switch(zop) {
    case ZOP_READ: zop_read(); break;
    case ZOP_WRITE: zop_write(); break;
    default : break;
    }

    io_unmap();

    return 0;
}