src/pld/virtex2.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2
   3 /***************************************************************************
   4  *   Copyright (C) 2006 by Dominic Rath                                    *
   5  *   Dominic.Rath@gmx.de                                                   *
   6  ***************************************************************************/
   7
   8 #ifdef HAVE_CONFIG_H
   9 #include "config.h"
  10 #endif
  11
  12 #include "virtex2.h"
  13 #include "xilinx_bit.h"
  14 #include "pld.h"
  15
  16 static int virtex2_set_instr(struct jtag_tap *tap, uint32_t new_instr)
  17 {
  18         if (!tap)
  19                 return ERROR_FAIL;
  20
  21         if (buf_get_u32(tap->cur_instr, 0, tap->ir_length) != new_instr) {
  22                 struct scan_field field;
  23
  24                 field.num_bits = tap->ir_length;
  25                 void *t = calloc(DIV_ROUND_UP(field.num_bits, 8), 1);
  26                 if (!t) {
  27                         LOG_ERROR("Out of memory");
  28                         return ERROR_FAIL;
  29                 }
  30                 field.out_value = t;
  31                 buf_set_u32(t, 0, field.num_bits, new_instr);
  32                 field.in_value = NULL;
  33
  34                 jtag_add_ir_scan(tap, &field, TAP_IDLE);
  35
  36                 free(t);
  37         }
  38
  39         return ERROR_OK;
  40 }
  41
  42 static int virtex2_send_32(struct pld_device *pld_device,
  43         int num_words, uint32_t *words)
  44 {
  45         struct virtex2_pld_device *virtex2_info = pld_device->driver_priv;
  46         struct scan_field scan_field;
  47         uint8_t *values;
  48         int i;
  49
  50         values = malloc(num_words * 4);
  51         if (!values) {
  52                 LOG_ERROR("Out of memory");
  53                 return ERROR_FAIL;
  54         }
  55
  56         scan_field.num_bits = num_words * 32;
  57         scan_field.out_value = values;
  58         scan_field.in_value = NULL;
  59
  60         for (i = 0; i < num_words; i++)
  61                 buf_set_u32(values + 4 * i, 0, 32, flip_u32(*words++, 32));
  62
  63         int retval = virtex2_set_instr(virtex2_info->tap, 0x5); /* CFG_IN */
  64         if (retval != ERROR_OK) {
  65                 free(values);
  66                 return retval;
  67         }
  68
  69         jtag_add_dr_scan(virtex2_info->tap, 1, &scan_field, TAP_DRPAUSE);
  70
  71         free(values);
  72
  73         return ERROR_OK;
  74 }
  75
  76 static inline void virtexflip32(jtag_callback_data_t arg)
  77 {
  78         uint8_t *in = (uint8_t *)arg;
  79         *((uint32_t *)arg) = flip_u32(le_to_h_u32(in), 32);
  80 }
  81
  82 static int virtex2_receive_32(struct pld_device *pld_device,
  83         int num_words, uint32_t *words)
  84 {
  85         struct virtex2_pld_device *virtex2_info = pld_device->driver_priv;
  86         struct scan_field scan_field;
  87
  88         scan_field.num_bits = 32;
  89         scan_field.out_value = NULL;
  90         scan_field.in_value = NULL;
  91
  92         int retval = virtex2_set_instr(virtex2_info->tap, 0x4); /* CFG_OUT */
  93         if (retval != ERROR_OK)
  94                 return retval;
  95
  96         while (num_words--) {
  97                 scan_field.in_value = (uint8_t *)words;
  98
  99                 jtag_add_dr_scan(virtex2_info->tap, 1, &scan_field, TAP_DRPAUSE);
 100
 101                 jtag_add_callback(virtexflip32, (jtag_callback_data_t)words);
 102
 103                 words++;
 104         }
 105
 106         return ERROR_OK;
 107 }
 108
 109 static int virtex2_read_stat(struct pld_device *pld_device, uint32_t *status)
 110 {
 111         uint32_t data[5];
 112
 113         jtag_add_tlr();
 114
 115         data[0] = 0xaa995566;   /* synch word */
 116         data[1] = 0x2800E001;   /* Type 1, read, address 7, 1 word */
 117         data[2] = 0x20000000;   /* NOOP (Type 1, read, address 0, 0 words */
 118         data[3] = 0x20000000;   /* NOOP */
 119         data[4] = 0x20000000;   /* NOOP */
 120         int retval = virtex2_send_32(pld_device, 5, data);
 121         if (retval != ERROR_OK)
 122                 return retval;
 123
 124         retval = virtex2_receive_32(pld_device, 1, status);
 125         if (retval != ERROR_OK)
 126                 return retval;
 127
 128         retval = jtag_execute_queue();
 129         if (retval == ERROR_OK)
 130                 LOG_DEBUG("status: 0x%8.8" PRIx32, *status);
 131
 132         return retval;
 133 }
 134
 135 static int virtex2_load_prepare(struct pld_device *pld_device)
 136 {
 137         struct virtex2_pld_device *virtex2_info = pld_device->driver_priv;
 138         int retval;
 139
 140         retval = virtex2_set_instr(virtex2_info->tap, 0xb);     /* JPROG_B */
 141         if (retval != ERROR_OK)
 142                 return retval;
 143
 144         retval = jtag_execute_queue();
 145         if (retval != ERROR_OK)
 146                 return retval;
 147         jtag_add_sleep(1000);
 148
 149         retval = virtex2_set_instr(virtex2_info->tap, 0x5);     /* CFG_IN */
 150         if (retval != ERROR_OK)
 151                 return retval;
 152
 153         return jtag_execute_queue();
 154 }
 155
 156 static int virtex2_load_cleanup(struct pld_device *pld_device)
 157 {
 158         struct virtex2_pld_device *virtex2_info = pld_device->driver_priv;
 159         int retval;
 160
 161         jtag_add_tlr();
 162
 163         if (!(virtex2_info->no_jstart)) {
 164                 retval = virtex2_set_instr(virtex2_info->tap, 0xc);     /* JSTART */
 165                 if (retval != ERROR_OK)
 166                         return retval;
 167         }
 168         jtag_add_runtest(13, TAP_IDLE);
 169         retval = virtex2_set_instr(virtex2_info->tap, 0x3f);            /* BYPASS */
 170         if (retval != ERROR_OK)
 171                 return retval;
 172         retval = virtex2_set_instr(virtex2_info->tap, 0x3f);            /* BYPASS */
 173         if (retval != ERROR_OK)
 174                 return retval;
 175         if (!(virtex2_info->no_jstart)) {
 176                 retval = virtex2_set_instr(virtex2_info->tap, 0xc);     /* JSTART */
 177                 if (retval != ERROR_OK)
 178                         return retval;
 179         }
 180         jtag_add_runtest(13, TAP_IDLE);
 181         retval = virtex2_set_instr(virtex2_info->tap, 0x3f);            /* BYPASS */
 182         if (retval != ERROR_OK)
 183                 return retval;
 184
 185         return jtag_execute_queue();
 186 }
 187
 188 static int virtex2_load(struct pld_device *pld_device, const char *filename)
 189 {
 190         struct virtex2_pld_device *virtex2_info = pld_device->driver_priv;
 191         struct xilinx_bit_file bit_file;
 192         int retval;
 193         unsigned int i;
 194         struct scan_field field;
 195
 196         field.in_value = NULL;
 197
 198         retval = xilinx_read_bit_file(&bit_file, filename);
 199         if (retval != ERROR_OK)
 200                 return retval;
 201
 202         retval = virtex2_load_prepare(pld_device);
 203         if (retval != ERROR_OK) {
 204                 xilinx_free_bit_file(&bit_file);
 205                 return retval;
 206         }
 207
 208         for (i = 0; i < bit_file.length; i++)
 209                 bit_file.data[i] = flip_u32(bit_file.data[i], 8);
 210
 211         field.num_bits = bit_file.length * 8;
 212         field.out_value = bit_file.data;
 213
 214         jtag_add_dr_scan(virtex2_info->tap, 1, &field, TAP_DRPAUSE);
 215         retval = jtag_execute_queue();
 216         if (retval != ERROR_OK) {
 217                 xilinx_free_bit_file(&bit_file);
 218                 return retval;
 219         }
 220
 221         retval = virtex2_load_cleanup(pld_device);
 222
 223         xilinx_free_bit_file(&bit_file);
 224
 225         return retval;
 226 }
 227
 228 COMMAND_HANDLER(virtex2_handle_read_stat_command)
 229 {
 230         struct pld_device *device;
 231         uint32_t status;
 232
 233         if (CMD_ARGC < 1)
 234                 return ERROR_COMMAND_SYNTAX_ERROR;
 235
 236         unsigned dev_id;
 237         COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], dev_id);
 238         device = get_pld_device_by_num(dev_id);
 239         if (!device) {
 240                 command_print(CMD, "pld device '#%s' is out of bounds", CMD_ARGV[0]);
 241                 return ERROR_FAIL;
 242         }
 243
 244         int retval = virtex2_read_stat(device, &status);
 245         if (retval != ERROR_OK) {
 246                 command_print(CMD, "cannot read virtex2 status register");
 247                 return retval;
 248         }
 249
 250         command_print(CMD, "virtex2 status register: 0x%8.8" PRIx32, status);
 251
 252         return ERROR_OK;
 253 }
 254
 255 PLD_DEVICE_COMMAND_HANDLER(virtex2_pld_device_command)
 256 {
 257         struct jtag_tap *tap;
 258
 259         struct virtex2_pld_device *virtex2_info;
 260
 261         if (CMD_ARGC < 2)
 262                 return ERROR_COMMAND_SYNTAX_ERROR;
 263
 264         tap = jtag_tap_by_string(CMD_ARGV[1]);
 265         if (!tap) {
 266                 command_print(CMD, "Tap: %s does not exist", CMD_ARGV[1]);
 267                 return ERROR_FAIL;
 268         }
 269
 270         virtex2_info = malloc(sizeof(struct virtex2_pld_device));
 271         if (!virtex2_info) {
 272                 LOG_ERROR("Out of memory");
 273                 return ERROR_FAIL;
 274         }
 275         virtex2_info->tap = tap;
 276
 277         virtex2_info->no_jstart = 0;
 278         if (CMD_ARGC >= 3)
 279                 COMMAND_PARSE_NUMBER(int, CMD_ARGV[2], virtex2_info->no_jstart);
 280
 281         pld->driver_priv = virtex2_info;
 282
 283         return ERROR_OK;
 284 }
 285
 286 static const struct command_registration virtex2_exec_command_handlers[] = {
 287         {
 288                 .name = "read_stat",
 289                 .mode = COMMAND_EXEC,
 290                 .handler = virtex2_handle_read_stat_command,
 291                 .help = "read status register",
 292                 .usage = "pld_num",
 293         },
 294         COMMAND_REGISTRATION_DONE
 295 };
 296 static const struct command_registration virtex2_command_handler[] = {
 297         {
 298                 .name = "virtex2",
 299                 .mode = COMMAND_ANY,
 300                 .help = "Virtex-II specific commands",
 301                 .usage = "",
 302                 .chain = virtex2_exec_command_handlers,
 303         },
 304         COMMAND_REGISTRATION_DONE
 305 };
 306
 307 struct pld_driver virtex2_pld = {
 308         .name = "virtex2",
 309         .commands = virtex2_command_handler,
 310         .pld_device_command = &virtex2_pld_device_command,
 311         .load = &virtex2_load,
 312 };