OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [config/] [or1k/] [tm-or1k.h] - Blame information for rev 136

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 106 markom
/* Definitions to target GDB to or1k targets.
2
   Copyright 2001 Free Software Foundation, Inc.
3
 
4
   This file is part of GDB.
5
 
6
   This program is free software; you can redistribute it and/or modify
7
   it under the terms of the GNU General Public License as published by
8
   the Free Software Foundation; either version 2 of the License, or
9
   (at your option) any later version.
10
 
11
   This program is distributed in the hope that it will be useful,
12
   but WITHOUT ANY WARRANTY; without even the implied warranty of
13
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
   GNU General Public License for more details.
15
 
16
   You should have received a copy of the GNU General Public License
17
   along with this program; if not, write to the Free Software
18
   Foundation, Inc., 59 Temple Place - Suite 330,
19
   Boston, MA 02111-1307, USA.  */
20
 
21
#ifndef TM_OR1K_H
22
#define TM_OR1K_H
23
 
24
#ifndef TARGET_OR1K
25
#define TARGET_OR1K
26
#endif
27
 
28 122 markom
#include "defs.h"
29 126 chris
#include <inttypes.h>  /* CZ */
30 122 markom
 
31 106 markom
struct value;
32
 
33
struct struct_or1k_implementation
34
  {
35
    /* Implementation version.  */
36
    unsigned int VR;
37
    /* Units present.  */
38
    unsigned int UPR;
39
    /* Number of total available matchpoints in this implementation.  */
40
    unsigned int num_matchpoints;
41 113 markom
    /* Number of currently used matchpoints.  */
42
    unsigned int num_used_matchpoints;
43 115 markom
    /* Has watchpoint driven counters.  */
44
    int has_counters;
45 106 markom
    /* Number of registers.  */
46
    unsigned int num_gpr_regs;
47 115 markom
    unsigned int num_vfpr_regs;
48
    /* Is there any vf support?  */
49 106 markom
    int vf_present;
50
 };
51
 
52
struct or1k_target_ops
53
  {
54
    /* Name this target type.  */
55
    char *to_shortname;
56
 
57
    /* Init target.  */
58
    void (*to_init) PARAMS ((char *args));
59
    /* Destruct target.  */
60
    void (*to_done) PARAMS ((void));
61
 
62 113 markom
    /* Read register.
63
       Does not fail, places error no. in err instead or call error(), if fatal.  */
64 122 markom
    ULONGEST (*to_read_reg) PARAMS ((unsigned int regno));
65 113 markom
    /* Write register.
66
       Does not fail, places error no. in err instead or call error(), if fatal.  */
67 122 markom
    void (*to_write_reg) PARAMS ((unsigned int regno, ULONGEST value));
68 106 markom
 
69 113 markom
    /* Selects scan chain.  All register accesses are related to current scan chain.
70
       Does not fail, places error no. in err instead or call error(), if fatal.
71
       See jtag_chains enum.  */
72
    void (*to_set_chain) PARAMS ((int chain));
73 106 markom
 
74
    /* Executes extended command on the target.  */
75
    void (*to_exec_command) PARAMS ((char *args, int from_tty));
76
 
77
    /* Associated target_ops.  */
78
    struct target_ops *gdb_ops;
79
    /* Should be OPS_MAGIC. */
80
    int to_magic;
81
  };
82
 
83
 
84
#define DEFAULT_PROMPT "(or1k) "
85
 
86 113 markom
/* Context stuff. */
87
#define CURRENT_CID (0)
88
#define MAX_CID     (15)
89
 
90
 
91
/* Instruction definitions. */
92
#define BRK_INSTR_STRUCT {0x21, 0x00, 0x00, 0x00}
93
#define NOP_INSTR (0x15000000)
94
 
95 106 markom
/* Special purpose regisers.  */
96 113 markom
#define SPR_GROUP_SIZE_BITS (11)
97 106 markom
#define SPR_GROUP_SIZE (1 << SPR_GROUP_SIZE_BITS)
98
#define SPR_SYSTEM_GROUP (0)
99
#define SPR_DEBUG_GROUP (6)
100 115 markom
#define SPR_GPR_START  (1024)
101
#define SPR_VFPR_START ((MAX_CID + 1) * MAX_GPR_REGS + SPR_GPR_START)
102
#define OR1K_NUM_SPR_GROUPS (12)
103 106 markom
 
104
/* Define register values.  */
105
#define SPR_REG(group, index) (((group) << SPR_GROUP_SIZE_BITS) + (index))
106
 
