Code Review / openocd.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
Cleanup: nuke trailling whitespaces
[openocd.git] / src / target / mips32_pracc.c
diff --git a/src/target/mips32_pracc.c b/src/target/mips32_pracc.c
index db364bb403ce146a2c411b2531f50b05ff00f7a9..0d33f391469402cc889e8118a5d5c0edb652da2a 100644 (file)
--- a/src/target/mips32_pracc.c
+++ b/src/target/mips32_pracc.c
@@ -26,7 +26,7 @@ This version has optimized assembly routines for 32 bit operations:
 - write word
 - write array of words
 
-One thing to be aware of is that the MIPS32 cpu will execute the 
+One thing to be aware of is that the MIPS32 cpu will execute the
 instruction after a branch instruction (one delay slot).
 
 For example:
@@ -36,7 +36,7 @@ For example:
     B foo
     LW $1, ($2 +100)
 
-The LW $1, ($2 +100) instruction is also executed. If this is 
+The LW $1, ($2 +100) instruction is also executed. If this is
 not wanted a NOP can be inserted:
 
     LW $2, ($5 +10)
@@ -78,22 +78,22 @@ Nico Coesel
 #include "mips32_pracc.h"
 
 typedef struct {
-       u32 *local_iparam;
+       uint32_t *local_iparam;
        int num_iparam;
-       u32 *local_oparam;
+       uint32_t *local_oparam;
        int num_oparam;
-       u32 *code;
+       uint32_t *code;
        int code_len;
-       u32 stack[32];
+       uint32_t stack[32];
        int stack_offset;
        mips_ejtag_t *ejtag_info;
 } mips32_pracc_context;
 
-static int wait_for_pracc_rw(mips_ejtag_t *ejtag_info, u32 *ctrl)
+static int wait_for_pracc_rw(mips_ejtag_t *ejtag_info, uint32_t *ctrl)
 {
-       u32 ejtag_ctrl;
-       
-       while (1) 
+       uint32_t ejtag_ctrl;
+
+       while (1)
        {
                mips_ejtag_set_instr(ejtag_info, EJTAG_INST_CONTROL, NULL);
                ejtag_ctrl = ejtag_info->ejtag_ctrl;
@@ -103,16 +103,16 @@ static int wait_for_pracc_rw(mips_ejtag_t *ejtag_info, u32 *ctrl)
                LOG_DEBUG("DEBUGMODULE: No memory access in progress!\n");
                return ERROR_JTAG_DEVICE_ERROR;
        }
-       
+
        *ctrl = ejtag_ctrl;
        return ERROR_OK;
 }
 
-static int mips32_pracc_exec_read(mips32_pracc_context *ctx, u32 address)
+static int mips32_pracc_exec_read(mips32_pracc_context *ctx, uint32_t address)
 {
        mips_ejtag_t *ejtag_info = ctx->ejtag_info;
        int offset;
-       u32 ejtag_ctrl, data;
+       uint32_t ejtag_ctrl, data;
 
        if ((address >= MIPS32_PRACC_PARAM_IN)
                && (address <= MIPS32_PRACC_PARAM_IN + ctx->num_iparam * 4))
@@ -141,12 +141,12 @@ static int mips32_pracc_exec_read(mips32_pracc_context *ctx, u32 address)
        {
                /* TODO: send JMP 0xFF200000 instruction. Hopefully processor jump back
                 * to start of debug vector */
-               
+
                data = 0;
-               LOG_ERROR("Error reading unexpected address %8.8x", address);
+               LOG_ERROR("Error reading unexpected address %8.8" PRIx32 "", address);
                return ERROR_JTAG_DEVICE_ERROR;
        }
-       
+
        /* Send the data out */
        mips_ejtag_set_instr(ctx->ejtag_info, EJTAG_INST_DATA, NULL);
        mips_ejtag_drscan_32(ctx->ejtag_info, &data);
@@ -159,20 +159,20 @@ static int mips32_pracc_exec_read(mips32_pracc_context *ctx, u32 address)
 
        jtag_add_clocks(5);
        jtag_execute_queue();
-       
+
 
        return ERROR_OK;
 }
 
