Commit | Line | Data |
---|---|---|
35ce4f08 | 1 | /* Remote target communications for the Macraigor Systems BDM Wiggler |
2549d2b3 | 2 | talking to a Motorola PPC 8xx ADS board |
35ce4f08 GN |
3 | Copyright 1996, 1997 Free Software Foundation, Inc. |
4 | ||
5 | This file is part of GDB. | |
6 | ||
7 | This program is free software; you can redistribute it and/or modify | |
8 | it under the terms of the GNU General Public License as published by | |
9 | the Free Software Foundation; either version 2 of the License, or | |
10 | (at your option) any later version. | |
11 | ||
12 | This program is distributed in the hope that it will be useful, | |
13 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | GNU General Public License for more details. | |
16 | ||
17 | You should have received a copy of the GNU General Public License | |
18 | along with this program; if not, write to the Free Software | |
19 | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ | |
20 | ||
21 | #include "defs.h" | |
22 | #include "gdbcore.h" | |
23 | #include "gdb_string.h" | |
24 | #include <fcntl.h> | |
25 | #include "frame.h" | |
26 | #include "inferior.h" | |
27 | #include "bfd.h" | |
28 | #include "symfile.h" | |
29 | #include "target.h" | |
30 | #include "wait.h" | |
31 | #include "gdbcmd.h" | |
32 | #include "objfiles.h" | |
33 | #include "gdb-stabs.h" | |
34 | #include <sys/types.h> | |
35 | #include <signal.h> | |
36 | #include "serial.h" | |
37 | #include "ocd.h" | |
38 | ||
39 | static void bdm_ppc_open PARAMS ((char *name, int from_tty)); | |
40 | ||
41 | static int bdm_ppc_wait PARAMS ((int pid, | |
42 | struct target_waitstatus *target_status)); | |
43 | ||
44 | static void bdm_ppc_fetch_registers PARAMS ((int regno)); | |
45 | ||
46 | static void bdm_ppc_store_registers PARAMS ((int regno)); | |
47 | ||
48 | extern struct target_ops bdm_ppc_ops; /* Forward decl */ | |
49 | \f | |
2549d2b3 GN |
50 | /*#define BDM_NUM_REGS 71*/ |
51 | #define BDM_NUM_REGS 24 | |
52 | ||
53 | #define BDM_REGMAP \ | |
54 | 2048, 2049, 2050, 2051, 2052, 2053, 2054, 2055, /* r0-r7 */ \ | |
55 | 2056, 2057, 2058, 2059, 2060, 2061, 2062, 2063, /* r8-r15 */ \ | |
56 | 2064, 2065, 2066, 2067, 2068, 2069, 2070, 2071, /* r16-r23 */ \ | |
57 | 2072, 2073, 2074, 2075, 2076, 2077, 2078, 2079, /* r24-r31 */ \ | |
58 | \ | |
59 | 2080, 2082, 2084, 2086, 2088, 2090, 2092, 2094, /* fp0->fp8 */ \ | |
60 | 2096, 2098, 2100, 2102, 2104, 2106, 2108, 2110, /* fp0->fp8 */ \ | |
61 | 2112, 2114, 2116, 2118, 2120, 2122, 2124, 2126, /* fp0->fp8 */ \ | |
62 | 2128, 2130, 2132, 2134, 2136, 2138, 2140, 2142, /* fp0->fp8 */ \ | |
63 | \ | |
64 | 26, /* pc (SRR0 (SPR 26)) */ \ | |
65 | 2146, /* ps (MSR) */ \ | |
66 | 2144, /* cnd (CR) */ \ | |
67 | 8, /* lr (SPR 8) */ \ | |
68 | 9, /* cnt (CTR (SPR 9)) */ \ | |
69 | 1, /* xer (SPR 1) */ \ | |
70 | 0, /* mq (SPR 0) */ | |
35ce4f08 | 71 | |
2549d2b3 | 72 | \f |
160db9b2 GN |
73 | char nowatchdog[4] = {0xff,0xff,0xff,0x88}; |
74 | ||
2549d2b3 GN |
75 | /* Open a connection to a remote debugger. |
76 | NAME is the filename used for communication. */ | |
77 | ||
35ce4f08 GN |
78 | static void |
79 | bdm_ppc_open (name, from_tty) | |
80 | char *name; | |
81 | int from_tty; | |
82 | { | |
160db9b2 GN |
83 | CORE_ADDR watchdogaddr = 0xff000004; |
84 | ||
706eff3f | 85 | ocd_open (name, from_tty, OCD_TARGET_MOTO_PPC, &bdm_ppc_ops); |
160db9b2 GN |
86 | |
87 | /* We want interrupts to drop us into debugging mode. */ | |
88 | /* Modify the DER register to accomplish this. */ | |
89 | ocd_write_bdm_register (149, 0x20024000); | |
90 | ||
91 | /* Disable watchdog timer on the board */ | |
92 | ocd_write_bytes (watchdogaddr, nowatchdog, 4); | |
35ce4f08 GN |
93 | } |
94 | ||
95 | /* Wait until the remote machine stops, then return, | |
96 | storing status in STATUS just as `wait' would. | |
97 | Returns "pid" (though it's not clear what, if anything, that | |
98 | means in the case of this target). */ | |
99 | ||
100 | static int | |
101 | bdm_ppc_wait (pid, target_status) | |
102 | int pid; | |
103 | struct target_waitstatus *target_status; | |
104 | { | |
105 | int stop_reason; | |
106 | ||
107 | target_status->kind = TARGET_WAITKIND_STOPPED; | |
108 | ||
706eff3f | 109 | stop_reason = ocd_wait (); |
35ce4f08 GN |
110 | |
111 | if (stop_reason) | |
112 | { | |
113 | target_status->value.sig = TARGET_SIGNAL_INT; | |
114 | return inferior_pid; | |
115 | } | |
116 | ||
117 | target_status->value.sig = TARGET_SIGNAL_TRAP; /* XXX for now */ | |
118 | ||
61a0d022 | 119 | #if 0 |
35ce4f08 GN |
120 | { |
121 | unsigned long ecr, der; | |
122 | ||
706eff3f GN |
123 | ecr = ocd_read_bdm_register (148); /* Read the exception cause register */ |
124 | der = ocd_read_bdm_register (149); /* Read the debug enables register */ | |
35ce4f08 GN |
125 | fprintf_unfiltered (gdb_stdout, "ecr = 0x%x, der = 0x%x\n", ecr, der); |
126 | } | |
61a0d022 | 127 | #endif |
35ce4f08 GN |
128 | |
129 | return inferior_pid; | |
130 | } | |
131 | \f | |
132 | static int bdm_regmap[] = {BDM_REGMAP}; | |
133 | ||
134 | /* Read the remote registers into regs. | |
2549d2b3 | 135 | Fetch register REGNO, or all registers if REGNO == -1 |
35ce4f08 GN |
136 | |
137 | The Wiggler uses the following codes to access the registers: | |
138 | ||
139 | 0 -> 1023 SPR 0 -> 1023 | |
140 | 0 - SPR 0 - MQ | |
141 | 1 - SPR 1 - XER | |
142 | 8 - SPR 8 - LR | |
143 | 9 - SPR 9 - CTR (known as cnt in GDB) | |
144 | 26 - SPR 26 - SRR0 - pc | |
145 | 1024 -> 2047 DCR 0 -> DCR 1023 (IBM PPC 4xx only) | |
146 | 2048 -> 2079 R0 -> R31 | |
2549d2b3 | 147 | 2080 -> 2143 FP0 -> FP31 (64 bit regs) (IBM PPC 5xx only) |
35ce4f08 GN |
148 | 2144 CR (known as cnd in GDB) |
149 | 2145 FPCSR | |
150 | 2146 MSR (known as ps in GDB) | |
151 | */ | |
152 | ||
153 | static void | |
154 | bdm_ppc_fetch_registers (regno) | |
155 | int regno; | |
156 | { | |
157 | int i; | |
2549d2b3 GN |
158 | unsigned char *regs, *beginregs, *endregs, *almostregs; |
159 | unsigned char midregs[32]; | |
160 | unsigned char mqreg[1]; | |
35ce4f08 GN |
161 | int first_regno, last_regno; |
162 | int first_bdm_regno, last_bdm_regno; | |
2549d2b3 GN |
163 | int reglen, beginreglen, endreglen; |
164 | ||
165 | #if 1 | |
166 | for (i = 0; i < (FPLAST_REGNUM - FP0_REGNUM + 1); i++) | |
167 | { | |
168 | midregs[i] = -1; | |
169 | } | |
170 | mqreg[0] = -1; | |
171 | #endif | |
35ce4f08 GN |
172 | |
173 | if (regno == -1) | |
174 | { | |
175 | first_regno = 0; | |
176 | last_regno = NUM_REGS - 1; | |
177 | ||
178 | first_bdm_regno = 0; | |
179 | last_bdm_regno = BDM_NUM_REGS - 1; | |
180 | } | |
181 | else | |
182 | { | |
183 | first_regno = regno; | |
184 | last_regno = regno; | |
185 | ||
186 | first_bdm_regno = bdm_regmap [regno]; | |
187 | last_bdm_regno = bdm_regmap [regno]; | |
188 | } | |
189 | ||
190 | if (first_bdm_regno == -1) | |
191 | { | |
192 | supply_register (first_regno, NULL); | |
193 | return; /* Unsupported register */ | |
194 | } | |
195 | ||
2549d2b3 GN |
196 | #if 1 |
197 | /* Can't ask for floating point regs on ppc 8xx, also need to | |
198 | avoid asking for the mq register. */ | |
199 | if (first_regno == last_regno) /* only want one reg */ | |
200 | { | |
201 | /* printf("Asking for register %d\n", first_regno); */ | |
202 | ||
203 | /* if asking for an invalid register */ | |
204 | if ((first_regno == MQ_REGNUM) || | |
205 | ((first_regno >= FP0_REGNUM) && (first_regno <= FPLAST_REGNUM))) | |
206 | { | |
207 | /* printf("invalid reg request!\n"); */ | |
208 | supply_register (first_regno, NULL); | |
209 | return; /* Unsupported register */ | |
210 | } | |
211 | else | |
212 | { | |
213 | regs = ocd_read_bdm_registers (first_bdm_regno, | |
214 | last_bdm_regno, ®len); | |
215 | } | |
216 | } | |
217 | else /* want all regs */ | |
218 | { | |
219 | /* printf("Asking for registers %d to %d\n", first_regno, last_regno); */ | |
220 | beginregs = ocd_read_bdm_registers (first_bdm_regno, | |
221 | FP0_REGNUM - 1, &beginreglen); | |
222 | endregs = (strcat (midregs, | |
223 | ocd_read_bdm_registers (FPLAST_REGNUM + 1, | |
224 | last_bdm_regno - 1, &endreglen))); | |
225 | almostregs = (strcat (beginregs, endregs)); | |
226 | regs = (strcat (almostregs, mqreg)); | |
227 | reglen = beginreglen + 32 + endreglen + 1; | |
228 | } | |
229 | ||
230 | #endif | |
231 | #if 0 | |
706eff3f | 232 | regs = ocd_read_bdm_registers (first_bdm_regno, last_bdm_regno, ®len); |
2549d2b3 | 233 | #endif |
35ce4f08 GN |
234 | |
235 | for (i = first_regno; i <= last_regno; i++) | |
236 | { | |
237 | int bdm_regno, regoffset; | |
238 | ||
239 | bdm_regno = bdm_regmap [i]; | |
240 | if (bdm_regno != -1) | |
241 | { | |
242 | regoffset = bdm_regno - first_bdm_regno; | |
243 | ||
244 | if (regoffset >= reglen / 4) | |
245 | continue; | |
246 | ||
247 | supply_register (i, regs + 4 * regoffset); | |
248 | } | |
249 | else | |
250 | supply_register (i, NULL); /* Unsupported register */ | |
251 | } | |
252 | } | |
253 | ||
254 | /* Store register REGNO, or all registers if REGNO == -1, from the contents | |
255 | of REGISTERS. FIXME: ignores errors. */ | |
256 | ||
257 | static void | |
258 | bdm_ppc_store_registers (regno) | |
259 | int regno; | |
260 | { | |
261 | int i; | |
262 | int first_regno, last_regno; | |
263 | int first_bdm_regno, last_bdm_regno; | |
264 | ||
265 | if (regno == -1) | |
266 | { | |
267 | first_regno = 0; | |
268 | last_regno = NUM_REGS - 1; | |
269 | ||
270 | first_bdm_regno = 0; | |
271 | last_bdm_regno = BDM_NUM_REGS - 1; | |
272 | } | |
273 | else | |
274 | { | |
275 | first_regno = regno; | |
276 | last_regno = regno; | |
277 | ||
278 | first_bdm_regno = bdm_regmap [regno]; | |
279 | last_bdm_regno = bdm_regmap [regno]; | |
280 | } | |
281 | ||
282 | if (first_bdm_regno == -1) | |
283 | return; /* Unsupported register */ | |
284 | ||
285 | for (i = first_regno; i <= last_regno; i++) | |
286 | { | |
287 | int bdm_regno; | |
288 | ||
289 | bdm_regno = bdm_regmap [i]; | |
290 | ||
2549d2b3 GN |
291 | /* only attempt to write if it's a valid ppc 8xx register */ |
292 | /* (need to avoid FP regs and MQ reg) */ | |
293 | if ((i != MQ_REGNUM) && ((i < FP0_REGNUM) || (i > FPLAST_REGNUM))) | |
294 | { | |
295 | /* printf("write valid reg %d\n", bdm_regno); */ | |
296 | ocd_write_bdm_registers (bdm_regno, registers + REGISTER_BYTE (i), 4); | |
297 | } | |
298 | /* | |
299 | else if (i == MQ_REGNUM) | |
300 | printf("don't write invalid reg %d (MQ_REGNUM)\n", bdm_regno); | |
301 | else | |
302 | printf("don't write invalid reg %d\n", bdm_regno); | |
303 | */ | |
35ce4f08 GN |
304 | } |
305 | } | |
306 | \f | |
307 | /* Define the target subroutine names */ | |
308 | ||
309 | struct target_ops bdm_ppc_ops = { | |
706eff3f | 310 | "ocd", /* to_shortname */ |
2549d2b3 GN |
311 | "Remote target with On-Chip Debugging", /* to_longname */ |
312 | "Use a remote target with On-Chip Debugging. To use a target box,\n\ | |
313 | specify the serial device it is connected to (e.g. /dev/ttya). To use\n\ | |
314 | a wiggler, specify wiggler and then the port it is connected to\n\ | |
315 | (e.g. wiggler lpt1).", /* to_doc */ | |
35ce4f08 | 316 | bdm_ppc_open, /* to_open */ |
706eff3f | 317 | ocd_close, /* to_close */ |
35ce4f08 | 318 | NULL, /* to_attach */ |
706eff3f GN |
319 | ocd_detach, /* to_detach */ |
320 | ocd_resume, /* to_resume */ | |
35ce4f08 GN |
321 | bdm_ppc_wait, /* to_wait */ |
322 | bdm_ppc_fetch_registers, /* to_fetch_registers */ | |
323 | bdm_ppc_store_registers, /* to_store_registers */ | |
706eff3f GN |
324 | ocd_prepare_to_store, /* to_prepare_to_store */ |
325 | ocd_xfer_memory, /* to_xfer_memory */ | |
326 | ocd_files_info, /* to_files_info */ | |
160db9b2 GN |
327 | ocd_insert_breakpoint, /* to_insert_breakpoint */ |
328 | ocd_remove_breakpoint, /* to_remove_breakpoint */ | |
35ce4f08 GN |
329 | NULL, /* to_terminal_init */ |
330 | NULL, /* to_terminal_inferior */ | |
331 | NULL, /* to_terminal_ours_for_output */ | |
332 | NULL, /* to_terminal_ours */ | |
333 | NULL, /* to_terminal_info */ | |
706eff3f GN |
334 | ocd_kill, /* to_kill */ |
335 | ocd_load, /* to_load */ | |
35ce4f08 | 336 | NULL, /* to_lookup_symbol */ |
706eff3f GN |
337 | ocd_create_inferior, /* to_create_inferior */ |
338 | ocd_mourn, /* to_mourn_inferior */ | |
35ce4f08 GN |
339 | 0, /* to_can_run */ |
340 | 0, /* to_notice_signals */ | |
706eff3f GN |
341 | ocd_thread_alive, /* to_thread_alive */ |
342 | ocd_stop, /* to_stop */ | |
35ce4f08 GN |
343 | process_stratum, /* to_stratum */ |
344 | NULL, /* to_next */ | |
345 | 1, /* to_has_all_memory */ | |
346 | 1, /* to_has_memory */ | |
347 | 1, /* to_has_stack */ | |
348 | 1, /* to_has_registers */ | |
349 | 1, /* to_has_execution */ | |
350 | NULL, /* sections */ | |
351 | NULL, /* sections_end */ | |
352 | OPS_MAGIC /* to_magic */ | |
353 | }; | |
354 | ||
355 | void | |
356 | _initialize_bdm_ppc () | |
357 | { | |
358 | add_target (&bdm_ppc_ops); | |
359 | } |