107 115 markom
#define VR_SPRNUM SPR_REG(SPR_SYSTEM_GROUP, 0)
108
#define UPR_SPRNUM SPR_REG(SPR_SYSTEM_GROUP, 1)
109
#define CPUCFGR_SPRNUM SPR_REG(SPR_SYSTEM_GROUP, 2)
110
#define DCFGR_SPRNUM SPR_REG(SPR_SYSTEM_GROUP, 7)
111
#define PC_SPRNUM SPR_REG(SPR_SYSTEM_GROUP, 16)
112
#define SR_SPRNUM SPR_REG(SPR_SYSTEM_GROUP, 17)
113 113 markom
#define CCR_SPRNUM(cid) SPR_REG(SPR_SYSTEM_GROUP, 4 + (cid))
114 115 markom
#define DVR0_SPRNUM SPR_REG(SPR_DEBUG_GROUP, 32)
115
#define DCR0_SPRNUM SPR_REG(SPR_DEBUG_GROUP, 40)
116
#define DMR1_SPRNUM SPR_REG(SPR_DEBUG_GROUP, 48)
117
#define DMR2_SPRNUM SPR_REG(SPR_DEBUG_GROUP, 49)
118
#define DCWR0_SPRNUM SPR_REG(SPR_DEBUG_GROUP, 50)
119
#define DCWR1_SPRNUM SPR_REG(SPR_DEBUG_GROUP, 51)
120
#define DSR_SPRNUM SPR_REG(SPR_DEBUG_GROUP, 52)
121
#define DRR_SPRNUM SPR_REG(SPR_DEBUG_GROUP, 53)
122
#define DIR_SPRNUM SPR_REG(SPR_DEBUG_GROUP, 54)
123 106 markom
#define ZERO_REGNUM (0)
124
#define SP_REGNUM (1)
125
#define FP_REGNUM (2)
126
#define A0_REGNUM (3)
127
#define A5_REGNUM (8)
128
#define LR_REGNUM (9)
129
#define RV_REGNUM (11)
130 113 markom
#define VFA0_REGNUM (MAX_GPR_REGS + 0)
131
#define VFA5_REGNUM (MAX_GPR_REGS + 5)
132
#define VFRV_REGNUM (MAX_GPR_REGS + 6)
133
#define PC_REGNUM (MAX_GPR_REGS + MAX_VF_REGS + 0)
134
#define PS_REGNUM (MAX_GPR_REGS + MAX_VF_REGS + 1)
135
#define CCR_REGNUM (MAX_GPR_REGS + MAX_VF_REGS + 2)
136 106 markom
 
137
extern int or1k_regnum_to_sprnum PARAMS ((int regno));
138
#define REGNUM_TO_SPRNUM(regno) (or1k_regnum_to_sprnum(regno))
139
 
140
/* Defines for SPR bits.  */
141
#define DMR1_ST    (0x00400000)
142
 
143 136 chris
/* Changed by CZ 21/06/01 */
144
#define DRR_BE     (0x00001000)
145
#define DRR_SCE    (0x00000800)
146
#define DRR_RE     (0x00000400)
147
#define DRR_IME    (0x00000200)
148
#define DRR_DME    (0x00000100)
149
#define DRR_HPINTE (0x00000080)
150 106 markom
#define DRR_IIE    (0x00000040)
151 136 chris
#define DRR_AE     (0x00000020)
152
#define DRR_LPINTE (0x00000010)
153
#define DRR_IPFE   (0x00000008)
154
#define DRR_DPFE   (0x00000004)
155
#define DRR_BUSEE  (0x00000002)
156
#define DRR_RSTE   (0x00000001)
157 106 markom
 
158
/* Number of matchpoints */
159
#define NUM_MATCHPOINTS (or1k_implementation.num_matchpoints)
160 118 markom
#define MAX_MATCHPOINTS (8)
161 106 markom
 
162
/* Number of machine GPR registers */
163
#define NUM_GPR_REGS (or1k_implementation.num_gpr_regs)
164
#define MAX_GPR_REGS (32)
165
 
166
/* Number of machine VF registers */
167 116 markom
#define NUM_VF_REGS (or1k_implementation.num_vfpr_regs)
168 106 markom
#define MAX_VF_REGS (32)
169
 
170
/* gdb mapping of registers */
171
#ifndef NUM_REGS
172
#define NUM_REGS (MAX_GPR_REGS+MAX_VF_REGS+3)
173
#endif
174
 
