cortex_a hybrid & context breakpoints
authorHeythem Bouhaja <heythem.bouhaja@stericsson.com>
Mon, 9 May 2011 08:40:35 +0000 (10:40 +0200)
committerØyvind Harboe <oyvind.harboe@zylin.com>
Tue, 30 Aug 2011 16:27:52 +0000 (18:27 +0200)
src/target/breakpoints.c
src/target/breakpoints.h
src/target/cortex_a.c
src/target/target.c
src/target/target.h
src/target/target_type.h

index e6eb673..5a0fc40 100644 (file)
@@ -72,6 +72,7 @@ int breakpoint_add_internal(struct target *target, uint32_t address, uint32_t le
 
        (*breakpoint_p) = malloc(sizeof(struct breakpoint));
        (*breakpoint_p)->address = address;
+       (*breakpoint_p)->asid = 0;
        (*breakpoint_p)->length = length;
        (*breakpoint_p)->type = type;
        (*breakpoint_p)->set = 0;
@@ -107,6 +108,117 @@ fail:
        return ERROR_OK;
 }
 
+int context_breakpoint_add_internal(struct target *target, uint32_t asid, uint32_t length, enum breakpoint_type type)
+{
+       struct breakpoint *breakpoint = target->breakpoints;
+       struct breakpoint **breakpoint_p = &target->breakpoints;
+       int retval;
+       int n;
+
+       n = 0;
+       while (breakpoint)
+       {
+               n++;
+               if (breakpoint->asid == asid) 
+               {
+                       /* FIXME don't assume "same address" means "same
+                        * breakpoint" ... check all the parameters before
+                        * succeeding.
+                        */
+                       LOG_DEBUG("Duplicate Breakpoint asid: 0x%08" PRIx32 " (BP %d)",
+                                       asid, breakpoint->unique_id );
+                       return -1;
+               }
+               breakpoint_p = &breakpoint->next;
+               breakpoint = breakpoint->next;
+       }
+
+       (*breakpoint_p) = malloc(sizeof(struct breakpoint));
+       (*breakpoint_p)->address = 0;
+       (*breakpoint_p)->asid = asid;
+       (*breakpoint_p)->length = length;
+       (*breakpoint_p)->type = type;
+       (*breakpoint_p)->set = 0;
+       (*breakpoint_p)->orig_instr = malloc(length);
+       (*breakpoint_p)->next = NULL;
+       (*breakpoint_p)->unique_id = bpwp_unique_id++;
+       retval = target_add_context_breakpoint(target, *breakpoint_p);
+       if (retval != ERROR_OK)
+       {
+               LOG_ERROR("could not add breakpoint");
+               free((*breakpoint_p)->orig_instr);
+               free(*breakpoint_p);
+               *breakpoint_p = NULL;
+               return retval;
+       }
+
+       LOG_DEBUG("added %s Context breakpoint at 0x%8.8" PRIx32 " of length 0x%8.8x, (BPID: %d)",
+                       breakpoint_type_strings[(*breakpoint_p)->type],
+                       (*breakpoint_p)->asid, (*breakpoint_p)->length,
+                       (*breakpoint_p)->unique_id  );
+
+       return ERROR_OK;
+}
+
+int hybrid_breakpoint_add_internal(struct target *target, uint32_t address, uint32_t asid, uint32_t length, enum breakpoint_type type)
+{      
+       struct breakpoint *breakpoint = target->breakpoints;
+       struct breakpoint **breakpoint_p = &target->breakpoints;
+       int retval;
+       int n;
+       n = 0;
+       while (breakpoint)
+       {
+               n++;
+               if ((breakpoint->asid == asid) && (breakpoint->address == address)) {
+                       /* FIXME don't assume "same address" means "same
+                        * breakpoint" ... check all the parameters before
+                        * succeeding.
+                        */
+                       LOG_DEBUG("Duplicate Hybrid Breakpoint asid: 0x%08" PRIx32 " (BP %d)",
+                                       asid, breakpoint->unique_id );
+                       return -1;
+               }
+               else if ((breakpoint->address == address) && (breakpoint->asid == 0)) 
+               {
+                       LOG_DEBUG("Duplicate Breakpoint IVA: 0x%08" PRIx32 " (BP %d)",
+                                       address, breakpoint->unique_id );
+                       return -1;
+                       
+               }
+               breakpoint_p = &breakpoint->next;
+               breakpoint = breakpoint->next;
+       }
+       (*breakpoint_p) = malloc(sizeof(struct breakpoint));
+       (*breakpoint_p)->address = address;
+       (*breakpoint_p)->asid = asid;
+       (*breakpoint_p)->length = length;
+       (*breakpoint_p)->type = type;
+       (*breakpoint_p)->set = 0;
+       (*breakpoint_p)->orig_instr = malloc(length);
+       (*breakpoint_p)->next = NULL;
+       (*breakpoint_p)->unique_id = bpwp_unique_id++;
+
+
+       retval = target_add_hybrid_breakpoint(target, *breakpoint_p);
+       if (retval != ERROR_OK)
+       {
+               LOG_ERROR("could not add breakpoint");
+               free((*breakpoint_p)->orig_instr);
+               free(*breakpoint_p);
+               *breakpoint_p = NULL;
+               return retval;
+       }
+       LOG_DEBUG("added %s Hybrid breakpoint at address 0x%8.8" PRIx32 " of length 0x%8.8x, (BPID: %d)",
+                       breakpoint_type_strings[(*breakpoint_p)->type],
+                       (*breakpoint_p)->address, (*breakpoint_p)->length,
+                       (*breakpoint_p)->unique_id  );
+
+       return ERROR_OK;
+}
+
+
+
 int breakpoint_add(struct target *target, uint32_t address, uint32_t length, enum breakpoint_type type)
 {
 
@@ -129,6 +241,50 @@ int retval = ERROR_OK;
        return(breakpoint_add_internal(target, address, length, type));
 
 }
