OpenOCD
virtex2.c
Go to the documentation of this file.
1 /***************************************************************************
2  * Copyright (C) 2006 by Dominic Rath *
3  * Dominic.Rath@gmx.de *
4  * *
5  * This program is free software; you can redistribute it and/or modify *
6  * it under the terms of the GNU General Public License as published by *
7  * the Free Software Foundation; either version 2 of the License, or *
8  * (at your option) any later version. *
9  * *
10  * This program is distributed in the hope that it will be useful, *
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13  * GNU General Public License for more details. *
14  * *
15  * You should have received a copy of the GNU General Public License *
16  * along with this program. If not, see <http://www.gnu.org/licenses/>. *
17  ***************************************************************************/
18 
19 #ifdef HAVE_CONFIG_H
20 #include "config.h"
21 #endif
22 
23 #include "virtex2.h"
24 #include "xilinx_bit.h"
25 #include "pld.h"
26 
27 static int virtex2_set_instr(struct jtag_tap *tap, uint32_t new_instr)
28 {
29  if (tap == NULL)
30  return ERROR_FAIL;
31 
32  if (buf_get_u32(tap->cur_instr, 0, tap->ir_length) != new_instr) {
33  struct scan_field field;
34 
35  field.num_bits = tap->ir_length;
36  void *t = calloc(DIV_ROUND_UP(field.num_bits, 8), 1);
37  field.out_value = t;
38  buf_set_u32(t, 0, field.num_bits, new_instr);
39  field.in_value = NULL;
40 
41  jtag_add_ir_scan(tap, &field, TAP_IDLE);
42 
43  free(t);
44  }
45 
46  return ERROR_OK;
47 }
48 
50  int num_words, uint32_t *words)
51 {
52  struct virtex2_pld_device *virtex2_info = pld_device->driver_priv;
53  struct scan_field scan_field;
54  uint8_t *values;
55  int i;
56 
57  values = malloc(num_words * 4);
58 
59  scan_field.num_bits = num_words * 32;
60  scan_field.out_value = values;
61  scan_field.in_value = NULL;
62 
63  for (i = 0; i < num_words; i++)
64  buf_set_u32(values + 4 * i, 0, 32, flip_u32(*words++, 32));
65 
66  virtex2_set_instr(virtex2_info->tap, 0x5); /* CFG_IN */
67 
68  jtag_add_dr_scan(virtex2_info->tap, 1, &scan_field, TAP_DRPAUSE);
69 
70  free(values);
71 
72  return ERROR_OK;
73 }
74 
75 static inline void virtexflip32(jtag_callback_data_t arg)
76 {
77  uint8_t *in = (uint8_t *)arg;
78  *((uint32_t *)arg) = flip_u32(le_to_h_u32(in), 32);
79 }
80 
82  int num_words, uint32_t *words)
83 {
84  struct virtex2_pld_device *virtex2_info = pld_device->driver_priv;
85  struct scan_field scan_field;
86 
87  scan_field.num_bits = 32;
88  scan_field.out_value = NULL;
89  scan_field.in_value = NULL;
90 
91  virtex2_set_instr(virtex2_info->tap, 0x4); /* CFG_OUT */
92 
93  while (num_words--) {
94  scan_field.in_value = (uint8_t *)words;
95 
96  jtag_add_dr_scan(virtex2_info->tap, 1, &scan_field, TAP_DRPAUSE);
97 
99 
100  words++;
101  }
102 
103  return ERROR_OK;
104 }
105 
106 static int virtex2_read_stat(struct pld_device *pld_device, uint32_t *status)
107 {
108  uint32_t data[5];
109 
110  jtag_add_tlr();
111 
112  data[0] = 0xaa995566; /* synch word */
113  data[1] = 0x2800E001; /* Type 1, read, address 7, 1 word */
114  data[2] = 0x20000000; /* NOOP (Type 1, read, address 0, 0 words */
115  data[3] = 0x20000000; /* NOOP */
116  data[4] = 0x20000000; /* NOOP */
117  virtex2_send_32(pld_device, 5, data);
118 
119  virtex2_receive_32(pld_device, 1, status);
120 
122 
123  LOG_DEBUG("status: 0x%8.8" PRIx32 "", *status);
124 
125  return ERROR_OK;
126 }
127 
128 static int virtex2_load(struct pld_device *pld_device, const char *filename)
129 {
130  struct virtex2_pld_device *virtex2_info = pld_device->driver_priv;
131  struct xilinx_bit_file bit_file;
132  int retval;
133  unsigned int i;
134  struct scan_field field;
135 
136  field.in_value = NULL;
137 
138  retval = xilinx_read_bit_file(&bit_file, filename);
139  if (retval != ERROR_OK)
140  return retval;
141 
142  virtex2_set_instr(virtex2_info->tap, 0xb); /* JPROG_B */
144  jtag_add_sleep(1000);
145 
146  virtex2_set_instr(virtex2_info->tap, 0x5); /* CFG_IN */
148 
149  for (i = 0; i < bit_file.length; i++)
150  bit_file.data[i] = flip_u32(bit_file.data[i], 8);
151 
152  field.num_bits = bit_file.length * 8;
153  field.out_value = bit_file.data;
154 
155  jtag_add_dr_scan(virtex2_info->tap, 1, &field, TAP_DRPAUSE);
157 
158  jtag_add_tlr();
159 
160  if (!(virtex2_info->no_jstart))
161  virtex2_set_instr(virtex2_info->tap, 0xc); /* JSTART */
163  virtex2_set_instr(virtex2_info->tap, 0x3f); /* BYPASS */
164  virtex2_set_instr(virtex2_info->tap, 0x3f); /* BYPASS */
165  if (!(virtex2_info->no_jstart))
166  virtex2_set_instr(virtex2_info->tap, 0xc); /* JSTART */
168  virtex2_set_instr(virtex2_info->tap, 0x3f); /* BYPASS */
170 
171  return ERROR_OK;
172 }
173 
174 COMMAND_HANDLER(virtex2_handle_read_stat_command)
175 {
176  struct pld_device *device;
177  uint32_t status;
178 
179  if (CMD_ARGC < 1)
181 
182  unsigned dev_id;
183  COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], dev_id);
184  device = get_pld_device_by_num(dev_id);
185  if (!device) {
186  command_print(CMD_CTX, "pld device '#%s' is out of bounds", CMD_ARGV[0]);
187  return ERROR_OK;
188  }
189 
190  virtex2_read_stat(device, &status);
191 
192  command_print(CMD_CTX, "virtex2 status register: 0x%8.8" PRIx32 "", status);
193 
194  return ERROR_OK;
195 }
196 
197 PLD_DEVICE_COMMAND_HANDLER(virtex2_pld_device_command)
198 {
199  struct jtag_tap *tap;
200 
201  struct virtex2_pld_device *virtex2_info;
202 
203  if (CMD_ARGC < 2)
205 
206  tap = jtag_tap_by_string(CMD_ARGV[1]);
207  if (tap == NULL) {
208  command_print(CMD_CTX, "Tap: %s does not exist", CMD_ARGV[1]);
209  return ERROR_OK;
210  }
211 
212  virtex2_info = malloc(sizeof(struct virtex2_pld_device));
213  virtex2_info->tap = tap;
214 
215  virtex2_info->no_jstart = 0;
216  if (CMD_ARGC >= 3)
217  COMMAND_PARSE_NUMBER(int, CMD_ARGV[2], virtex2_info->no_jstart);
218 
219  pld->driver_priv = virtex2_info;
220 
221  return ERROR_OK;
222 }
223 
225  {
226  .name = "read_stat",
227  .mode = COMMAND_EXEC,
228  .handler = virtex2_handle_read_stat_command,
229  .help = "read status register",
230  .usage = "pld_num",
231  },
233 };
235  {
236  .name = "virtex2",
237  .mode = COMMAND_ANY,
238  .help = "Virtex-II specific commands",
239  .usage = "",
241  },
243 };
244 
246  .name = "virtex2",
247  .commands = virtex2_command_handler,
248  .pld_device_command = &virtex2_pld_device_command,
249  .load = &virtex2_load,
250 };
int xilinx_read_bit_file(struct xilinx_bit_file *bit_file, const char *filename)
Definition: xilinx_bit.c:71
#define LOG_DEBUG(expr...)
Definition: log.h:115
const char * name
Definition: pld.h:30
uint32_t flip_u32(uint32_t value, unsigned int num)
Definition: binarybuffer.c:176
struct jtag_tap * jtag_tap_by_string(const char *s)
Definition: jtag/core.c:236
void jtag_add_dr_scan(struct jtag_tap *active, int in_num_fields, const struct scan_field *in_fields, tap_state_t state)
Generate a DR SCAN using the fields passed to the function.
Definition: jtag/core.c:451
static int virtex2_receive_32(struct pld_device *pld_device, int num_words, uint32_t *words)
Definition: virtex2.c:81
const uint8_t * out_value
A pointer to value to be scanned into the device.
Definition: jtag.h:111
static const struct device_t * device
Definition: at91rm9200.c:105
int ir_length
size of instruction register
Definition: jtag.h:130
#define ERROR_FAIL
Definition: log.h:150
static uint32_t le_to_h_u32(const uint8_t *buf)
Definition: types.h:124
#define CMD_ARGV
Use this macro to access the arguments for the command being handled, rather than accessing the varia...
Definition: command.h:126
struct pld_driver virtex2_pld
Definition: virtex2.c:245
#define CMD_ARGC
Use this macro to access the number of arguments for the command being handled, rather than accessing...
Definition: command.h:121
This structure defines a single scan field in the scan.
Definition: jtag.h:107
Definition: jtag.h:79
uint32_t length
Definition: xilinx_bit.h:28
static void buf_set_u32(uint8_t *_buffer, unsigned first, unsigned num, uint32_t value)
Sets num bits in _buffer, starting at the first bit, using the bits in value.
Definition: binarybuffer.h:40
struct pld_device * get_pld_device_by_num(int num)
Definition: pld.c:39
static int virtex2_read_stat(struct pld_device *pld_device, uint32_t *status)
Definition: virtex2.c:106
void jtag_add_tlr(void)
Run a TAP_RESET reset where the end state is TAP_RESET, regardless of the start state.
Definition: jtag/core.c:478
int num_bits
The number of bits this field specifies.
Definition: jtag.h:109
#define COMMAND_PARSE_NUMBER(type, in, out)
parses the string in into out as a type, or prints a command error and passes the error code to the c...
Definition: command.h:378
Definition: pld.h:39
static const struct command_registration virtex2_exec_command_handlers[]
Definition: virtex2.c:224
struct jtag_tap * tap
Definition: virtex2.h:25
PLD_DEVICE_COMMAND_HANDLER(virtex2_pld_device_command)
Definition: virtex2.c:197
#define jtag_add_callback(callback, in)
#define COMMAND_REGISTRATION_DONE
Use this as the last entry in an array of command_registration records.
Definition: command.h:222
uint8_t * cur_instr
current instruction
Definition: jtag.h:149
Definition: pld.h:29
#define ERROR_COMMAND_SYNTAX_ERROR
Definition: command.h:338
Definition: jtag.h:121
static int virtex2_set_instr(struct jtag_tap *tap, uint32_t new_instr)
Definition: virtex2.c:27
const char * name
Definition: command.h:203
#define CMD_CTX
Use this macro to access the context of the command being handled, rather than accessing the variable...
Definition: command.h:116
static int virtex2_send_32(struct pld_device *pld_device, int num_words, uint32_t *words)
Definition: virtex2.c:49
void jtag_add_runtest(int num_cycles, tap_state_t state)
Goes to TAP_IDLE (if we're not already there), cycle precisely num_cycles in the TAP_IDLE state...
Definition: jtag/core.c:592
#define DIV_ROUND_UP(m, n)
Rounds m up to the nearest multiple of n using division.
Definition: types.h:91
static void virtexflip32(jtag_callback_data_t arg)
Definition: virtex2.c:75
void jtag_add_ir_scan(struct jtag_tap *active, struct scan_field *in_fields, tap_state_t state)
Generate an IR SCAN with a list of scan fields with one entry for each enabled TAP.
Definition: jtag/core.c:373
void command_print(struct command_context *context, const char *format,...)
Definition: command.c:528
void jtag_add_sleep(uint32_t us)
Definition: jtag/core.c:768
static uint32_t buf_get_u32(const uint8_t *_buffer, unsigned first, unsigned num)
Retrieves num bits from _buffer, starting at the first bit, returning the bits in a 32-bit word...
Definition: binarybuffer.h:107
void * driver_priv
Definition: pld.h:41
uint8_t * data
Definition: xilinx_bit.h:29
static const struct command_registration virtex2_command_handler[]
Definition: virtex2.c:234
static int virtex2_load(struct pld_device *pld_device, const char *filename)
Definition: virtex2.c:128
int jtag_execute_queue(void)
For software FIFO implementations, the queued commands can be executed during this call or earlier...
Definition: jtag/core.c:861
#define ERROR_OK
Definition: log.h:144
intptr_t jtag_callback_data_t
Defines the type of data passed to the jtag_callback_t interface.
Definition: jtag.h:384
uint8_t * in_value
A pointer to a 32-bit memory location for data scanned out.
Definition: jtag.h:113
#define NULL
Definition: usb.h:27
COMMAND_HANDLER(virtex2_handle_read_stat_command)
Definition: virtex2.c:174