175
/* Can act like a little or big endian.  */
176
#if !defined (TARGET_BYTE_ORDER_DEFAULT)
177
#define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN
178
#define TARGET_BYTE_ORDER_SELECTABLE_P (1)
179
#endif
180
 
181
/* Size (in bytes) of registers.  */
182
#define OR1K_SPR_REGSIZE (4)
183
#define OR1K_VF_REGSIZE (8)
184
#define OR1K_GPR_REGSIZE ((OR1K_64BIT_IMPLEMENTATION)?(8):(4))
185 113 markom
#define OR1K_VF_DOUBLE (0)
186 106 markom
 
187 113 markom
#define OR1K_IS_GPR(N) ((N) >= 0 && (N) < MAX_GPR_REGS)
188
#define OR1K_IS_VF(N) ((N) >= MAX_GPR_REGS && (N) < MAX_GPR_REGS + MAX_VF_REGS)
189 106 markom
 
190
/* Register representation is the same as in memory.  */
191
#define REGISTER_CONVERTIBLE(N) (0)
192
 
193
/* Given the register index, return the name of the corresponding
194
   register. */
195
extern char *or1k_register_name PARAMS ((int regno));
196
#define REGISTER_NAME(regno) or1k_register_name (regno)
197
 
198
/* Is this implementation 64 or 32 bit.
199
   WARNING: gdb or1k port is not yet prepared for 64b implementations!  */
200
#define OR1K_64BIT_IMPLEMENTATION 0
201
 
202
/* Number of bytes of storage in the actual machine representation for
203
   register N.  NOTE: This indirectly defines the register size
204
   transfered by the GDB protocol.  If we have 64bit processor
205
   implementation, GPR register raw size is 8B, otherwise 4B.  */
206
#define REGISTER_RAW_SIZE(N) ((OR1K_IS_GPR(N)?((OR1K_64BIT_IMPLEMENTATION)?\
207
(8):(4)):(OR1K_SPR_REGSIZE)))
208
 
209
/* Number of bytes of storage in the program's representation
210
   for register N. Same as RAW_SIZE.  */
211
#define REGISTER_VIRTUAL_SIZE(N) TYPE_LENGTH (REGISTER_VIRTUAL_TYPE (N))
212
 
213
/* Return the GDB type object for the "standard" data type of data in
214
   register N.  */
215
#define REGISTER_VIRTUAL_TYPE(N) ((OR1K_IS_GPR(N))?(\
216 113 markom
(OR1K_64BIT_IMPLEMENTATION)?builtin_type_int64:builtin_type_int\
217
):(OR1K_IS_VF(N) ? builtin_type_float : builtin_type_uint32))
218 106 markom
 
219
/* Largest value REGISTER_RAW_SIZE can have.  */
220
#define MAX_REGISTER_RAW_SIZE ((OR1K_64BIT_IMPLEMENTATION)?(8):(4))
221
 
222
/* Largest value REGISTER_VIRTUAL_SIZE can have.  */
223
#define MAX_REGISTER_VIRTUAL_SIZE ((OR1K_64BIT_IMPLEMENTATION)?(8):(4))
224
 
225
#define REGISTER_SIZE (MAX_REGISTER_VIRTUAL_SIZE)
226
 
227
/* ABI uses R3 through R8 for args.  */
228
#define OR1K_LAST_ARG_REGNUM (A5_REGNUM)
229
#define OR1K_NUM_ARG_REGS (6)
230 118 markom
 
231 106 markom
/* ABI uses VFR0 through VFR5 for float args.  */
232
#define OR1K_LAST_FP_ARG_REGNUM (VFA5_REGNUM)
233
#define OR1K_NUM_FP_ARG_REGS (6)
234
 
235
/* Should not store into R0.  */
236
#define CANNOT_STORE_REGISTER(N) ((N) == 0)
237
 
238
/* Index within `registers' of the first byte of the space for
239
   register N.  */
240
#define REGISTER_BYTE(N) ((N) * OR1K_SPR_REGSIZE)
241
 
242
/* Total amount of space needed to store our copies of the machine's
243
   register state, the array `registers'.  */
244
#define REGISTER_BYTES (NUM_REGS * OR1K_SPR_REGSIZE)
245
 
246 113 markom
extern void or1k_do_registers_info PARAMS ((int, int));
247
#define DO_REGISTERS_INFO(regnum, fp) or1k_do_registers_info(regnum, fp)
248
 
249
 
250
 
