gdb-5.0-bdm-m68k.patch

WaitForSingleObject 摩托罗拉的68k源程序

+	cf_breakpoint_count = 0;
+	if (bdmWriteSystemRegister (BDM_REG_TDR, TDR_TRC_HALT) < 0)
+		bdm_report_error ();
+	return(0);
+}
+
+int
+cf_stopped_by_watchpoint(void)
+{
+	return hit_watchpoint;
+}
+
+int
+cf_can_use_watchpoint(type, cnt, ot)
+	enum target_hw_bp_type type;
+	int cnt;
+	int ot;
+{
+	unsigned long tdr;
+
+	if (cpu_type != BDM_COLDFIRE)  {
+		return(0);
+	}
+
+	if (type == bp_hardware_breakpoint || type == bp_read_watchpoint ||
+	    type == bp_hardware_watchpoint || type == bp_access_watchpoint)  {
+		if (cnt <= 1)  {
+			return(1);
+		}
+	}
+
+	return(-1);
+}
+
+int
+cf_insert_hw_breakpoint(addr, shadow)
+	CORE_ADDR addr;
+	char *shadow;
+{
+	unsigned long tdr;
+
+	if (cpu_type != BDM_COLDFIRE)  {
+		return(-1);
+	}
+
+	if (cf_breakpoint_count < CF_BREAKPOINT_MAX)  {
+		cf_breakpoints[cf_breakpoint_count].type = hw_execute;
+		cf_breakpoints[cf_breakpoint_count].addr = addr;
+		cf_breakpoints[cf_breakpoint_count++].len = 2;
+
+		if (bdmReadSystemRegister (BDM_REG_TDR, &tdr) < 0)
+			bdm_report_error ();
+		tdr = ((tdr & ~TDR_L1_ALL) | (TDR_L1_EBL|TDR_L1_EPC));
+		if (bdmWriteSystemRegister (BDM_REG_PBR, addr) < 0)
+			bdm_report_error ();
+		if (bdmWriteSystemRegister (BDM_REG_PBMR, 0) < 0)
+			bdm_report_error ();
+		if (bdmWriteSystemRegister (BDM_REG_TDR, tdr) < 0)
+			bdm_report_error ();
+		if (bdmDebugLevel)
+			printf_filtered ("Insert PC Breakpoint @0x%08x\n", addr);
+	}
+	else  {
+		return(-1);
+	}
+	return(0);
+}
+
+static int
+cf_check_breakpoint(type, addr, len)
+	enum target_hw_bp_type type;
+	CORE_ADDR addr;
+	int len;
+{
+	int i;
+
+	for (i = 0; i < cf_breakpoint_count; i++)  {
+		if (cf_breakpoints[i].type == type &&
+		    cf_breakpoints[i].addr == addr &&
+		    cf_breakpoints[i].len == len)  {
+			for (; i < CF_BREAKPOINT_MAX-1; i++)  {
+				cf_breakpoints[i] = cf_breakpoints[i+1];
+			}
+			cf_breakpoint_count--;
+			return(1);
+		}
+	}
+	return(0);
+}
+
+int
+cf_remove_hw_breakpoint(addr, shadow)
+	CORE_ADDR addr;
+	char *shadow;
+{
+	unsigned long tdr;
+	unsigned long csr;
+
+	if (cpu_type != BDM_COLDFIRE)  {
+		return(-1);
+	}
+
+	if (cf_check_breakpoint(hw_execute, addr, 2))  {
+		if (bdmReadSystemRegister (BDM_REG_TDR, &tdr) < 0)
+			bdm_report_error ();
+		tdr &= ~TDR_L1_EPC;
+		if ((tdr & TDR_L1_ALL) == 0)  {
+			tdr &= ~TDR_L1_EBL;
+		}
+		if (bdmWriteSystemRegister (BDM_REG_TDR, tdr) < 0)
+			bdm_report_error ();
+		if (bdmDebugLevel)
+			printf_filtered ("Remove PC Breakpoint @0x%08x\n", addr);
+	}
+	else  {
+		return(-1);
+	}
+	return(0);
+}
+
+#define AATR_READONLY  0x7F85
+#define AATR_WRITEONLY 0x7F05
+#define AATR_READWRITE 0xFF05
+
+int
+cf_insert_watchpoint(addr, len, type)
+	CORE_ADDR addr;
+	int len;
+	enum target_hw_bp_type type;
+{
+	unsigned long tdr;
+
+	if (cpu_type != BDM_COLDFIRE)  {
+		return(-1);
+	}
+
+	if (cf_breakpoint_count < CF_BREAKPOINT_MAX)  {
+		cf_breakpoints[cf_breakpoint_count].type = type;
+		cf_breakpoints[cf_breakpoint_count].addr = addr;
+		cf_breakpoints[cf_breakpoint_count++].len = len;
+
+		if (bdmReadSystemRegister (BDM_REG_TDR, &tdr) < 0)
+			bdm_report_error ();
+		tdr = ((tdr & ~TDR_L1_ALL) | (TDR_L1_EBL|TDR_L1_EAR));
+		if (bdmWriteSystemRegister (BDM_REG_ABLR, addr) < 0)
+			bdm_report_error ();
+		if (bdmWriteSystemRegister (BDM_REG_ABHR, addr+len-1) < 0)
+			bdm_report_error ();
+		if (type == hw_read)  {
+			if (bdmWriteSystemRegister (BDM_REG_AATR, AATR_READONLY) < 0)
+				bdm_report_error ();
+			if (bdmDebugLevel)
+				printf_filtered ("Insert read Watchpoint @0x%08x-0x%08x\n",
+				                 addr, addr+len-1);
+		}
+		else if (type == hw_write)  {
+			if (bdmWriteSystemRegister (BDM_REG_AATR, AATR_WRITEONLY) < 0)
+				bdm_report_error ();
+			if (bdmDebugLevel)
+				printf_filtered ("Insert write Watchpoint @0x%08x-0x%08x\n",
+				                 addr, addr+len-1);
+		}
+		else  {
+			if (bdmWriteSystemRegister (BDM_REG_AATR, AATR_READWRITE) < 0)
+				bdm_report_error ();
+			if (bdmDebugLevel)
+				printf_filtered ("Insert access Watchpoint @0x%08x-0x%08x\n",
+				                 addr, addr+len-1);
+		}
+		if (bdmWriteSystemRegister (BDM_REG_TDR, tdr) < 0)
+			bdm_report_error ();
+	}
+	else  {
+		return(-1);
+	}
+	return(0);
+}
+
+int
+cf_remove_watchpoint(addr, len, type)
+	CORE_ADDR addr;
+	int len;
+	enum target_hw_bp_type type;
+{
+	unsigned long tdr;
+	unsigned long csr;
+
+	if (cpu_type != BDM_COLDFIRE)  {
+		return(-1);
+	}
+
+	if (cf_check_breakpoint(type, addr, len))  {
+		if (bdmReadSystemRegister (BDM_REG_TDR, &tdr) < 0)
+			bdm_report_error ();
+		tdr &= ~TDR_L1_EAR;
+		if ((tdr & TDR_L1_ALL) == 0)  {
+			tdr &= ~TDR_L1_EBL;
+		}
+		if (bdmWriteSystemRegister (BDM_REG_TDR, tdr) < 0)
+			bdm_report_error ();
+		if (bdmDebugLevel)
+			printf_filtered ("Remove %s Watchpoint @0x%08x-0x%08x\n",
+			                 (type == hw_read) ? "read" :
+			                  ((type == hw_write) ? "write" : "access"),
+			                 addr, addr+len-1);
+	}
+	else  {
+		return(-1);
+	}
+	return(0);
+}
+
+int
+cf_stopped_data_address()
+{
+	unsigned long tdr;
+	unsigned long ablr;
+
+	if (cpu_type != BDM_COLDFIRE)  {
+		return(-1);
+	}
+
+	if (bdmReadSystemRegister (BDM_REG_TDR, &tdr) < 0)
+		bdm_report_error ();
+	if (bdmReadSystemRegister (BDM_REG_ABLR, &ablr) < 0)
+		bdm_report_error ();
+
+	if (tdr & TDR_L1_EAR)  {
+		return(ablr);
+	}
+	return(0);
+}
+
+/* This is called not only when we first attach, but also when the
+   user types "run" after having attached.  */
+void
+bdm_create_inferior (char *execfile, char *args, char **env)
+{
+	char *prg_file = NULL;
+	unsigned long entry_pt;
+
+	clear_proceed_status ();
+	init_wait_for_inferior ();
+	if (*args) {
+		prg_file = args;
+	}
+	else {
+		prg_file = execfile;
+	}
+	if (!(prg_file) && !(bdm_prog_loaded))
+		error ("No program specified to run\n");
+	if (bdm_prog_loaded)
+		printf_filtered ("Note: `%s' has already been loaded.\n", bdm_prog_loaded);
+	if (query ("Do you want to download `%s'?", prg_file))
+		bdm_load (prg_file, 0);
+	if (bdmReadSystemRegister (BDM_REG_RPC, &entry_pt) < 0)
+		bdm_report_error ();
+	proceed (entry_pt, TARGET_SIGNAL_DEFAULT, 0);
+}
+
+/*
+ * Fetch register REGNO, or all user registers if REGNO is -1.
+ */
+static void
+bdm_fetch_register (int regno)
+{
+	unsigned long l;
+	char cbuf[4];
+	int ret;
+
+	if (regno < 0) {
+		for (regno = 0 ; regno < NUM_REGS ; regno++)
+			bdm_fetch_register (regno);
+	}
+	else {
+		/*
+		 * When the target is running the 
+		 * cpu registers can not be accessed.
+		 */
+		if (bdm_gdb_no_wait && (bdm_get_status () == 0)) {
+			l = 0;
+			ret = 0;
+	 	}
+		else {
+			if (regno < 16) {
+				ret = bdmReadRegister (regno, &l);
+			}
+			else {
+				if ((regno - 16) < (sizeof (reg_to_dev_num) / sizeof (int))) {
+					ret = bdmReadSystemRegister (reg_to_dev_num[regno - 16], &l);
+				}
+				else {
+					error ("Bad register number (%d)", regno); 
+					return;
+				}
+			}
+		}
+		if (ret < 0)
+			bdm_report_error ();
+		cbuf[0] = l >> 24;
+		cbuf[1] = l >> 16;
+		cbuf[2] = l >> 8;
+		cbuf[3] = l;
+		supply_register (regno, cbuf);
+	}
+}
+
+void
+bdm_prepare_to_store (void)
+{
+	/* Do nothing, since we can store individual regs */
+}
+
+/*
+ * Store register REGNO, or all user registers if REGNO == -1.
+ */
+void
+bdm_store_register (int regno)
+{
+	unsigned long l;
+	int ret;
+
+	if (bdm_gdb_no_wait && (bdm_get_status () == 0))
+		return;
+  
+	if (regno == -1) {
+		for (regno = 0 ; regno < NUM_REGS ; regno++)
+			bdm_store_register (regno);
+	}
+	else {
+		l = read_register (regno);
+		if (regno < 16) {
+			ret = bdmWriteRegister (regno, l);
+		}
+		else {
+			if ((regno - 16) < (sizeof (reg_to_dev_num) / sizeof (int))) {
+				ret = bdmWriteSystemRegister (reg_to_dev_num[regno - 16], l);
+			}
+			else {
+				error ("Bad register number (%d)", regno); 
+				return;
+			}
+		}
+		if (ret < 0)
+			bdm_report_error ();
+	}
+}
+
+/*
+ * Transfer memory contents between target and host
+ */
+static int
+bdm_xfer_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len, int write, struct target_ops *t)
+{
+	int ret;
+
+	if (write)
+		ret = bdmWriteMemory (memaddr, myaddr, len);
+	else
+		ret = bdmReadMemory (memaddr, myaddr, len);
+	if (ret < 0)
+		bdm_report_error ();
+	return len;
+}
+
+static void
+bdm_files_info (struct target_ops *t)
+{
+	printf_filtered ("target %s is attached to %s\n", t->to_shortname, dev_name);
+	if (bdm_prog_loaded) {
+		printf_filtered ("and running program %s\n", bdm_prog_loaded);
+	}
+	else {
+		printf_filtered ("no program loaded\n");
+	}
+}
+
+/*
+ * Load a file.
+ */
+static void
+bdm_load (char *args, int from_tty)
+{
+	char *p;
+
+	if (bdm_prog_loaded) {
+		free (bdm_prog_loaded);
+		bdm_prog_loaded = NULL;
+	}
+	if (!args) {
+		error (
+		 "The bdmload command must include the filename to load.\n"
+			     "You may want to use 'run', which uses the file given\n"
+				 "on the command line when gdb was invoked.");
+	}
+	if ((bdm_get_status () & BDM_TARGETSTOPPED) == 0)
+		bdm_stop_chip ();
+
+	/* strip off additional (unwanted) arguments after file name */
+	for (p = args; (*p != '\0') && (!isspace (*p)); p++) ;
+	*p = '\0';
+
+	if (loadExecutable (args) < 0)
+		error ("%s", downloadErrorString);
+	bdm_prog_loaded = savestring (args, strlen (args));
+}
+
+/*
+ * Select a CPU32 processor register set.
+ */
+static void
+bdm_select_cpu32 (char *args, int from_tty)
+{
+	bdm_reg_names = cpu32_reg_names;
+}
+
+struct target_ops bdm_ops;
+
+static void
+init_bdm_ops(void)
+{
+	bdm_ops.to_shortname = "bdm";
+	bdm_ops.to_longname = "CPU32 and Coldfire Background Debug Mode Interface for downloading and remote debugging";
+	bdm_ops.to_doc = "Uses the Public Domain Background Debug Mode Interface connected to the\n"
+"BDM-port of the CPU32 or Coldfire based microcontroller and to a parallel port\n"
+"of the PC.\n"
+"Usage: target bdm <device>\n"
+"where <device> is the BDM character special file (e.g. /dev/bdm0).";
+	bdm_ops.to_open = bdm_open;
+	bdm_ops.to_close = bdm_close;
+	bdm_ops.to_detach = bdm_detach;
+	bdm_ops.to_resume = bdm_resume;
+	bdm_ops.to_wait = bdm_wait;
+	bdm_ops.to_fetch_registers = bdm_fetch_register;
+	bdm_ops.to_store_registers = bdm_store_register;
+	bdm_ops.to_prepare_to_store = bdm_prepare_to_store;
+	bdm_ops.to_xfer_memory = bdm_xfer_inferior_memory;
+	bdm_ops.to_files_info = bdm_files_info;
+	bdm_ops.to_insert_breakpoint = memory_insert_breakpoint;
+	bdm_ops.to_remove_breakpoint = memory_remove_breakpoint;
+	bdm_ops.to_kill = bdm_kill;
+	bdm_ops.to_load = bdm_load;
+	bdm_ops.to_create_inferior = bdm_create_inferior;
+	bdm_ops.to_mourn_inferior = generic_mourn_inferior;
+	bdm_ops.to_can_run = bdm_can_run;
+	bdm_ops.to_stratum = process_stratum;
+	bdm_ops.to_has_all_memory = 1;
+	bdm_ops.to_has_memory = 1;
+	bdm_ops.to_has_stack = 1;
+	bdm_ops.to_has_registers = 1;
+	bdm_ops.to_has_execution = 1;
+	bdm_ops.to_magic = OPS_MAGIC;
+};
+
+void
+_initialize_remote_bdmcf (void)
+{
+	init_bdm_ops ();
+	add_com ("bdm_reset", class_obscure,
+		 (void (*)(char *, int))bdm_reset,
+		 "Reset target and enter BDM mode.");
+	add_com ("bdm_release", class_obscure,
+		 (void (*)(char *, int))bdm_release_chip,
+		 "Reset target without BDM-mode.");
+	add_com ("bdm_status", class_obscure,
+		 (void (*)(char *, int))bdm_get_status_interactive,
+		 "Show status of bdm interface\n");
+	add_com ("bdm_setdelay", class_obscure,
+		 bdm_setdelay_interactive,
+		 "set delay for download");
+	add_com ("bdm_setdebug", class_obscure,
+		 bdm_setdebug_interactive,
+		 "enable/disable BDM diagnostic messages");
+	add_com ("bdm_setdriverdebug", class_obscure,
+		 bdm_setdriverdebug_interactive,
+		 "enable/disable BDM driver diagnostic messages");
+	add_com ("bdm_no_wait", class_obscure,
+		 bdm_set_no_wait,
+		 "Cause GDB to not wait for the target to stop when running.");
+	add_com ("bdm_wait", class_obscure,
+		 bdm_set_wait,
+		 "Cause GDB to wait for the target to stop when running.");
+	add_com ("bdm_stop", class_obscure,
+		 bdm_issue_stop,
+		 "Stop the target if running.");
+	add_com ("bdm-select-cpu32", class_obscure,
+		 bdm_select_cpu32,
+		 "Selects the CPU32 register set rather than the default CPU32+.");
+           
+	add_target (&bdm_ops);
+}