+int context_breakpoint_add(struct target *target, uint32_t asid, uint32_t length, enum breakpoint_type type)
+{
+
+int retval = ERROR_OK;
+    if (target->smp)
+       {
+               struct target_list *head;
+               struct target *curr;
+               head = target->head;
+               while(head != (struct target_list*)NULL)
+               {
+                       curr = head->target;
+                       retval = context_breakpoint_add_internal(curr, asid,length, type);
+                       if (retval != ERROR_OK) return retval;
+                       head = head->next;      
+               }
+               return retval;
+       }
+       else
+       return(context_breakpoint_add_internal(target, asid, length, type));
+
+}
+int hybrid_breakpoint_add(struct target *target, uint32_t address, uint32_t asid, uint32_t length, enum breakpoint_type type)
+{
+
+int retval = ERROR_OK;
+    if (target->smp)
+       {
+               struct target_list *head;
+               struct target *curr;
+               head = target->head;
+               while(head != (struct target_list*)NULL)
+               {
+                       curr = head->target;
+                       retval = hybrid_breakpoint_add_internal(curr, address, asid, length, type);
+                       if (retval != ERROR_OK) return retval;
+                       head = head->next;      
+               }
+               return retval;
+       }
+       else
+       return(hybrid_breakpoint_add_internal(target, address, asid, length, type));
+
+}
 
 /* free up a breakpoint */
 static void breakpoint_free(struct target *target, struct breakpoint *breakpoint_to_remove)
@@ -162,7 +318,11 @@ void breakpoint_remove_internal(struct target *target, uint32_t address)
 
        while (breakpoint)
        {
-               if (breakpoint->address == address)
+               if ((breakpoint->address == address) && (breakpoint->asid == 0))
+                       break;
+               else if ((breakpoint->address == 0) && (breakpoint->asid == address))
+                       break;
+               else if ((breakpoint->address == address) && (breakpoint->asid != 0))
                        break;
                breakpoint = breakpoint->next;
        }
index ee4d9d1..912117f 100644 (file)
@@ -38,12 +38,14 @@ enum watchpoint_rw
 struct breakpoint
 {
        uint32_t address;
+       uint32_t asid;
        int length;
        enum breakpoint_type type;
        int set;
        uint8_t *orig_instr;
        struct breakpoint *next;
-       int unique_id;
+       uint32_t unique_id;
+       int linked_BRP; 
 };
 
 struct watchpoint