251 106 markom
/* BREAKPOINT_FROM_PC uses the program counter value to determine whether a
252
   16- or 32-bit breakpoint should be used.  It returns a pointer
253
   to a string of bytes that encode a breakpoint instruction, stores
254
   the length of the string to *lenptr, and adjusts the pc (if necessary) to
255
   point to the actual memory location where the breakpoint should be
256
   inserted.  */
257
extern unsigned char *or1k_breakpoint_from_pc PARAMS ((CORE_ADDR *bp_addr, int *bp_size));
258
#define BREAKPOINT_FROM_PC(pcptr, lenptr) or1k_breakpoint_from_pc (pcptr, lenptr)
259
 
260
/* Amount PC must be decremented by after a breakpoint.
261
   This is often the number of bytes in BREAKPOINT
262
   but not always.  */
263
#define DECR_PC_AFTER_BREAK 0
264
 
265
/* Amount PC must be decremented by after a breakpoint.
266
   This is often the number of bytes in BREAKPOINT
267
   but not always.  */
268
#define DECR_PC_AFTER_BREAK 0
269
 
270 113 markom
extern int or1k_insert_breakpoint (CORE_ADDR addr, char *contents_cache);
271
#define target_insert_hw_breakpoint(addr, cache) or1k_insert_breakpoint (addr, cache)
272
 
273
extern int or1k_remove_breakpoint (CORE_ADDR addr, char *contents_cache);
274
#define target_remove_hw_breakpoint(addr, cache) or1k_remove_breakpoint (addr, cache)
275
 
276
/* Watchpoint support.  */
277
#define TARGET_HAS_HARDWARE_WATCHPOINTS
278
 
279
/* Use these macros for watchpoint insertion/deletion.  */
280
/* type can be 0: write watch, 1: read watch, 2: access watch (read/write) */
281
extern int or1k_insert_watchpoint PARAMS ((CORE_ADDR addr, int len, int type));
282
#define target_insert_watchpoint(addr, len, type) \
283
        or1k_insert_watchpoint (addr, len, type)
284
 
285
extern int or1k_insert_watchpoint PARAMS ((CORE_ADDR addr, int len, int type));
286
#define target_remove_watchpoint(addr, len, type) \
287
        or1k_remove_watchpoint (addr, len, type)
288
 
289
/* We need to remove watchpoints when stepping, else we hit them again! */
290
#define HAVE_NONSTEPPABLE_WATCHPOINT
291
 
292
extern int or1k_stopped_by_watchpoint PARAMS ((void));
293
#define STOPPED_BY_WATCHPOINT(w) or1k_stopped_by_watchpoint ()
294
 
295
typedef enum bptype;
296
extern int or1k_can_use_hardware_watchpoint PARAMS ((enum bptype, int));
297
#define TARGET_CAN_USE_HARDWARE_WATCHPOINT(bp_type, cnt, ot) \
298
  or1k_can_use_hardware_watchpoint(bp_type, cnt)
299
 
300
 
301
/* Catchpoint support.  */
302
/* HACK: how do we hook to signal namings otherwise? */
303
#include "target.h"
304
extern char *target_signal_to_string PARAMS ((enum target_signal));
305 118 markom
 
306 113 markom
/* Return the name (SIGHUP, etc.) for a signal.  */
307
extern char *or1k_signal_to_name PARAMS ((enum target_signal));
308 118 markom
 
309 113 markom
/* Given a name (SIGHUP, etc.), return its signal.  */
310
extern enum target_signal or1k_signal_from_name PARAMS ((char *));
311
 
312
#define NUM_OR1K_SIGNALS (10)
313
 
314 106 markom
/* Extract from an array REGBUF containing the (raw) register state
315
   a function return value of type TYPE, and copy that, in virtual format,
316
   into VALBUF.  */
317
extern void or1k_extract_return_value PARAMS ((struct type *, char[], char *));
318
#define EXTRACT_RETURN_VALUE(TYPE, REGBUF, VALBUF) \
319
  or1k_extract_return_value (TYPE, REGBUF, VALBUF)
320
 
321
/* Write into appropriate registers a function return value
322
   of type TYPE, given in virtual format.  */
323
#define STORE_RETURN_VALUE(TYPE,VALBUF) \
324
  {\
325
    if (TYPE_CODE (TYPE) == TYPE_CODE_FLT)\
326
      write_register_bytes (REGISTER_BYTE (VFRV_REGNUM), VALBUF, TYPE_LENGTH (TYPE));\
327
    else\
328
      write_register_bytes (REGISTER_BYTE (RV_REGNUM), VALBUF, TYPE_LENGTH (TYPE));\
329
  }
