rtos : ps command

[fw/openocd] / src / target / mips_m4k.c

diff --git a/src/target/mips_m4k.c b/src/target/mips_m4k.c
index e4ab044ab7039d2c00c4a843ac34930b5b1235dd..4546093f216c4d5b9f866b7b91433641cd712e1d 100644 (file)
--- a/src/target/mips_m4k.c
+++ b/src/target/mips_m4k.c
@@ -865,40 +865,54 @@ static int mips_m4k_read_memory(struct target *target, uint32_t address,
 
        /* sanitize arguments */
        if (((size != 4) && (size != 2) && (size != 1)) || (count == 0) || !(buffer))
-               return ERROR_INVALID_ARGUMENTS;
+               return ERROR_COMMAND_SYNTAX_ERROR;
 
        if (((size == 4) && (address & 0x3u)) || ((size == 2) && (address & 0x1u)))
                return ERROR_TARGET_UNALIGNED_ACCESS;
 
+       /* since we don't know if buffer is aligned, we allocate new mem that is always aligned */
+       void *t = NULL;
+
+       if (size > 1)
+       {
+               t = malloc(count * size * sizeof(uint8_t));
+               if (t == NULL)
+               {
+                       LOG_ERROR("Out of memory");
+                       return ERROR_FAIL;
+               }
+       }
+       else
+       {
+               t = buffer;
+       }
+
        /* if noDMA off, use DMAACC mode for memory read */
        int retval;
        if (ejtag_info->impcode & EJTAG_IMP_NODMA)
-               retval = mips32_pracc_read_mem(ejtag_info, address, size, count, (void *)buffer);
+               retval = mips32_pracc_read_mem(ejtag_info, address, size, count, t);
        else
-               retval = mips32_dmaacc_read_mem(ejtag_info, address, size, count, (void *)buffer);
-       if (ERROR_OK != retval)
-               return retval;
+               retval = mips32_dmaacc_read_mem(ejtag_info, address, size, count, t);
 
        /* mips32_..._read_mem with size 4/2 returns uint32_t/uint16_t in host */
        /* endianness, but byte array should represent target endianness       */
-       uint32_t i, t32;
-       uint16_t t16;
-       for(i = 0; i < (count*size); i += size)
+       if (ERROR_OK == retval)
        {
                switch(size)
                {
                case 4:
-                       t32 = le_to_h_u32(&buffer[i]);
-                       target_buffer_set_u32(target,&buffer[i], t32);
+                       target_buffer_set_u32_array(target,buffer,count,t);
                        break;
                case 2:
-                       t16 = le_to_h_u16(&buffer[i]);
-                       target_buffer_set_u16(target,&buffer[i], t16);
+                       target_buffer_set_u16_array(target,buffer,count,t);
                        break;
                }
        }
 
-       return ERROR_OK;
+       if ((size > 1) && (t != NULL))
+               free(t);
+
+       return retval;
 }
 
 static int mips_m4k_write_memory(struct target *target, uint32_t address,
@@ -918,41 +932,33 @@ static int mips_m4k_write_memory(struct target *target, uint32_t address,
 
        /* sanitize arguments */
        if (((size != 4) && (size != 2) && (size != 1)) || (count == 0) || !(buffer))
-               return ERROR_INVALID_ARGUMENTS;
+               return ERROR_COMMAND_SYNTAX_ERROR;
 
        if (((size == 4) && (address & 0x3u)) || ((size == 2) && (address & 0x1u)))
                return ERROR_TARGET_UNALIGNED_ACCESS;
 
        /** correct endianess if we have word or hword access */
-       uint8_t *t = NULL;
+       void *t = NULL;
        if (size > 1)
        {
                /* mips32_..._write_mem with size 4/2 requires uint32_t/uint16_t in host */
                /* endianness, but byte array represents target endianness               */
-               t = malloc(count * sizeof(uint32_t));
+               t = malloc(count * size * sizeof(uint8_t));
                if (t == NULL)
                {
                        LOG_ERROR("Out of memory");
                        return ERROR_FAIL;
                }
 
-               uint32_t i, t32;
-               uint16_t t16;
-               for(i = 0; i < (count*size); i += size)
+               switch(size)
                {
-                       switch(size)
-                       {
-                       case 4:
-                               t32 = target_buffer_get_u32(target,&buffer[i]);
-                               h_u32_to_le(&t[i], t32);
-                               break;
-                       case 2:
-                               t16 = target_buffer_get_u16(target,&buffer[i]);
-                               h_u16_to_le(&t[i], t16);
-                               break;
-                       }
+               case 4:
+                       target_buffer_get_u32_array(target,buffer,count,(uint32_t*)t);
+                       break;
+               case 2:
+                       target_buffer_get_u16_array(target,buffer,count,(uint16_t*)t);
+                       break;
                }
-
                buffer = t;
        }
 
@@ -1078,7 +1084,7 @@ static int mips_m4k_bulk_write_memory(struct target *target, uint32_t address,
 
        /* mips32_pracc_fastdata_xfer requires uint32_t in host endianness, */
        /* but byte array represents target endianness                      */
-       uint8_t * t = NULL;
+       uint32_t *t = NULL;
        t = malloc(count * sizeof(uint32_t));
        if (t == NULL)
        {
@@ -1086,15 +1092,10 @@ static int mips_m4k_bulk_write_memory(struct target *target, uint32_t address,
                return ERROR_FAIL;
        }
 
-       uint32_t i, t32;
-       for(i = 0; i < (count*4); i += 4)
-       {
-               t32 = target_buffer_get_u32(target,&buffer[i]);
-               h_u32_to_le(&t[i], t32);
-       }
+       target_buffer_get_u32_array(target,buffer,count,t);
 
        retval = mips32_pracc_fastdata_xfer(ejtag_info, mips32->fast_data_area, write_t, address,
-                       count, (uint32_t*) (void *)t);
+                       count, t);
 
        if (t != NULL)
                free(t);
@@ -1139,7 +1140,7 @@ COMMAND_HANDLER(mips_m4k_handle_cp0_command)
        /* two or more argument, access a single register/select (write if third argument is given) */
        if (CMD_ARGC < 2)
        {
-               command_print(CMD_CTX, "command requires more arguments.");
+           return ERROR_COMMAND_SYNTAX_ERROR;
        }
        else
        {