@@ -61,6 +63,10 @@ struct watchpoint
 void breakpoint_clear_target(struct target *target);
 int breakpoint_add(struct target *target,
                uint32_t address, uint32_t length, enum breakpoint_type type);
+int context_breakpoint_add(struct target *target,
+               uint32_t asid, uint32_t length, enum breakpoint_type type);
+int hybrid_breakpoint_add(struct target *target,
+               uint32_t address, uint32_t asid, uint32_t length, enum breakpoint_type type);
 void breakpoint_remove(struct target *target, uint32_t address);
 
 struct breakpoint* breakpoint_find(struct target *target, uint32_t address);
index 9b8ba41..39f1b9e 100755 (executable)
@@ -53,6 +53,10 @@ static int cortex_a8_debug_entry(struct target *target);
 static int cortex_a8_restore_context(struct target *target, bool bpwp);
 static int cortex_a8_set_breakpoint(struct target *target,
                struct breakpoint *breakpoint, uint8_t matchmode);
+static int cortex_a8_set_context_breakpoint(struct target *target,
+               struct breakpoint *breakpoint, uint8_t matchmode);
+static int cortex_a8_set_hybrid_breakpoint(struct target *target,
+               struct breakpoint *breakpoint);
 static int cortex_a8_unset_breakpoint(struct target *target,
                struct breakpoint *breakpoint);
 static int cortex_a8_dap_read_coreregister_u32(struct target *target,
@@ -1422,6 +1426,141 @@ static int cortex_a8_set_breakpoint(struct target *target,
        return ERROR_OK;
 }
 
+static int cortex_a8_set_context_breakpoint(struct target *target,
+               struct breakpoint *breakpoint, uint8_t matchmode)
+{
+       int retval = ERROR_FAIL;
+       int brp_i=0;
+       uint32_t control;
+       uint8_t byte_addr_select = 0x0F;
+       struct cortex_a8_common *cortex_a8 = target_to_cortex_a8(target);
+       struct armv7a_common *armv7a = &cortex_a8->armv7a_common;
+       struct cortex_a8_brp * brp_list = cortex_a8->brp_list;
+       
+       if (breakpoint->set)
+       {
+               LOG_WARNING("breakpoint already set");
+               return retval ;
+       }
+       /*check available context BRPs*/
+       while ((brp_list[brp_i].used || (brp_list[brp_i].type!=BRP_CONTEXT)) && (brp_i < cortex_a8->brp_num))
+                       brp_i++ ;
+       
+       if (brp_i >= cortex_a8->brp_num)
+       {
+               LOG_ERROR("ERROR Can not find free Breakpoint Register Pair");
+               return ERROR_FAIL;
+       }
+
+       breakpoint->set = brp_i + 1;
+       control = ((matchmode & 0x7) << 20)
+                               | (byte_addr_select << 5)
+                               | (3 << 1) | 1;
+       brp_list[brp_i].used = 1;
+       brp_list[brp_i].value = (breakpoint->asid);
+       brp_list[brp_i].control = control;
+       retval = cortex_a8_dap_write_memap_register_u32(target, armv7a->debug_base
+                       + CPUDBG_BVR_BASE + 4 * brp_list[brp_i].BRPn, 
+                       brp_list[brp_i].value);
+       if(retval != ERROR_OK)
+               return retval;
+       retval = cortex_a8_dap_write_memap_register_u32(target, armv7a->debug_base
+                       + CPUDBG_BCR_BASE + 4 * brp_list[brp_i].BRPn,
+                       brp_list[brp_i].control);
+       if(retval != ERROR_OK)
+               return retval;
+       LOG_DEBUG("brp %i control 0x%0" PRIx32 " value 0x%0" PRIx32, brp_i,
+       brp_list[brp_i].control,
+       brp_list[brp_i].value);
+       return ERROR_OK;
+               
+}
+
+static int cortex_a8_set_hybrid_breakpoint(struct target *target, struct breakpoint *breakpoint)
+{
+       int retval = ERROR_FAIL;
+       int brp_1=0; //holds the contextID pair
+       int brp_2=0; // holds the IVA pair
+       uint32_t control_CTX, control_IVA;
+       uint8_t CTX_byte_addr_select = 0x0F;
+       uint8_t IVA_byte_addr_select = 0x0F;
+       uint8_t CTX_machmode = 0x03;
+       uint8_t IVA_machmode = 0x01;
+       struct cortex_a8_common *cortex_a8 = target_to_cortex_a8(target);
+       struct armv7a_common *armv7a = &cortex_a8->armv7a_common;
+       struct cortex_a8_brp * brp_list = cortex_a8->brp_list;
+       
+       
+       
+       if (breakpoint->set)
+       {
+               LOG_WARNING("breakpoint already set");
+               return retval ;
+       }
+       /*check available context BRPs*/
+       while ((brp_list[brp_1].used || (brp_list[brp_1].type!=BRP_CONTEXT)) && (brp_1 < cortex_a8->brp_num))
+                       brp_1++ ;
+       
+       printf("brp(CTX) found num: %d \n",brp_1);
+       if (brp_1 >= cortex_a8->brp_num)
+       {
+               LOG_ERROR("ERROR Can not find free Breakpoint Register Pair");
+               return ERROR_FAIL;
+       }
+
+       while ((brp_list[brp_2].used || (brp_list[brp_2].type!=BRP_NORMAL)) && (brp_2 < cortex_a8->brp_num))
+                       brp_2++ ;
+       
+       printf("brp(IVA) found num: %d \n",brp_2);
+       if (brp_2 >= cortex_a8->brp_num)
+       {
+               LOG_ERROR("ERROR Can not find free Breakpoint Register Pair");
+               return ERROR_FAIL;
+       }
+
+       breakpoint->set = brp_1 + 1;
+       breakpoint->linked_BRP= brp_2;
+       control_CTX = ((CTX_machmode & 0x7) << 20)
+                               | (brp_2 << 16)
+                               | (0 << 14)
+                               | (CTX_byte_addr_select << 5)
+                               | (3 << 1) | 1;
+               brp_list[brp_1].used = 1;
+               brp_list[brp_1].value = (breakpoint->asid);
+               brp_list[brp_1].control = control_CTX;
+               retval = cortex_a8_dap_write_memap_register_u32(target, armv7a->debug_base
+                               + CPUDBG_BVR_BASE + 4 * brp_list[brp_1].BRPn, 
+                               brp_list[brp_1].value);
+               if (retval != ERROR_OK)
+                       return retval;
+               retval = cortex_a8_dap_write_memap_register_u32(target, armv7a->debug_base
+                               + CPUDBG_BCR_BASE + 4 * brp_list[brp_1].BRPn,
+                               brp_list[brp_1].control);
+               if( retval != ERROR_OK )
+                       return retval;
+
+               control_IVA = ((IVA_machmode & 0x7) << 20)
+                               | (brp_1 << 16)
+                               | (IVA_byte_addr_select << 5)
+                               | (3 << 1) | 1;
+               brp_list[brp_2].used = 1;
+               brp_list[brp_2].value = (breakpoint->address & 0xFFFFFFFC);
+               brp_list[brp_2].control = control_IVA;
+               retval = cortex_a8_dap_write_memap_register_u32(target, armv7a->debug_base
+                               + CPUDBG_BVR_BASE + 4 * brp_list[brp_2].BRPn, 
+                               brp_list[brp_2].value);
+               if (retval != ERROR_OK)
+                       return retval;
+               retval = cortex_a8_dap_write_memap_register_u32(target, armv7a->debug_base
+                               + CPUDBG_BCR_BASE + 4 * brp_list[brp_2].BRPn,
+                               brp_list[brp_2].control);
+               if (retval != ERROR_OK )
+                       return retval;
+
+       return ERROR_OK;
+}
+
+
 static int cortex_a8_unset_breakpoint(struct target *target, struct breakpoint *breakpoint)
 {
        int retval;
@@ -1437,27 +1576,81 @@ static int cortex_a8_unset_breakpoint(struct target *target, struct breakpoint *
 
        if (breakpoint->type == BKPT_HARD)
        {
-               int brp_i = breakpoint->set - 1;
-               if ((brp_i < 0) || (brp_i >= cortex_a8->brp_num))
+               if ((breakpoint->address != 0) && (breakpoint->asid != 0))
                {
-                       LOG_DEBUG("Invalid BRP number in breakpoint");
+                       int brp_i = breakpoint->set - 1;
+                       int brp_j = breakpoint->linked_BRP;
+                       if ((brp_i < 0) || (brp_i >= cortex_a8->brp_num))
+                       {
+                               LOG_DEBUG("Invalid BRP number in breakpoint");
+                               return ERROR_OK;
+                       }
+                       LOG_DEBUG("rbp %i control 0x%0" PRIx32 " value 0x%0" PRIx32, brp_i,
+                                       brp_list[brp_i].control, brp_list[brp_i].value);
+                       brp_list[brp_i].used = 0;
+                       brp_list[brp_i].value = 0;
+                       brp_list[brp_i].control = 0;
+                       retval = cortex_a8_dap_write_memap_register_u32(target, armv7a->debug_base
+                                       + CPUDBG_BCR_BASE + 4 * brp_list[brp_i].BRPn,
+                                       brp_list[brp_i].control);
+                       if (retval != ERROR_OK)
+                               return retval;
+                       retval = cortex_a8_dap_write_memap_register_u32(target, armv7a->debug_base
+                                       + CPUDBG_BVR_BASE + 4 * brp_list[brp_i].BRPn,
+                                       brp_list[brp_i].value);
+                       if (retval != ERROR_OK)
+                               return retval;                                          
+                       if ((brp_j < 0) || (brp_j >= cortex_a8->brp_num))
+                       {
+                               LOG_DEBUG("Invalid BRP number in breakpoint");
+                               return ERROR_OK;
+                       }
+                       LOG_DEBUG("rbp %i control 0x%0" PRIx32 " value 0x%0" PRIx32, brp_j,
+                                       brp_list[brp_j].control, brp_list[brp_j].value);
+                       brp_list[brp_j].used = 0;
+                       brp_list[brp_j].value = 0;
+                       brp_list[brp_j].control = 0;
+                       retval = cortex_a8_dap_write_memap_register_u32(target, armv7a->debug_base
+                                       + CPUDBG_BCR_BASE + 4 * brp_list[brp_j].BRPn,
+                                       brp_list[brp_j].control);
+                       if (retval != ERROR_OK)
+                               return retval;
+                       retval = cortex_a8_dap_write_memap_register_u32(target, armv7a->debug_base
+                                       + CPUDBG_BVR_BASE + 4 * brp_list[brp_j].BRPn,
+                                       brp_list[brp_j].value);
+                       if (retval != ERROR_OK)
+                               return retval;
+                       breakpoint->linked_BRP = 0;
+                       breakpoint->set = 0;
                        return ERROR_OK;
+                       
                }
-               LOG_DEBUG("rbp %i control 0x%0" PRIx32 " value 0x%0" PRIx32, brp_i,
-                               brp_list[brp_i].control, brp_list[brp_i].value);
-               brp_list[brp_i].used = 0;
-               brp_list[brp_i].value = 0;
-               brp_list[brp_i].control = 0;
-               retval = cortex_a8_dap_write_memap_register_u32(target, armv7a->debug_base
-                               + CPUDBG_BCR_BASE + 4 * brp_list[brp_i].BRPn,
-                               brp_list[brp_i].control);
-               if (retval != ERROR_OK)
-                       return retval;
-               retval = cortex_a8_dap_write_memap_register_u32(target, armv7a->debug_base
-                               + CPUDBG_BVR_BASE + 4 * brp_list[brp_i].BRPn,
-                               brp_list[brp_i].value);
-               if (retval != ERROR_OK)
-                       return retval;
+               else
+               {
+                       int brp_i = breakpoint->set - 1;
+                       if ((brp_i < 0) || (brp_i >= cortex_a8->brp_num))
+                       {
+                               LOG_DEBUG("Invalid BRP number in breakpoint");
+                               return ERROR_OK;
+                       }
+                       LOG_DEBUG("rbp %i control 0x%0" PRIx32 " value 0x%0" PRIx32, brp_i,
+                                       brp_list[brp_i].control, brp_list[brp_i].value);
+                       brp_list[brp_i].used = 0;
+                       brp_list[brp_i].value = 0;
+                       brp_list[brp_i].control = 0;
+                       retval = cortex_a8_dap_write_memap_register_u32(target, armv7a->debug_base
+                                       + CPUDBG_BCR_BASE + 4 * brp_list[brp_i].BRPn,
+                                       brp_list[brp_i].control);
+                       if (retval != ERROR_OK)
+                               return retval;
+                       retval = cortex_a8_dap_write_memap_register_u32(target, armv7a->debug_base
+                                       + CPUDBG_BVR_BASE + 4 * brp_list[brp_i].BRPn,
+                                       brp_list[brp_i].value);
+                       if (retval != ERROR_OK)
+                               return retval;
+                       breakpoint->set = 0;
+                       return ERROR_OK;
+               }                                       
        }
        else
        {
@@ -1501,6 +1694,41 @@ static int cortex_a8_add_breakpoint(struct target *target,
        return cortex_a8_set_breakpoint(target, breakpoint, 0x00); /* Exact match */
 }
 
+static int cortex_a8_add_context_breakpoint(struct target *target,
+               struct breakpoint *breakpoint)
+{
+       struct cortex_a8_common *cortex_a8 = target_to_cortex_a8(target);
+
+       if ((breakpoint->type == BKPT_HARD) && (cortex_a8->brp_num_available < 1))
+       {
+               LOG_INFO("no hardware breakpoint available");
+               return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
+       }
+
+       if (breakpoint->type == BKPT_HARD)
+               cortex_a8->brp_num_available--;
+
+       return cortex_a8_set_context_breakpoint(target, breakpoint, 0x02); /* asid match */
+}
+
+static int cortex_a8_add_hybrid_breakpoint(struct target *target,
+               struct breakpoint *breakpoint)
+{
+       struct cortex_a8_common *cortex_a8 = target_to_cortex_a8(target);
+
+       if ((breakpoint->type == BKPT_HARD) && (cortex_a8->brp_num_available < 1))
+       {
+               LOG_INFO("no hardware breakpoint available");
+               return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
+       }
+
+       if (breakpoint->type == BKPT_HARD)
+               cortex_a8->brp_num_available--;
+
+       return cortex_a8_set_hybrid_breakpoint(target, breakpoint); /* ??? */
+}
+
+
 static int cortex_a8_remove_breakpoint(struct target *target, struct breakpoint *breakpoint)
 {
        struct cortex_a8_common *cortex_a8 = target_to_cortex_a8(target);
@@ -2546,6 +2774,8 @@ struct target_type cortexa8_target = {
        .run_algorithm = armv4_5_run_algorithm,
 
        .add_breakpoint = cortex_a8_add_breakpoint,
+       .add_context_breakpoint = cortex_a8_add_context_breakpoint,
+       .add_hybrid_breakpoint = cortex_a8_add_hybrid_breakpoint,
        .remove_breakpoint = cortex_a8_remove_breakpoint,
        .add_watchpoint = NULL,
        .remove_watchpoint = NULL,
index b71d839..be9742f 100644 (file)
@@ -772,6 +772,27 @@ int target_add_breakpoint(struct target *target,
        }
        return target->type->add_breakpoint(target, breakpoint);
 }
+
+int target_add_context_breakpoint(struct target *target,
+               struct breakpoint *breakpoint)
+{
+       if (target->state != TARGET_HALTED) {
+               LOG_WARNING("target %s is not halted", target->cmd_name);
+               return ERROR_TARGET_NOT_HALTED;
+       }
+       return target->type->add_context_breakpoint(target, breakpoint);
+}
+
+int target_add_hybrid_breakpoint(struct target *target,
+               struct breakpoint *breakpoint)
+{
+       if (target->state != TARGET_HALTED) {
+               LOG_WARNING("target %s is not halted", target->cmd_name);
+               return ERROR_TARGET_NOT_HALTED;
+       }
+       return target->type->add_hybrid_breakpoint(target, breakpoint);
+}
+
 int target_remove_breakpoint(struct target *target,
                struct breakpoint *breakpoint)
 {
@@ -2919,7 +2940,7 @@ static int handle_bp_command_list(struct command_context *cmd_ctx)
                {
                        char* buf = buf_to_str(breakpoint->orig_instr,
                                        breakpoint->length, 16);
-                       command_print(cmd_ctx, "0x%8.8" PRIx32 ", 0x%x, %i, 0x%s",
+                       command_print(cmd_ctx, "IVA breakpoint: 0x%8.8" PRIx32 ", 0x%x, %i, 0x%s",
                                        breakpoint->address,
                                        breakpoint->length,
                                        breakpoint->set, buf);
@@ -2927,9 +2948,22 @@ static int handle_bp_command_list(struct command_context *cmd_ctx)
                }
                else
                {
-                       command_print(cmd_ctx, "0x%8.8" PRIx32 ", 0x%x, %i",
-                                                 breakpoint->address,
-                                                 breakpoint->length, breakpoint->set);
+                       if ((breakpoint->address == 0) && (breakpoint->asid != 0))
+                               command_print(cmd_ctx, "Context breakpoint: 0x%8.8" PRIx32 ", 0x%x, %i",
+                                                       breakpoint->asid,
+                                                       breakpoint->length, breakpoint->set);
+                       else if ((breakpoint->address != 0) && (breakpoint->asid != 0))
+                       {
+                               command_print(cmd_ctx, "Hybrid breakpoint(IVA): 0x%8.8" PRIx32 ", 0x%x, %i",
+                                                       breakpoint->address,
+                                                       breakpoint->length, breakpoint->set);
+                               command_print(cmd_ctx, "\t|--->linked with ContextID: 0x%8.8" PRIx32,
+                                                       breakpoint->asid);
+                       }
+                       else
+                               command_print(cmd_ctx, "Breakpoint(IVA): 0x%8.8" PRIx32 ", 0x%x, %i",
+                                                       breakpoint->address,
+                                                       breakpoint->length, breakpoint->set);
                }
 
                breakpoint = breakpoint->next;
@@ -2938,43 +2972,90 @@ static int handle_bp_command_list(struct command_context *cmd_ctx)
 }
 
 static int handle_bp_command_set(struct command_context *cmd_ctx,
-               uint32_t addr, uint32_t length, int hw)
+               uint32_t addr, uint32_t asid, uint32_t length, int hw)
 {
        struct target *target = get_current_target(cmd_ctx);
-       int retval = breakpoint_add(target, addr, length, hw);
-       if (ERROR_OK == retval)
-               command_print(cmd_ctx, "breakpoint set at 0x%8.8" PRIx32 "", addr);
-       else
-               LOG_ERROR("Failure setting breakpoint");
-       return retval;
+       
+               if (asid == 0)
+               {       int retval = breakpoint_add(target, addr, length, hw);
+                       if (ERROR_OK == retval)
+                               command_print(cmd_ctx, "breakpoint set at 0x%8.8" PRIx32 "", addr);
+                       else
+                       {
+                               LOG_ERROR("Failure setting breakpoint, the same address(IVA) is already used");
+                               return retval;
+                       }
+               }
+               else if (addr == 0)
+               {
+                       int retval = context_breakpoint_add(target, asid, length, hw);
+                       if (ERROR_OK == retval)
+                               command_print(cmd_ctx, "Context breakpoint set at 0x%8.8" PRIx32 "", asid);
+                       else
+                       {
+                               LOG_ERROR("Failure setting breakpoint, the same address(CONTEXTID) is already used");
+                               return retval;
+                       }
+               }
+               else
+               {       
+                       int retval = hybrid_breakpoint_add(target, addr, asid, length, hw);
+                       if(ERROR_OK == retval)
+                       command_print(cmd_ctx, "Hybrid breakpoint set at 0x%8.8" PRIx32 "", asid);
+                       else
+                       {
+                               LOG_ERROR("Failure setting breakpoint, the same address is already used");
+                               return retval;
+                       }
+               }
+       return ERROR_OK;
+
+       
 }
 
 COMMAND_HANDLER(handle_bp_command)
 {
-       if (CMD_ARGC == 0)
-               return handle_bp_command_list(CMD_CTX);
-
-       if (CMD_ARGC < 2 || CMD_ARGC > 3)
-       {
-               command_print(CMD_CTX, "usage: bp <address> <length> ['hw']");
-               return ERROR_COMMAND_SYNTAX_ERROR;
-       }
-
        uint32_t addr;
-       COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
+       uint32_t asid;
        uint32_t length;
-       COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], length);
-
        int hw = BKPT_SOFT;
-       if (CMD_ARGC == 3)
+       switch(CMD_ARGC)
        {
-               if (strcmp(CMD_ARGV[2], "hw") == 0)
+               case 0:
+                       return handle_bp_command_list(CMD_CTX);
+               case 3:
+
+                       if(strcmp(CMD_ARGV[2], "hw") == 0)
+                       {
+                               hw = BKPT_HARD;
+                               COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
+
+                               COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], length);
+
+                               asid = 0;
+                               return handle_bp_command_set(CMD_CTX, addr, asid, length, hw);
+                       }
+                       else if(strcmp(CMD_ARGV[2], "hw_ctx") == 0)
+                       {
+                               hw = BKPT_HARD;
+                               COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], asid);
+                               COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], length);
+                               addr = 0;
+                               return handle_bp_command_set(CMD_CTX, addr, asid, length, hw);
+                       }
+
+               case 4:
                        hw = BKPT_HARD;