330
 
331
/* Extract from an array REGBUF containing the (raw) register state
332
   the address in which a function should return its structure value,
333
   as a CORE_ADDR (or an expression that can be used as one).  */
334
/* The address is passed in a0 upon entry to the function, but when
335
   the function exits, the compiler has copied the value to v0.  This
336
   convention is specified by the System V ABI, so I think we can rely
337
   on it.  */
338
#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) \
339
  (extract_address (REGBUF + REGISTER_BYTE (RV_REGNUM), \
340
                    REGISTER_RAW_SIZE (RV_REGNUM)))
341
 
342
#define EXTRACT_STRUCT_VALUE_ADDRESS_P 1
343
 
344
/* Advance PC across any function entry prologue instructions
345
   to reach some "real" code.  */
346
extern CORE_ADDR or1k_skip_prologue PARAMS ((CORE_ADDR addr));
347
#define SKIP_PROLOGUE(pc) (or1k_skip_prologue (pc))
348
 
349
/* FRAMES */
350
#define FRAME_ARGS_ADDRESS(fi)  (fi)->frame
351
 
352
#define FRAME_LOCALS_ADDRESS(fi) (fi)->frame
353
 
354
/* FRAME_CHAIN takes a frame's nominal address
355
   and produces the frame's chain-pointer. */
356
#define FRAME_CHAIN(thisframe) (CORE_ADDR) or1k_frame_chain (thisframe)
357
extern CORE_ADDR or1k_frame_chain PARAMS ((struct frame_info *));
358
 
359
/* Discard from the stack the innermost frame, restoring all registers.  */
360
extern void or1k_pop_frame PARAMS ((void));
361
#define POP_FRAME or1k_pop_frame()
362
 
363
 
364
/* Return number of args passed to a frame.
365
   Can return -1, meaning no way to tell.  */
366
#define FRAME_NUM_ARGS(fi)      (-1)
367
 
368
/* Return number of bytes at start of arglist that are not really args.  */
369
#define FRAME_ARGS_SKIP 0
370
 
371
/* Put here the code to store, into a struct frame_saved_regs,
372
   the addresses of the saved registers of frame described by FRAME_INFO.
373
   This includes special registers such as pc and fp saved in special
374
   ways in the stack frame.  sp is even more special:
375
   the address we return for it IS the sp for the next frame.  */
376
extern void or1k_init_saved_regs PARAMS ((struct frame_info *));
377
#define FRAME_INIT_SAVED_REGS(frame_info) or1k_init_saved_regs (frame_info);
378
 
379
/* Saved Pc.  */
380
extern CORE_ADDR or1k_frame_saved_pc PARAMS ((struct frame_info *));
381
#define FRAME_SAVED_PC(FRAME) (or1k_frame_saved_pc(FRAME))
382
 
383
/* Set the return address register to point to the entry
384
   point of the program, where a breakpoint lies in wait.  */
385
extern CORE_ADDR or1k_push_return_address PARAMS ((CORE_ADDR pc, CORE_ADDR sp));
386
#define PUSH_RETURN_ADDRESS(PC, SP) (or1k_push_return_address ((PC), (SP)))
387
 
388
/* Immediately after a function call, return the saved pc.
389
   Can't always go through the frames for this because on some machines
390
   the new frame is not set up until the new function executes
391
   some instructions.  */
392
#define SAVED_PC_AFTER_CALL(frame)      read_register(LR_REGNUM)
393
 
394
/* Offset from address of function to start of its code.
395
   Zero on most machines.  */
396
#define FUNCTION_START_OFFSET (0)
397
 
398
/* Floating point is IEEE compliant */
399
#define IEEE_FLOAT
400
 
401
/* Is floating/vector unit present.  */
402
#define OR1K_VF_PRESENT (or1k_implementation.vf_present)
403
 
404
#define INIT_FRAME_PC           /* Not necessary */
405
 
406
/* Stack grows downward.  */
407
#define INNER_THAN(lhs,rhs) ((lhs) < (rhs))
408
 
409
/* Size of stack entry - in bytes.  */
410
#define OR1K_STACK_ALIGN (8)
411 118 markom
 
412 106 markom
/* Maximum struct size, that is still stored onto stack.  */
413
#define OR1K_STRUCT_CONV_SIZE (8)
414
#define STACK_ALIGN(addr) OR1K_STACK_ALIGN
415
 
