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                 field.out_value = t;
  27                 buf_set_u32(t, 0, field.num_bits, new_instr);
  28                 field.in_value = NULL;
  29
  30                 jtag_add_ir_scan(tap, &field, TAP_IDLE);
  31
  32                 free(t);
  33         }
  34
  35         return ERROR_OK;
  36 }
  37
  38 static int virtex2_send_32(struct pld_device *pld_device,
  39         int num_words, uint32_t *words)
  40 {
  41         struct virtex2_pld_device *virtex2_info = pld_device->driver_priv;
  42         struct scan_field scan_field;
  43         uint8_t *values;
  44         int i;
  45
  46         values = malloc(num_words * 4);
  47
  48         scan_field.num_bits = num_words * 32;
  49         scan_field.out_value = values;
  50         scan_field.in_value = NULL;
  51
  52         for (i = 0; i < num_words; i++)
  53                 buf_set_u32(values + 4 * i, 0, 32, flip_u32(*words++, 32));
  54
  55         virtex2_set_instr(virtex2_info->tap, 0x5);      /* CFG_IN */
  56
  57         jtag_add_dr_scan(virtex2_info->tap, 1, &scan_field, TAP_DRPAUSE);
  58
  59         free(values);
  60
  61         return ERROR_OK;
  62 }
  63
  64 static inline void virtexflip32(jtag_callback_data_t arg)
  65 {
  66         uint8_t *in = (uint8_t *)arg;
  67         *((uint32_t *)arg) = flip_u32(le_to_h_u32(in), 32);
  68 }
  69
  70 static int virtex2_receive_32(struct pld_device *pld_device,
  71         int num_words, uint32_t *words)
  72 {
  73         struct virtex2_pld_device *virtex2_info = pld_device->driver_priv;
  74         struct scan_field scan_field;
  75
  76         scan_field.num_bits = 32;
  77         scan_field.out_value = NULL;
  78         scan_field.in_value = NULL;
  79
  80         virtex2_set_instr(virtex2_info->tap, 0x4);      /* CFG_OUT */
  81
  82         while (num_words--) {
  83                 scan_field.in_value = (uint8_t *)words;
  84
  85                 jtag_add_dr_scan(virtex2_info->tap, 1, &scan_field, TAP_DRPAUSE);
  86
  87                 jtag_add_callback(virtexflip32, (jtag_callback_data_t)words);
  88
  89                 words++;
  90         }
  91
  92         return ERROR_OK;
  93 }
  94
  95 static int virtex2_read_stat(struct pld_device *pld_device, uint32_t *status)
  96 {
  97         uint32_t data[5];
  98
  99         jtag_add_tlr();
 100
 101         data[0] = 0xaa995566;   /* synch word */
 102         data[1] = 0x2800E001;   /* Type 1, read, address 7, 1 word */
 103         data[2] = 0x20000000;   /* NOOP (Type 1, read, address 0, 0 words */
 104         data[3] = 0x20000000;   /* NOOP */
 105         data[4] = 0x20000000;   /* NOOP */
 106         virtex2_send_32(pld_device, 5, data);
 107
 108         virtex2_receive_32(pld_device, 1, status);
 109
 110         jtag_execute_queue();
 111
 112         LOG_DEBUG("status: 0x%8.8" PRIx32 "", *status);
 113
 114         return ERROR_OK;
 115 }
 116
 117 static int virtex2_load(struct pld_device *pld_device, const char *filename)
 118 {
 119         struct virtex2_pld_device *virtex2_info = pld_device->driver_priv;
 120         struct xilinx_bit_file bit_file;
 121         int retval;
 122         unsigned int i;
 123         struct scan_field field;
 124
 125         field.in_value = NULL;
 126
 127         retval = xilinx_read_bit_file(&bit_file, filename);
 128         if (retval != ERROR_OK)
 129                 return retval;
 130
 131         virtex2_set_instr(virtex2_info->tap, 0xb);      /* JPROG_B */
 132         jtag_execute_queue();
 133         jtag_add_sleep(1000);
 134
 135         virtex2_set_instr(virtex2_info->tap, 0x5);      /* CFG_IN */
 136         jtag_execute_queue();
 137
 138         for (i = 0; i < bit_file.length; i++)
 139                 bit_file.data[i] = flip_u32(bit_file.data[i], 8);
 140
 141         field.num_bits = bit_file.length * 8;
 142         field.out_value = bit_file.data;
 143
 144         jtag_add_dr_scan(virtex2_info->tap, 1, &field, TAP_DRPAUSE);
 145         jtag_execute_queue();
 146
 147         jtag_add_tlr();
 148
 149         if (!(virtex2_info->no_jstart))
 150                 virtex2_set_instr(virtex2_info->tap, 0xc);      /* JSTART */
 151         jtag_add_runtest(13, TAP_IDLE);
 152         virtex2_set_instr(virtex2_info->tap, 0x3f);             /* BYPASS */
 153         virtex2_set_instr(virtex2_info->tap, 0x3f);             /* BYPASS */
 154         if (!(virtex2_info->no_jstart))
 155                 virtex2_set_instr(virtex2_info->tap, 0xc);      /* JSTART */
 156         jtag_add_runtest(13, TAP_IDLE);
 157         virtex2_set_instr(virtex2_info->tap, 0x3f);             /* BYPASS */
 158         jtag_execute_queue();
 159
 160         return ERROR_OK;
 161 }
 162
 163 COMMAND_HANDLER(virtex2_handle_read_stat_command)
 164 {
 165         struct pld_device *device;
 166         uint32_t status;
 167
 168         if (CMD_ARGC < 1)
 169                 return ERROR_COMMAND_SYNTAX_ERROR;
 170
 171         unsigned dev_id;
 172         COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], dev_id);
 173         device = get_pld_device_by_num(dev_id);
 174         if (!device) {
 175                 command_print(CMD, "pld device '#%s' is out of bounds", CMD_ARGV[0]);
 176                 return ERROR_OK;
 177         }
 178
 179         virtex2_read_stat(device, &status);
 180
 181         command_print(CMD, "virtex2 status register: 0x%8.8" PRIx32 "", status);
 182
 183         return ERROR_OK;
 184 }
 185
 186 PLD_DEVICE_COMMAND_HANDLER(virtex2_pld_device_command)
 187 {
 188         struct jtag_tap *tap;
 189
 190         struct virtex2_pld_device *virtex2_info;
 191
 192         if (CMD_ARGC < 2)
 193                 return ERROR_COMMAND_SYNTAX_ERROR;
 194
 195         tap = jtag_tap_by_string(CMD_ARGV[1]);
 196         if (!tap) {
 197                 command_print(CMD, "Tap: %s does not exist", CMD_ARGV[1]);
 198                 return ERROR_OK;
 199         }
 200
 201         virtex2_info = malloc(sizeof(struct virtex2_pld_device));
 202         virtex2_info->tap = tap;
 203
 204         virtex2_info->no_jstart = 0;
 205         if (CMD_ARGC >= 3)
 206                 COMMAND_PARSE_NUMBER(int, CMD_ARGV[2], virtex2_info->no_jstart);
 207
 208         pld->driver_priv = virtex2_info;
 209
 210         return ERROR_OK;
 211 }
 212
 213 static const struct command_registration virtex2_exec_command_handlers[] = {
 214         {
 215                 .name = "read_stat",
 216                 .mode = COMMAND_EXEC,
 217                 .handler = virtex2_handle_read_stat_command,
 218                 .help = "read status register",
 219                 .usage = "pld_num",
 220         },
 221         COMMAND_REGISTRATION_DONE
 222 };
 223 static const struct command_registration virtex2_command_handler[] = {
 224         {
 225                 .name = "virtex2",
 226                 .mode = COMMAND_ANY,
 227                 .help = "Virtex-II specific commands",
 228                 .usage = "",
 229                 .chain = virtex2_exec_command_handlers,
 230         },
 231         COMMAND_REGISTRATION_DONE
 232 };
 233
 234 struct pld_driver virtex2_pld = {
 235         .name = "virtex2",
 236         .commands = virtex2_command_handler,
 237         .pld_device_command = &virtex2_pld_device_command,
 238         .load = &virtex2_load,
 239 };