-static int mips32_pracc_exec_write(mips32_pracc_context *ctx, u32 address)
+static int mips32_pracc_exec_write(mips32_pracc_context *ctx, uint32_t address)
 {
-       u32 ejtag_ctrl,data;
+       uint32_t ejtag_ctrl,data;
        int offset;
        mips_ejtag_t *ejtag_info = ctx->ejtag_info;
 
        mips_ejtag_set_instr(ctx->ejtag_info, EJTAG_INST_DATA, NULL);
        mips_ejtag_drscan_32(ctx->ejtag_info, &data);
-       
+
        /* Clear access pending bit */
        ejtag_ctrl = ejtag_info->ejtag_ctrl & ~EJTAG_CTRL_PRACC;
        mips_ejtag_set_instr(ctx->ejtag_info, EJTAG_INST_CONTROL, NULL);
@@ -180,14 +180,14 @@ static int mips32_pracc_exec_write(mips32_pracc_context *ctx, u32 address)
 
        jtag_add_clocks(5);
        jtag_execute_queue();
-       
+
        if ((address >= MIPS32_PRACC_PARAM_IN)
                && (address <= MIPS32_PRACC_PARAM_IN + ctx->num_iparam * 4))
        {
                offset = (address - MIPS32_PRACC_PARAM_IN) / 4;
                ctx->local_iparam[offset] = data;
        }
-       else if ((address >= MIPS32_PRACC_PARAM_OUT )
+       else if ((address >= MIPS32_PRACC_PARAM_OUT)
                && (address <= MIPS32_PRACC_PARAM_OUT + ctx->num_oparam * 4))
        {
                offset = (address - MIPS32_PRACC_PARAM_OUT) / 4;
@@ -200,21 +200,21 @@ static int mips32_pracc_exec_write(mips32_pracc_context *ctx, u32 address)
        }
        else
        {
-               LOG_ERROR("Error writing unexpected address %8.8x", address);
+               LOG_ERROR("Error writing unexpected address %8.8" PRIx32 "", address);
                return ERROR_JTAG_DEVICE_ERROR;
        }
-       
+
        return ERROR_OK;
 }
 
-int mips32_pracc_exec( mips_ejtag_t *ejtag_info, int code_len, u32 *code, int num_param_in, u32 *param_in, int num_param_out, u32 *param_out, int cycle)
+int mips32_pracc_exec(mips_ejtag_t *ejtag_info, int code_len, uint32_t *code, int num_param_in, uint32_t *param_in, int num_param_out, uint32_t *param_out, int cycle)
 {
-       u32 ejtag_ctrl;
-       u32 address, data;
+       uint32_t ejtag_ctrl;
+       uint32_t address, data;
        mips32_pracc_context ctx;
        int retval;
        int pass = 0;
-       
+
        ctx.local_iparam = param_in;
        ctx.local_oparam = param_out;
        ctx.num_iparam = num_param_in;
@@ -223,18 +223,18 @@ int mips32_pracc_exec( mips_ejtag_t *ejtag_info, int code_len, u32 *code, int nu
        ctx.code_len = code_len;
        ctx.ejtag_info = ejtag_info;
        ctx.stack_offset = 0;
-       
+
        while (1)
        {
                if ((retval = wait_for_pracc_rw(ejtag_info, &ejtag_ctrl)) != ERROR_OK)
                        return retval;
-               
+
                address = data = 0;
                mips_ejtag_set_instr(ejtag_info, EJTAG_INST_ADDRESS, NULL);
                mips_ejtag_drscan_32(ejtag_info, &address);
 
 //             printf("Adres: %.8x\n", address);
-               
+
                /* Check for read or write */
                if (ejtag_ctrl & EJTAG_CTRL_PRNW)
                {
@@ -250,26 +250,26 @@ int mips32_pracc_exec( mips_ejtag_t *ejtag_info, int code_len, u32 *code, int nu
                        {
                                break;
                        }
-                       
+
                        if ((retval = mips32_pracc_exec_read(&ctx, address)) != ERROR_OK)
                                return retval;
 
                }
-               
+
                if (cycle == 0)
                        break;
        }
-       
+
        /* stack sanity check */
        if (ctx.stack_offset != 0)
        {
                LOG_DEBUG("Pracc Stack not zero");
        }
-       
+
        return ERROR_OK;
 }
 
-int mips32_pracc_read_mem(mips_ejtag_t *ejtag_info, u32 addr, int size, int count, void *buf)
+int mips32_pracc_read_mem(mips_ejtag_t *ejtag_info, uint32_t addr, int size, int count, void *buf)
 {
        switch (size)
        {
@@ -278,18 +278,18 @@ int mips32_pracc_read_mem(mips_ejtag_t *ejtag_info, u32 addr, int size, int coun
                case 2:
                        return mips32_pracc_read_mem16(ejtag_info, addr, count, (uint16_t*)buf);
                case 4:
-                       if(count==1)
-                               return mips32_pracc_read_u32(ejtag_info, addr, (u32*)buf);
+                       if (count == 1)
+                               return mips32_pracc_read_u32(ejtag_info, addr, (uint32_t*)buf);
                        else
-                               return mips32_pracc_read_mem32(ejtag_info, addr, count, (u32*)buf);
+                               return mips32_pracc_read_mem32(ejtag_info, addr, count, (uint32_t*)buf);
        }
-       
+
        return ERROR_OK;
 }
 
-int mips32_pracc_read_mem32(mips_ejtag_t *ejtag_info, u32 addr, int count, u32 *buf)
-{      
-       u32 code[] = {
+int mips32_pracc_read_mem32(mips_ejtag_t *ejtag_info, uint32_t addr, int count, uint32_t *buf)
+{
+       uint32_t code[] = {
                                                                                                                        /* start: */
                MIPS32_MTC0(15,31,0),                                                           /* move $15 to COP0 DeSave */
                MIPS32_LUI(15,UPPER16(MIPS32_PRACC_STACK)),             /* $15 = MIPS32_PRACC_STACK */
@@ -298,25 +298,25 @@ int mips32_pracc_read_mem32(mips_ejtag_t *ejtag_info, u32 addr, int count, u32 *
                MIPS32_SW(9,0,15),                                                                      /* sw $9,($15) */
                MIPS32_SW(10,0,15),                                                             /* sw $10,($15) */
                MIPS32_SW(11,0,15),                                                             /* sw $11,($15) */
-                       
+
                MIPS32_LUI(8,UPPER16(MIPS32_PRACC_PARAM_IN)),           /* $8 = MIPS32_PRACC_PARAM_IN */
                MIPS32_ORI(8,8,LOWER16(MIPS32_PRACC_PARAM_IN)),
-               MIPS32_LW(9,0,8),                                                                       /* $9=mem[$8]; read addr */
-               MIPS32_LW(10,4,8),                                                                      /* $10=mem[$8+4]; read count */
-               MIPS32_LUI(11,UPPER16(MIPS32_PRACC_PARAM_OUT)),         /* $11=MIPS32_PRACC_PARAM_OUT */
+               MIPS32_LW(9,0,8),                                                                       /* $9 = mem[$8]; read addr */
+               MIPS32_LW(10,4,8),                                                                      /* $10 = mem[$8 + 4]; read count */
+               MIPS32_LUI(11,UPPER16(MIPS32_PRACC_PARAM_OUT)),         /* $11 = MIPS32_PRACC_PARAM_OUT */
                MIPS32_ORI(11,11,LOWER16(MIPS32_PRACC_PARAM_OUT)),
                MIPS32_NOP,
                                                                                                                        /* loop: */
                MIPS32_BEQ(0,10,9),                                                                     /* beq 0, $10, end */
                MIPS32_NOP,
-               
+
                MIPS32_LW(8,0,9),                                                                       /* lw $8,0($9), Load $8 with the word @mem[$9] */
                MIPS32_SW(8,0,11),                                                                      /* sw $8,0($11) */
-               
+
                MIPS32_ADDI(10,10,NEG16(1)),                                            /* $10-- */
-               MIPS32_ADDI(9,9,4),                                                             /* $1+=4 */
-               MIPS32_ADDI(11,11,4),                                                           /* $11+=4 */
-               
+               MIPS32_ADDI(9,9,4),                                                             /* $1 += 4 */
+               MIPS32_ADDI(11,11,4),                                                           /* $11 += 4 */
+
                MIPS32_NOP,
                MIPS32_B(NEG16(9)),                                                                     /* b loop */
                MIPS32_NOP,
@@ -330,29 +330,29 @@ int mips32_pracc_read_mem32(mips_ejtag_t *ejtag_info, u32 addr, int count, u32 *
                MIPS32_B(NEG16(31)),                                                            /* b start */
                MIPS32_NOP,
        };
-       
+
        int retval = ERROR_OK;
        int blocksize;
        int bytesread;
-       u32 param_in[2];
-       
+       uint32_t param_in[2];
+
        bytesread = 0;
-       
+
        while (count > 0)
-       {       
+       {
                blocksize = count;
                if (count > 0x400)
                        blocksize = 0x400;
-               
+
                param_in[0] = addr;
                param_in[1] = blocksize;
-               
-               if ((retval = mips32_pracc_exec(ejtag_info, sizeof(code)/sizeof(code[0]), code, 
+
+               if ((retval = mips32_pracc_exec(ejtag_info, sizeof(code)/sizeof(code[0]), code,
                        sizeof(param_in)/sizeof(param_in[0]), param_in, blocksize, &buf[bytesread], 1)) != ERROR_OK)
                {
                        return retval;
                }
-               
+
                count -= blocksize;
                addr += blocksize;
                bytesread += blocksize;
@@ -361,9 +361,9 @@ int mips32_pracc_read_mem32(mips_ejtag_t *ejtag_info, u32 addr, int count, u32 *
        return retval;
 }
 
-int mips32_pracc_read_u32(mips_ejtag_t *ejtag_info, u32 addr, u32 *buf)
+int mips32_pracc_read_u32(mips_ejtag_t *ejtag_info, uint32_t addr, uint32_t *buf)
 {
-       u32 code[] = {
+       uint32_t code[] = {
                                                                                                                        /* start: */
                MIPS32_MTC0(15,31,0),                                                           /* move $15 to COP0 DeSave */
                MIPS32_LUI(15,UPPER16(MIPS32_PRACC_STACK)),             /* $15 = MIPS32_PRACC_STACK */
@@ -382,12 +382,12 @@ int mips32_pracc_read_u32(mips_ejtag_t *ejtag_info, u32 addr, u32 *buf)
        };
 
        int retval = ERROR_OK;
-       u32 param_in[1];
+       uint32_t param_in[1];
 
        param_in[0] = addr;
 
-       if ((retval = mips32_pracc_exec(ejtag_info, sizeof(code)/sizeof(code[0]), code, 
-               sizeof(param_in)/sizeof(param_in[0]), param_in, sizeof(u32), buf, 1)) != ERROR_OK)
+       if ((retval = mips32_pracc_exec(ejtag_info, sizeof(code)/sizeof(code[0]), code,
+               sizeof(param_in)/sizeof(param_in[0]), param_in, sizeof(uint32_t), buf, 1)) != ERROR_OK)
        {
                return retval;
        }
@@ -395,9 +395,9 @@ int mips32_pracc_read_u32(mips_ejtag_t *ejtag_info, u32 addr, u32 *buf)
        return retval;
 }
 
-int mips32_pracc_read_mem16(mips_ejtag_t *ejtag_info, u32 addr, int count, uint16_t *buf)
+int mips32_pracc_read_mem16(mips_ejtag_t *ejtag_info, uint32_t addr, int count, uint16_t *buf)
 {
-       u32 code[] = {
+       uint32_t code[] = {
                                                                                                                        /* start: */
                MIPS32_MTC0(15,31,0),                                                           /* move $15 to COP0 DeSave */
                MIPS32_LUI(15,UPPER16(MIPS32_PRACC_STACK)),             /* $15 = MIPS32_PRACC_STACK */
@@ -406,24 +406,24 @@ int mips32_pracc_read_mem16(mips_ejtag_t *ejtag_info, u32 addr, int count, uint1
                MIPS32_SW(9,0,15),                                                                      /* sw $9,($15) */
                MIPS32_SW(10,0,15),                                                             /* sw $10,($15) */
                MIPS32_SW(11,0,15),                                                             /* sw $11,($15) */
-                       
+
                MIPS32_LUI(8,UPPER16(MIPS32_PRACC_PARAM_IN)),           /* $8 = MIPS32_PRACC_PARAM_IN */
                MIPS32_ORI(8,8,LOWER16(MIPS32_PRACC_PARAM_IN)),
-               MIPS32_LW(9,0,8),                                                                       /* $9=mem[$8]; read addr */
-               MIPS32_LW(10,4,8),                                                                      /* $10=mem[$8+4]; read count */
-               MIPS32_LUI(11,UPPER16(MIPS32_PRACC_PARAM_OUT)),         /* $11=MIPS32_PRACC_PARAM_OUT */
+               MIPS32_LW(9,0,8),                                                                       /* $9 = mem[$8]; read addr */
+               MIPS32_LW(10,4,8),                                                                      /* $10 = mem[$8 + 4]; read count */
+               MIPS32_LUI(11,UPPER16(MIPS32_PRACC_PARAM_OUT)),         /* $11 = MIPS32_PRACC_PARAM_OUT */
                MIPS32_ORI(11,11,LOWER16(MIPS32_PRACC_PARAM_OUT)),
                MIPS32_NOP,
                                                                                                                        /* loop: */
                MIPS32_BEQ(0,10,9),                                                             /* beq 0, $10, end */
                MIPS32_NOP,
-               
+
                MIPS32_LHU(8,0,9),                                                                      /* lw $8,0($9), Load $8 with the halfword @mem[$9] */
                MIPS32_SW(8,0,11),                                                                      /* sw $8,0($11) */
-               
+
                MIPS32_ADDI(10,10,NEG16(1)),                                            /* $10-- */
-               MIPS32_ADDI(9,9,2),                                                             /* $9+=2 */
-               MIPS32_ADDI(11,11,4),                                                           /* $11+=4 */
+               MIPS32_ADDI(9,9,2),                                                             /* $9 += 2 */
+               MIPS32_ADDI(11,11,4),                                                           /* $11 += 4 */
                MIPS32_NOP,
                MIPS32_B(NEG16(9)),                                                                     /* b loop */
                MIPS32_NOP,
@@ -439,44 +439,44 @@ int mips32_pracc_read_mem16(mips_ejtag_t *ejtag_info, u32 addr, int count, uint1
        };
 
 //     /* TODO remove array */
-       u32 param_out[count];
+       uint32_t param_out[count];
        int i;
-       
+
 //     int retval;
        int blocksize;
        int bytesread;
-       u32 param_in[2];
-       
+       uint32_t param_in[2];
+
        bytesread = 0;
-       
+
        //while (count > 0)
-       {       
+       {
                blocksize = count;
                if (count > 0x400)
                        blocksize = 0x400;
-               
+
                param_in[0] = addr;
                param_in[1] = blocksize;
-               
+
                mips32_pracc_exec(ejtag_info, sizeof(code)/sizeof(code[0]), code, \
                        sizeof(param_in)/sizeof(param_in[0]), param_in, count, param_out, 1);
-               
+
 //             count -= blocksize;
 //             addr += blocksize;
 //             bytesread += blocksize;
        }
-       
+
        for (i = 0; i < count; i++)
        {
                buf[i] = param_out[i];
        }
-       
+
        return ERROR_OK;
 }
 
-int mips32_pracc_read_mem8(mips_ejtag_t *ejtag_info, u32 addr, int count, uint8_t *buf)
+int mips32_pracc_read_mem8(mips_ejtag_t *ejtag_info, uint32_t addr, int count, uint8_t *buf)
 {
-       u32 code[] = {
+       uint32_t code[] = {
                                                                                                                        /* start: */
                MIPS32_MTC0(15,31,0),                                                           /* move $15 to COP0 DeSave */
                MIPS32_LUI(15,UPPER16(MIPS32_PRACC_STACK)),             /* $15 = MIPS32_PRACC_STACK */
@@ -485,24 +485,24 @@ int mips32_pracc_read_mem8(mips_ejtag_t *ejtag_info, u32 addr, int count, uint8_
                MIPS32_SW(9,0,15),                                                                      /* sw $9,($15) */
                MIPS32_SW(10,0,15),                                                             /* sw $10,($15) */
                MIPS32_SW(11,0,15),                                                             /* sw $11,($15) */
-                       
+
                MIPS32_LUI(8,UPPER16(MIPS32_PRACC_PARAM_IN)),           /* $8 = MIPS32_PRACC_PARAM_IN */
                MIPS32_ORI(8,8,LOWER16(MIPS32_PRACC_PARAM_IN)),
-               MIPS32_LW(9,0,8),                                                                       /* $9=mem[$8]; read addr */
-               MIPS32_LW(10,4,8),                                                                      /* $10=mem[$8+4]; read count */
-               MIPS32_LUI(11,UPPER16(MIPS32_PRACC_PARAM_OUT)),         /* $11=MIPS32_PRACC_PARAM_OUT */
+               MIPS32_LW(9,0,8),                                                                       /* $9 = mem[$8]; read addr */
+               MIPS32_LW(10,4,8),                                                                      /* $10 = mem[$8 + 4]; read count */
+               MIPS32_LUI(11,UPPER16(MIPS32_PRACC_PARAM_OUT)),         /* $11 = MIPS32_PRACC_PARAM_OUT */
                MIPS32_ORI(11,11,LOWER16(MIPS32_PRACC_PARAM_OUT)),
                MIPS32_NOP,
                                                                                                                        /* loop: */
                MIPS32_BEQ(0,10,9),                                                             /* beq 0, $10, end */
                MIPS32_NOP,
-               
+
                MIPS32_LBU(8,0,9),                                                                      /* lw $8,0($9), Load t4 with the byte @mem[t1] */
                MIPS32_SW(8,0,11),                                                                      /* sw $8,0($11) */
-               
+
                MIPS32_ADDI(10,10,NEG16(1)),                                            /* $10-- */
-               MIPS32_ADDI(9,9,1),                                                             /* $9+=1 */
-               MIPS32_ADDI(11,11,4),                                                           /* $11+=4 */
+               MIPS32_ADDI(9,9,1),                                                             /* $9 += 1 */
+               MIPS32_ADDI(11,11,4),                                                           /* $11 += 4 */
                MIPS32_NOP,
                MIPS32_B(NEG16(9)),                                                                     /* b loop */
                MIPS32_NOP,
@@ -516,35 +516,35 @@ int mips32_pracc_read_mem8(mips_ejtag_t *ejtag_info, u32 addr, int count, uint8_
                MIPS32_B(NEG16(31)),                                                            /* b start */
                MIPS32_NOP,
        };
-       
+
 //     /* TODO remove array */
-       u32 param_out[count];
+       uint32_t param_out[count];
        int i;
-       
+
 //     int retval;
        int blocksize;
        int bytesread;
-       u32 param_in[2];
-       
+       uint32_t param_in[2];
+
        bytesread = 0;
-       
+
 //     while (count > 0)
-       {       
+       {
                blocksize = count;
                if (count > 0x400)
                        blocksize = 0x400;
-               
+
                param_in[0] = addr;
                param_in[1] = blocksize;
-               
+
                mips32_pracc_exec(ejtag_info, sizeof(code)/sizeof(code[0]), code, \
                        sizeof(param_in)/sizeof(param_in[0]), param_in, count, param_out, 1);
-               
+
 //             count -= blocksize;
 //             addr += blocksize;
 //             bytesread += blocksize;
        }
-       
+
        for (i = 0; i < count; i++)
        {
                buf[i] = param_out[i];
@@ -553,7 +553,7 @@ int mips32_pracc_read_mem8(mips_ejtag_t *ejtag_info, u32 addr, int count, uint8_
        return ERROR_OK;
 }
 
-int mips32_pracc_write_mem(mips_ejtag_t *ejtag_info, u32 addr, int size, int count, void *buf)
+int mips32_pracc_write_mem(mips_ejtag_t *ejtag_info, uint32_t addr, int size, int count, void *buf)
 {
        switch (size)
        {
@@ -562,20 +562,20 @@ int mips32_pracc_write_mem(mips_ejtag_t *ejtag_info, u32 addr, int size, int cou
                case 2:
                        return mips32_pracc_write_mem16(ejtag_info, addr, count,(uint16_t*)buf);
                case 4:
-                       if(count==1)
-                               return mips32_pracc_write_u32(ejtag_info, addr, (u32*)buf);
+                       if (count == 1)
+                               return mips32_pracc_write_u32(ejtag_info, addr, (uint32_t*)buf);
                        else
-                               return mips32_pracc_write_mem32(ejtag_info, addr, count, (u32*)buf);
+                               return mips32_pracc_write_mem32(ejtag_info, addr, count, (uint32_t*)buf);
        }
-       
+
        return ERROR_OK;
 }
 
-int mips32_pracc_write_mem32(mips_ejtag_t *ejtag_info, u32 addr, int count, u32 *buf)
+int mips32_pracc_write_mem32(mips_ejtag_t *ejtag_info, uint32_t addr, int count, uint32_t *buf)
 {
 
 //NC: use destination pointer as loop counter (last address is in $10)
-       u32 code[] = {
+       uint32_t code[] = {
                                                                                                                        /* start: */
                MIPS32_MTC0(15,31,0),                                                           /* move $15 to COP0 DeSave */
                MIPS32_LUI(15,UPPER16(MIPS32_PRACC_STACK)),             /* $15 = MIPS32_PRACC_STACK */
@@ -584,19 +584,19 @@ int mips32_pracc_write_mem32(mips_ejtag_t *ejtag_info, u32 addr, int count, u32
                MIPS32_SW(9,0,15),                                                                      /* sw $9,($15) */
                MIPS32_SW(10,0,15),                                                             /* sw $10,($15) */
                MIPS32_SW(11,0,15),                                                             /* sw $11,($15) */
-               
+
                MIPS32_ADDI(8,15,NEG16(MIPS32_PRACC_STACK-MIPS32_PRACC_PARAM_IN)),  //$8= MIPS32_PRACC_PARAM_IN
                MIPS32_LW(9,0,8),                                                                       /* Load write addr to $9 */
                MIPS32_LW(10,4,8),      //last address                                                                  /* Load write count to $10 */
-               MIPS32_ADDI(8,8,8),     // $8+=8 beginning of data
+               MIPS32_ADDI(8,8,8),     // $8 += 8 beginning of data
 
 //loop:
                MIPS32_LW(11,0,8),                                                                      /* lw $11,0($8), Load $11 with the word @mem[$8] */
                MIPS32_SW(11,0,9),                                                                      /* sw $11,0($9) */
-               
-               MIPS32_ADDI(9,9,4),                                                             /* $9+=4 */
+
+               MIPS32_ADDI(9,9,4),                                                             /* $9 += 4 */
                MIPS32_BNE(10,9,NEG16(4)),  //was 9 BNE $10, 9, loop                                                                    /* b loop */
-               MIPS32_ADDI(8,8,4),  //this instruction is part of the loop (one delay slot)!   /* $8+=4 */
+               MIPS32_ADDI(8,8,4),  //this instruction is part of the loop (one delay slot)!   /* $8 += 4 */
                                                                                                                        /* end: */
                MIPS32_LW(11,0,15),                                                             /* lw $11,($15) */
                MIPS32_LW(10,0,15),                                                             /* lw $10,($15) */
@@ -606,30 +606,30 @@ int mips32_pracc_write_mem32(mips_ejtag_t *ejtag_info, u32 addr, int count, u32
                MIPS32_MFC0(15,31,0),                                                           /* move COP0 DeSave to $15 */
                MIPS32_NOP, //this one will not be executed
        };
-       
+
        /* TODO remove array */
-       u32 param_in[count+2];
+       uint32_t param_in[count + 2];
        param_in[0] = addr;
-       param_in[1] = addr + count * sizeof(u32);       //last address
-    
-       memcpy(&param_in[2], buf, count * sizeof(u32));
-       
+       param_in[1] = addr + count * sizeof(uint32_t);  //last address
+
+       memcpy(&param_in[2], buf, count * sizeof(uint32_t));
+
        mips32_pracc_exec(ejtag_info, sizeof(code)/sizeof(code[0]), code, \
                sizeof(param_in)/sizeof(param_in[0]),param_in, 0, NULL, 1);
 
        return ERROR_OK;
 }
 
-int mips32_pracc_write_u32(mips_ejtag_t *ejtag_info, u32 addr, u32 *buf)
+int mips32_pracc_write_u32(mips_ejtag_t *ejtag_info, uint32_t addr, uint32_t *buf)
 {
-       u32 code[] = {
+       uint32_t code[] = {
                                                                                                                        /* start: */
                MIPS32_MTC0(15,31,0),                                                           /* move $15 to COP0 DeSave */
                MIPS32_LUI(15,UPPER16(MIPS32_PRACC_STACK)),             /* $15 = MIPS32_PRACC_STACK */
                MIPS32_ORI(15,15,LOWER16(MIPS32_PRACC_STACK)),
                MIPS32_SW(8,0,15),                                                                      /* sw $8,($15) */
                MIPS32_SW(9,0,15),                                                                      /* sw $9,($15) */
-       
+
                MIPS32_LW(8,NEG16((MIPS32_PRACC_STACK-MIPS32_PRACC_PARAM_IN)-4), 15),  //load R8 @ param_in[1] = data
                MIPS32_LW(9,NEG16(MIPS32_PRACC_STACK-MIPS32_PRACC_PARAM_IN), 15),  //load R9 @ param_in[0] = address
 
@@ -643,7 +643,7 @@ int mips32_pracc_write_u32(mips_ejtag_t *ejtag_info, u32 addr, u32 *buf)
        };
 
        /* TODO remove array */
-       u32 param_in[1+1];
+       uint32_t param_in[1 + 1];
        param_in[0] = addr;
        param_in[1] = *buf;
 
@@ -653,9 +653,9 @@ int mips32_pracc_write_u32(mips_ejtag_t *ejtag_info, u32 addr, u32 *buf)
        return ERROR_OK;
 }
 
-int mips32_pracc_write_mem16(mips_ejtag_t *ejtag_info, u32 addr, int count, uint16_t *buf)
+int mips32_pracc_write_mem16(mips_ejtag_t *ejtag_info, uint32_t addr, int count, uint16_t *buf)
 {
-       u32 code[] = {
+       uint32_t code[] = {
                                                                                                                        /* start: */
                MIPS32_MTC0(15,31,0),                                                           /* move $15 to COP0 DeSave */
                MIPS32_LUI(15,UPPER16(MIPS32_PRACC_STACK)),             /* $15 = MIPS32_PRACC_STACK */
@@ -664,24 +664,24 @@ int mips32_pracc_write_mem16(mips_ejtag_t *ejtag_info, u32 addr, int count, uint
                MIPS32_SW(9,0,15),                                                                      /* sw $9,($15) */
                MIPS32_SW(10,0,15),                                                             /* sw $10,($15) */
                MIPS32_SW(11,0,15),                                                             /* sw $11,($15) */
-               
+
                MIPS32_LUI(8,UPPER16(MIPS32_PRACC_PARAM_IN)),           /* $8 = MIPS32_PRACC_PARAM_IN */
                MIPS32_ORI(8,8,LOWER16(MIPS32_PRACC_PARAM_IN)),
                MIPS32_LW(9,0,8),                                                                       /* Load write addr to $9 */
                MIPS32_LW(10,4,8),                                                                      /* Load write count to $10 */
-               MIPS32_ADDI(8,8,8),                                                             /* $8+=8 */
+               MIPS32_ADDI(8,8,8),                                                             /* $8 += 8 */
                MIPS32_NOP,
                                                                                                                        /* loop: */
                MIPS32_BEQ(0,10,9),                                                                     /* beq $0, $10, end */
                MIPS32_NOP,
-               
+
                MIPS32_LW(11,0,8),                                                                      /* lw $11,0($8), Load $11 with the word @mem[$8] */
                MIPS32_SH(11,0,9),                                                                      /* sh $11,0($9) */
-               
+
                MIPS32_ADDI(10,10,NEG16(1)),                                            /* $10-- */
-               MIPS32_ADDI(9,9,2),                                                             /* $9+=2 */
-               MIPS32_ADDI(8,8,4),                                                             /* $8+=4 */
-               
+               MIPS32_ADDI(9,9,2),                                                             /* $9 += 2 */
+               MIPS32_ADDI(8,8,4),                                                             /* $8 += 4 */
+
                MIPS32_NOP,
                MIPS32_B(NEG16(9)),                                                                     /* b loop */
                MIPS32_NOP,
@@ -695,27 +695,27 @@ int mips32_pracc_write_mem16(mips_ejtag_t *ejtag_info, u32 addr, int count, uint
                MIPS32_B(NEG16(30)),                                                            /* b start */
                MIPS32_NOP,
        };
-       
+
        /* TODO remove array */
-       u32 param_in[count+2];
+       uint32_t param_in[count + 2];
        int i;
        param_in[0] = addr;
        param_in[1] = count;
-       
+
        for (i = 0; i < count; i++)
        {
-               param_in[i+2] = buf[i];
+               param_in[i + 2] = buf[i];
        }
-       
+
        mips32_pracc_exec(ejtag_info, sizeof(code)/sizeof(code[0]), code, \
                sizeof(param_in)/sizeof(param_in[0]), param_in, 0, NULL, 1);
 
        return ERROR_OK;
 }
 
-int mips32_pracc_write_mem8(mips_ejtag_t *ejtag_info, u32 addr, int count, uint8_t *buf)
+int mips32_pracc_write_mem8(mips_ejtag_t *ejtag_info, uint32_t addr, int count, uint8_t *buf)
 {
-       u32 code[] = {
+       uint32_t code[] = {
                                                                                                                        /* start: */
                MIPS32_MTC0(15,31,0),                                                           /* move $15 to COP0 DeSave */
                MIPS32_LUI(15,UPPER16(MIPS32_PRACC_STACK)),             /* $15 = MIPS32_PRACC_STACK */
@@ -724,24 +724,24 @@ int mips32_pracc_write_mem8(mips_ejtag_t *ejtag_info, u32 addr, int count, uint8
                MIPS32_SW(9,0,15),                                                                      /* sw $9,($15) */
                MIPS32_SW(10,0,15),                                                             /* sw $10,($15) */
                MIPS32_SW(11,0,15),                                                             /* sw $11,($15) */
-               
+
                MIPS32_LUI(8,UPPER16(MIPS32_PRACC_PARAM_IN)),           /* $8 = MIPS32_PRACC_PARAM_IN */
                MIPS32_ORI(8,8,LOWER16(MIPS32_PRACC_PARAM_IN)),
                MIPS32_LW(9,0,8),                                                                       /* Load write addr to $9 */
                MIPS32_LW(10,4,8),                                                                      /* Load write count to $10 */
-               MIPS32_ADDI(8,8,8),                                                             /* $8+=8 */
+               MIPS32_ADDI(8,8,8),                                                             /* $8 += 8 */
                MIPS32_NOP,
                                                                                                                        /* loop: */
                MIPS32_BEQ(0,10,9),                                                                     /* beq $0, $10, end */
                MIPS32_NOP,
-               
+
                MIPS32_LW(11,0,8),                                                                      /* lw $11,0($8), Load $11 with the word @mem[$8] */
                MIPS32_SB(11,0,9),                                                                      /* sb $11,0($9) */
-               
+
                MIPS32_ADDI(10,10,NEG16(1)),                                            /* $10-- */
-               MIPS32_ADDI(9,9,1),                                                             /* $9+=1 */
-               MIPS32_ADDI(8,8,4),                                                             /* $8+=4 */
-               
+               MIPS32_ADDI(9,9,1),                                                             /* $9 += 1 */
+               MIPS32_ADDI(8,8,4),                                                             /* $8 += 4 */
+
                MIPS32_NOP,
                MIPS32_B(NEG16(9)),                                                                     /* b loop */
                MIPS32_NOP,
@@ -755,28 +755,28 @@ int mips32_pracc_write_mem8(mips_ejtag_t *ejtag_info, u32 addr, int count, uint8
                MIPS32_B(NEG16(30)),                                                            /* b start */
                MIPS32_NOP,
        };
-       
+
        /* TODO remove array */
-       u32 param_in[count+2];
+       uint32_t param_in[count + 2];
        int retval;
        int i;
        param_in[0] = addr;
        param_in[1] = count;
-       
+
        for (i = 0; i < count; i++)
        {
-               param_in[i+2] = buf[i];
+               param_in[i + 2] = buf[i];
        }
-       
+
        retval = mips32_pracc_exec(ejtag_info, sizeof(code)/sizeof(code[0]), code, \
                sizeof(param_in)/sizeof(param_in[0]), param_in, 0, NULL, 1);
 
        return retval;
 }
 
-int mips32_pracc_write_regs(mips_ejtag_t *ejtag_info, u32 *regs)
+int mips32_pracc_write_regs(mips_ejtag_t *ejtag_info, uint32_t *regs)
 {
-       u32 code[] = {
+       uint32_t code[] = {
                                                                                                                /* start: */
                MIPS32_LUI(2,UPPER16(MIPS32_PRACC_PARAM_IN)),   /* $2 = MIPS32_PRACC_PARAM_IN */
                MIPS32_ORI(2,2,LOWER16(MIPS32_PRACC_PARAM_IN)),
@@ -816,7 +816,7 @@ int mips32_pracc_write_regs(mips_ejtag_t *ejtag_info, u32 *regs)
                MIPS32_LW(29,29*4,1),                                                   /* lw $29,29*4($1) */
                MIPS32_LW(30,30*4,1),                                                   /* lw $30,30*4($1) */
                MIPS32_LW(31,31*4,1),                                                   /* lw $31,31*4($1) */
-               
+
                MIPS32_LW(2,32*4,1),                                                    /* lw $2,32*4($1) */
                MIPS32_MTC0(2,12,0),                                                    /* move $2 to status */
                MIPS32_LW(2,33*4,1),                                                    /* lw $2,33*4($1) */
@@ -829,7 +829,7 @@ int mips32_pracc_write_regs(mips_ejtag_t *ejtag_info, u32 *regs)
                MIPS32_MTC0(2,13,0),                                                    /* move $2 to cause*/
                MIPS32_LW(2,37*4,1),                                                    /* lw $2,37*4($1) */
                MIPS32_MTC0(2,24,0),                                                    /* move $2 to pc */
-               
+
                MIPS32_LW(2,2*4,1),                                                     /* lw $2,2*4($1) */
                MIPS32_LW(1,0,15),                                                              /* lw $1,($15) */
                MIPS32_MFC0(15,31,0),                                                   /* move COP0 DeSave to $15 */
@@ -837,18 +837,18 @@ int mips32_pracc_write_regs(mips_ejtag_t *ejtag_info, u32 *regs)
                MIPS32_B(NEG16(55)),                                                    /* b start */
                MIPS32_NOP,
        };
-       
+
        int retval;
-       
+
        retval = mips32_pracc_exec(ejtag_info, sizeof(code)/sizeof(code[0]), code, \
                38, regs, 0, NULL, 1);
-       
+
        return retval;
 }
 
-int mips32_pracc_read_regs(mips_ejtag_t *ejtag_info, u32 *regs)
+int mips32_pracc_read_regs(mips_ejtag_t *ejtag_info, uint32_t *regs)
 {
-       u32 code[] = {
+       uint32_t code[] = {
                                                                                                                /* start: */
                MIPS32_MTC0(2,31,0),                                                    /* move $2 to COP0 DeSave */
                MIPS32_LUI(2,UPPER16(MIPS32_PRACC_PARAM_OUT)),  /* $2 = MIPS32_PRACC_PARAM_OUT */
@@ -893,7 +893,7 @@ int mips32_pracc_read_regs(mips_ejtag_t *ejtag_info, u32 *regs)
                MIPS32_SW(29,29*4,1),                                                   /* sw $29,29*4($1) */
                MIPS32_SW(30,30*4,1),                                                   /* sw $30,30*4($1) */
                MIPS32_SW(31,31*4,1),                                                   /* sw $31,31*4($1) */
-               
+
                MIPS32_MFC0(2,12,0),                                                    /* move status to $2 */
                MIPS32_SW(2,32*4,1),                                                    /* sw $2,32*4($1) */
                MIPS32_MFLO(2),                                                                 /* move lo to $2 */
@@ -906,7 +906,7 @@ int mips32_pracc_read_regs(mips_ejtag_t *ejtag_info, u32 *regs)
                MIPS32_SW(2,36*4,1),                                                    /* sw $2,36*4($1) */
                MIPS32_MFC0(2,24,0),                                                    /* move pc to $2 */
                MIPS32_SW(2,37*4,1),                                                    /* sw $2,37*4($1) */
-               
+
                MIPS32_LW(2,0,15),                                                              /* lw $2,($15) */
                MIPS32_LW(1,0,15),                                                              /* lw $1,($15) */
                MIPS32_MFC0(15,31,0),                                                   /* move COP0 DeSave to $15 */
@@ -914,11 +914,11 @@ int mips32_pracc_read_regs(mips_ejtag_t *ejtag_info, u32 *regs)
                MIPS32_B(NEG16(60)),                                                    /* b start */
                MIPS32_NOP,
        };
-       
+
        int retval;
-       
+
        retval = mips32_pracc_exec(ejtag_info, sizeof(code)/sizeof(code[0]), code, \
                0, NULL, 38, regs, 1);
-       
+
        return retval;
 }
Open On-Chip Debugger

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)