416
#define USE_STRUCT_CONVENTION(gcc_p, type) (TYPE_LENGTH (type) > OR1K_STRUCT_CONV_SIZE)
417
 
418
/* Stack must be aligned on 32-bit boundaries when synthesizing
419
   function calls. PUSH_ARGUMENTS will handle it. */
420
extern CORE_ADDR or1k_push_arguments PARAMS ((int, struct value **, CORE_ADDR, int, CORE_ADDR));
421
#define PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr) \
422
(or1k_push_arguments((nargs), (args), (sp), (struct_return), (struct_addr)))
423
 
424
/* Return non-zero if PC points to an instruction which will cause a step
425
   to execute both the instruction at PC and an instruction at PC+4.  */
426
extern int or1k_step_skips_delay PARAMS ((CORE_ADDR));
427
#define STEP_SKIPS_DELAY_P (1)
428
#define STEP_SKIPS_DELAY(pc) (or1k_step_skips_delay (pc))
429
 
430
/* DUMMY CALLS */
431
#define USE_GENERIC_DUMMY_FRAMES 1
432
#define CALL_DUMMY                   {0}
433
#define CALL_DUMMY_START_OFFSET      (0)
434
#define CALL_DUMMY_BREAKPOINT_OFFSET (0)
435
#define SIZEOF_CALL_DUMMY_WORDS      (0)
436
#define CALL_DUMMY_LOCATION          AT_ENTRY_POINT
437
#define FIX_CALL_DUMMY(DUMMY, START, FUNADDR, NARGS, ARGS, TYPE, GCCP) 
438
 
439
/* Return a location where we can set a breakpoint that will be hit
440
   when an inferior function call returns.  This is normally the
441
   program's entry point.  */
442
#define CALL_DUMMY_ADDRESS()         entry_point_address ()
443
#define SAVE_DUMMY_FRAME_TOS(SP)     generic_save_dummy_frame_tos (SP)
444
#define PC_IN_CALL_DUMMY(PC, SP, FP) generic_pc_in_call_dummy (PC, SP, FP)
445
#define PUSH_DUMMY_FRAME             generic_push_dummy_frame ()
446
 
447
/* Definitions and declarations used by or1k dependent files.  */
448
#define OR1K_INSTLEN 4          /* Length of an instruction */
449
typedef unsigned long t_inst;   /* Integer big enough to hold an instruction */
450
 
451
 
452
 
453
/* Defined in remote-or1k.c */
454
 
455
/* Target state names.  */
456
extern const char *status_name[];
457 118 markom
 
458 106 markom
/* Target state.  */
459
enum target_status
460
  {
461
    TARGET_UNDEFINED,
462
    TARGET_CONNECTING,
463
    TARGET_DISCONNECTING,
464
    TARGET_RUNNING,
465
    TARGET_STOPPED
466
  };
467
 
468
#define REG_SPACE 0x00000000
469
#define REG_SPACE_END 0x7FFFFFFF
470
#define MEM_SPACE 0x80000000
471
#define MEM_SPACE_END 0xFFFFFFFF
472
 
473
/* Compare conditions for DCRx registers.  */
474
enum enum_compare_condition
475
  {
476 118 markom
    CC_MASKED, CC_EQUAL, CC_LESS, CC_LESSE, CC_GREAT, CC_GREATE, CC_NEQUAL
477 106 markom
  };
478
 
479
/* Compare operand to compare DVRx to.  */
480
enum enum_compare_to
481
  {
482 119 markom
    CT_DISABLED, CT_FETCH, CT_LEA, CT_SEA, CT_LDATA, CT_SDATA, CT_AEA, CT_ADATA
483 106 markom
  };
484
 
485 118 markom
/* Matchpoint chaining types.  */
486
enum enum_chaining
487
  {
488
    CHAINING_NONE, CHAINING_AND, CHAINING_OR
489
  };
490 106 markom
 
491 118 markom
/* Names for cts.  */
492
#define NUM_CT_NAMES 8
493
extern const char *compare_to_names[NUM_CT_NAMES];
494
 
495 106 markom
/* DRCx struct */
496
struct dcr_struct
497
  {
498 113 markom
    enum enum_compare_to ct:3;
499
    unsigned int sc:1;
500 106 markom
    enum enum_compare_condition cc:3;
501 113 markom
    unsigned int dp:1;
502 106 markom
  };
503
 