-               else
+                       COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
+                       COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], asid);
+                       COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], length);
+                       return handle_bp_command_set(CMD_CTX, addr, asid, length, hw);
+               default:
+                       command_print(CMD_CTX, "usage: bp <address> [<asid>]<length> ['hw'|'hw_ctx']");
                        return ERROR_COMMAND_SYNTAX_ERROR;
        }
 
-       return handle_bp_command_set(CMD_CTX, addr, length, hw);
+       
 }
 
 COMMAND_HANDLER(handle_rbp_command)
@@ -5467,7 +5548,7 @@ static const struct command_registration target_exec_command_handlers[] = {
                .handler = handle_bp_command,
                .mode = COMMAND_EXEC,
                .help = "list or set hardware or software breakpoint",
-               .usage = "[address length ['hw']]",
+               .usage = "usage: bp <address> [<asid>]<length> ['hw'|'hw_ctx']",
        },
        {
                .name = "rbp",
index 1b5730f..5248d69 100644 (file)
@@ -369,10 +369,25 @@ static inline void target_set_examined(struct target *target)
 int target_add_breakpoint(struct target *target,
                struct breakpoint *breakpoint);
 /**
+ * Add the @a ContextID breakpoint  for @a target.
+ *
+ * This routine is a wrapper for target->type->add_context_breakpoint.
+ */
+int target_add_context_breakpoint(struct target *target,
+               struct breakpoint *breakpoint);
+/**
+ * Add the @a ContextID & IVA breakpoint  for @a target.
+ *
+ * This routine is a wrapper for target->type->add_hybrid_breakpoint.
+ */
+int target_add_hybrid_breakpoint(struct target *target,
+               struct breakpoint *breakpoint);
+/**
  * Remove the @a breakpoint for @a target.
  *
  * This routine is a wrapper for target->type->remove_breakpoint.
  */
+
 int target_remove_breakpoint(struct target *target,
                struct breakpoint *breakpoint);
 /**
index 6059c40..fc062da 100644 (file)
@@ -148,6 +148,8 @@ struct target_type
         * Upon GDB connection all breakpoints/watchpoints are cleared.
         */
        int (*add_breakpoint)(struct target *target, struct breakpoint *breakpoint);
+       int (*add_context_breakpoint)(struct target *target, struct breakpoint *breakpoint);
+       int (*add_hybrid_breakpoint)(struct target *target, struct breakpoint *breakpoint);
 
        /* remove breakpoint. hw will only be updated if the target
         * is currently halted.