504 118 markom
/* All data needed for a matchpoint.  */
505
struct matchpoint
506
  {
507
    struct dcr_struct dcr;
508
    unsigned int dvr;
509
    unsigned int chain_type;
510
    unsigned int cause_breakpoint;
511
  };
512
 
513
/* Trace related structures and data.  */
514
#define TRACE_FILENAME_SIZE (128)
515
extern char trace_filename[TRACE_FILENAME_SIZE];
516
#define TRACE_FILENAME (&trace_filename[0])
517
#define TRACE_DATA_SIZE (sizeof(struct htrace_data_struct))
518
 
519
struct htrace_data_struct
520
  {
521
    unsigned int unused:24;
522
    unsigned int data:32;
523
    unsigned int type:4;
524
    unsigned int reserved:3;
525
    unsigned int valid:1;
526
  };
527
 
528
enum enum_operation
529
  {
530
    TRIGOP_ANY, TRIGOP_OR, TRIGOP_AND
531
  };
532
 
533
struct htrace_event_struct
534
  {
535
    enum enum_operation operation:2;
536
    unsigned int reserved1:6;
537
    unsigned int is_valid:1;
538
    unsigned int is_trig:2;
539
    unsigned int ls_valid:1;
540
    unsigned int ls_trig:4;
541
    unsigned int reserved2:2;
542
    unsigned int bp_valid:1;
543
    unsigned int bp_trig:1;
544
    unsigned int wp_valid:1;
545
    unsigned int wp_trig:11;
546
  };
547
 
548
struct htrace_record_struct
549
  {
550
    unsigned int reserved:25;
551
    unsigned int rec:7;
552
  };
553
 
554
struct htrace_moder_struct
555
  {
556
    unsigned int reserved:29;
557
    unsigned int rec_sel_dep:1;
558
    unsigned int trace_enable:1;
559
    unsigned int contin:1;
560
  };
561
 
562
/* Number of records as defined in TAP.  */
563
#define NUM_RECORDS (8)
564
 
565
struct htrace_struct
566
  {
567
    /* Local copy of HW regs for trace.  */
568
    struct htrace_event_struct trig, qual, stop;
569
    struct htrace_record_struct recwp[MAX_MATCHPOINTS], recbp;
570
    struct htrace_moder_struct moder;
571
    /* Which matchpoints does record use?  Bitmask.  */
572
    unsigned int wp_record_uses[MAX_MATCHPOINTS];
573
  };
574
 
575
extern struct htrace_struct or1k_htrace;
576
extern int trace_size;
577
 
578
#define MAX_RECORD_NAMES 7
579
extern const char *or1k_record_names[MAX_RECORD_NAMES];
580
#define MAX_IS_NAMES 4
581
extern const char *or1k_is_names[MAX_IS_NAMES];
582
#define MAX_LS_NAMES 16
583
extern const char *or1k_ls_names[MAX_LS_NAMES];
584
 
585
/* Stuff for HW watches.  */
586
#define MAX_HW_WATCHES MAX_MATCHPOINTS
587
 
588
struct hwatch_struct
589
  {
590
    int matchpoint_start;
591
  };
592
 
593
extern int num_hw_watches;
594
extern struct hwatch_struct or1k_hwatch[MAX_HW_WATCHES];
595
 
596 106 markom
/* Possible errors are listed here.  */
597 126 chris
enum enum_errors  /* modified <chris@asics.ws> CZ 24/05/01 */
598
{
599
  /* Codes > 0 are for system errors */
600 106 markom
 
601 126 chris
  ERR_NONE = 0,
602
  ERR_CRC = -1,
603
  JTAG_PROXY_INVALID_COMMAND = -2,
604
  JTAG_PROXY_SERVER_TERMINATED = -3,
605
  JTAG_PROXY_NO_CONNECTION = -4,
606
  JTAG_PROXY_PROTOCOL_ERROR = -5,
607
  JTAG_PROXY_COMMAND_NOT_IMPLEMENTED = -6,
608
  JTAG_PROXY_INVALID_CHAIN = -7,
609
  JTAG_PROXY_INVALID_ADDRESS = -8,
610
};
611
 
612 118 markom
/* All JTAG chains.  */
613 113 markom
enum jtag_chains
614
  {
615
    SC_GLOBAL,      /* 0 Global BS Chain */
616
    SC_RISC_DEBUG,  /* 1 RISC Debug Interface chain */
617
    SC_RISC_TEST,   /* 2 RISC Test Chain */
618
    SC_TRACE,       /* 3 Trace Chain */
619
    SC_REGISTER,    /* Register Chain */
620
    SC_BLOCK,       /* Block Chains */
621
  };
622
 
623 118 markom
/* See JTAG documentation about these.  */
624
#define JI_SIZE (4)
625
enum jtag_instr
626
  {
627
    JI_EXTEST,
628
    JI_SAMPLE_PRELOAD,
629
    JI_IDCODE,
630
    JI_CHAIN_SELECT,
631
    JI_INTEST,
632
    JI_CLAMP,
633
    JI_CLAMPZ,
634
    JI_HIGHZ,
635
    JI_DEBUG,
636
    JI_BYPASS = 0xF
637
  };
638
 
639 113 markom
/* JTAG registers.  */
640 118 markom
#define JTAG_MODER  (0x0)
641
#define JTAG_TSEL   (0x1)
642
#define JTAG_QSEL   (0x2)
643
#define JTAG_SSEL   (0x3)
644 113 markom
#define JTAG_RISCOP (0x9)
645 118 markom
#define JTAG_RECWP0 (0x10)
646
#define JTAG_RECBP0 (0x1b)
647 113 markom
 
648 118 markom
 
649
/* Current register values.  */
650
extern unsigned int dmr1;
651
extern unsigned int dmr2;
652
extern unsigned int dsr;
653
extern unsigned int drr;
654
 
655
extern int matchpoint_user_count[MAX_MATCHPOINTS];
656
 
657
/* Current watchpoints.  */
658
extern unsigned int dvr[MAX_MATCHPOINTS];
659
extern struct dcr_struct dcr[MAX_MATCHPOINTS];
660
extern int debug_regs_changed;
661
 
662
/* Returns error name.  */
663 106 markom
extern const char *or1k_err_name PARAMS ((int e));
664
 
665 118 markom
/* Last error number.  */
666
extern int err;
667
 
668 106 markom
extern struct struct_or1k_implementation or1k_implementation;
669
extern unsigned int or1k_fetch_instruction PARAMS ((CORE_ADDR addr));
670
extern void or1k_fetch_registers PARAMS ((int regno));
671
 
672
/* Sets register/memory regno to data.  */
673 113 markom
extern void or1k_write_spr_reg PARAMS ((unsigned int regno, unsigned int data));
674 106 markom
 
675
/* Sets register/memory regno to data.  */
676 113 markom
extern unsigned int or1k_read_spr_reg PARAMS ((unsigned int regno));
677 106 markom
 
678 118 markom
/* Flushes or1k's pipeline.  */
679 113 markom
extern void or1k_flush_pipeline PARAMS ((void));
680
 
681 118 markom
/* Sifts unused matchpoints to higher indexses.  */
682
extern void sift_matchpoints ();
683
 
684 126 chris
 
685
/* Added by Chris Ziomkowski <chris@asics.ws> 24/05/01 */
686
typedef enum {
687
  JTAG_COMMAND_READ = 1,
688
  JTAG_COMMAND_WRITE = 2,
689
  JTAG_COMMAND_CHAIN = 3,
690
} JTAG_proxy_protocol_commands;
691
 
692
/* Each transmit structure must begin with an integer
693
   which specifies the type of command. Information
694
   after this is variable. Make sure to have all information
695
   aligned properly. If we stick with 32 bit integers, it
696
   should be portable onto every platform. These structures
697
   will be transmitted across the network in network byte
698
   order.
699
*/
700
 
701
typedef struct {
702
  uint32_t command;
703
  uint32_t length;
704
  uint32_t address;
705
  uint32_t data_H;
706
  uint32_t data_L;
707
} JTAGProxyWriteMessage;
708
 
709
typedef struct {
710
  uint32_t command;
711
  uint32_t length;
712
  uint32_t address;
713
} JTAGProxyReadMessage;
714
 
715
typedef struct {
716
  uint32_t command;
717
  uint32_t length;
718
  uint32_t chain;
719
} JTAGProxyChainMessage;
720
 
721
/* The responses are messages specific, however convention
722
   states the first word should be an error code. Again,
723
   sticking with 32 bit integers should provide maximum
724
   portability. */
725
 
726
typedef struct {
727
  int32_t status;
728
} JTAGProxyWriteResponse;
729
 
730
typedef struct {
731
  int32_t status;
732
  uint32_t data_H;
733
  uint32_t data_L;
734
} JTAGProxyReadResponse;
735
 
736
typedef struct {
737
  int32_t status;
738
} JTAGProxyChainResponse;
739
 
740 106 markom
#endif /* TM_OR1K_H */

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.