suzanne.soy/fpgatools
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

minor cleanup

Browse Source
This commit is contained in:
Wolfgang Spraul 2013-02-23 03:28:11 -05:00
parent 5b961b1dfd
commit 153e764bf1
7 changed files with 183 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
bit2fp.c
View File

@ -9,32 +9,40 @@
#include "floorplan.h" #include "floorplan.h"
#include "bit.h" #include "bit.h"
int main(int argc, char** argv) static void help_exit(int argc, char **argv)
{ {
struct fpga_model model;
int bit_header, bit_regs, bit_crc, fp_header, pull_model, file_arg, flags;
int rc = -1;
struct fpga_config config;
// parameters
if (argc < 2) {
fprintf(stderr, fprintf(stderr,
"\n" "\n"
"%s - bitstream to floorplan\n" "%s - bitstream to floorplan\n"
"Usage: %s [--bit-header] [--bit-regs] [--bit-crc] [--no-model]\n" "Usage: %s [--help] [--verbose] [--bit-header] [--bit-regs] [--bit-crc]\n"
" %*s [--no-fp-header] <bitstream_file>\n" " %*s [--no-model] [--no-fp-header] <bitstream_file>\n"
"\n", argv[0], argv[0], (int) strlen(argv[0]), ""); "\n", argv[0], argv[0], (int) strlen(argv[0]), "");
goto fail; exit(EXIT_SUCCESS);
} }
int main(int argc, char** argv)
{
struct fpga_model model;
int bit_header, bit_regs, bit_crc, fp_header, pull_model, file_arg;
int verbose, flags, rc = -1;
struct fpga_config config;
// parameters
if (argc < 2) help_exit(argc, argv);
verbose = 0;
bit_header = 0; bit_header = 0;
bit_regs = 0; bit_regs = 0;
bit_crc = 0; bit_crc = 0;
pull_model = 1; pull_model = 1;
fp_header = 1; fp_header = 1;
file_arg = 1; file_arg = 1;
while (file_arg < argc while (file_arg < argc && !strncmp(argv[file_arg], "--", 2)) {
&& !strncmp(argv[file_arg], "--", 2)) { if (!strcmp(argv[file_arg], "--help"))
if (!strcmp(argv[file_arg], "--bit-header")) help_exit(argc, argv);
if (!strcmp(argv[file_arg], "--verbose"))
verbose = 1;
else if (!strcmp(argv[file_arg], "--bit-header"))
bit_header = 1; bit_header = 1;
else if (!strcmp(argv[file_arg], "--bit-regs")) else if (!strcmp(argv[file_arg], "--bit-regs"))
bit_regs = 1; bit_regs = 1;
@ -55,7 +63,7 @@ int main(int argc, char** argv)
fprintf(stderr, "Error opening %s.\n", argv[file_arg]); fprintf(stderr, "Error opening %s.\n", argv[file_arg]);
goto fail; goto fail;
} }
rc = read_bitfile(&config, fbits); rc = read_bitfile(&config, fbits, verbose);
fclose(fbits); fclose(fbits);
if (rc) FAIL(rc); if (rc) FAIL(rc);
} }

4
libs/bit.h
View File

@ -74,6 +74,8 @@ struct fpga_bits
struct fpga_config struct fpga_config
{ {
int verbose_read;
char header_str[4][MAX_HEADER_STR_LEN]; char header_str[4][MAX_HEADER_STR_LEN];
int num_regs; int num_regs;
@ -87,7 +89,7 @@ struct fpga_config
uint32_t auto_crc; uint32_t auto_crc;
}; };
int read_bitfile(struct fpga_config* cfg, FILE* f); int read_bitfile(struct fpga_config* cfg, FILE* f, int verbose_read);
#define DUMP_HEADER_STR 0x0001 #define DUMP_HEADER_STR 0x0001
#define DUMP_REGS 0x0002 #define DUMP_REGS 0x0002

123
libs/bit_regs.c
View File

@ -29,12 +29,13 @@ static int parse_commands(struct fpga_config* config, uint8_t* d,
#define BITSTREAM_READ_PAGESIZE 4096 #define BITSTREAM_READ_PAGESIZE 4096
int read_bitfile(struct fpga_config* cfg, FILE* f) int read_bitfile(struct fpga_config* cfg, FILE* f, int verbose_read)
{ {
uint8_t* bit_data = 0; uint8_t* bit_data = 0;
int rc, file_len, bit_len, bit_cur; int rc, file_len, bit_len, bit_cur;
memset(cfg, 0, sizeof(*cfg)); memset(cfg, 0, sizeof(*cfg));
cfg->verbose_read = verbose_read;
cfg->num_regs_before_bits = -1; cfg->num_regs_before_bits = -1;
cfg->idcode_reg = -1; cfg->idcode_reg = -1;
cfg->FLR_reg = -1; cfg->FLR_reg = -1;
@ -851,10 +852,45 @@ static void print_ramb16_cfg(ramb16_cfg_t* cfg)
printf("}\n"); printf("}\n");
} }
static void printf_minors(int row, int major, int minor, int num_minors, const uint8_t *major_bits) static void printf_minor_diff(int row, int major, int minor,
const uint8_t *old_minor_bits, const uint8_t *new_minor_bits)
{
int word_i, w_old, w_new;
char v16_str[32];
// print words as pins (fpga bit ordering)
for (word_i = 0; word_i < FRAME_SIZE/XC6_WORD_BYTES; word_i++) {
if (word_i == XC6_HCLK_POS/XC6_WORD_BYTES)
sprintf(v16_str, "v16_clk");
else
sprintf(v16_str, "v16_%i",
word_i<XC6_HCLK_POS/XC6_WORD_BYTES ? word_i : word_i - 1);
w_old = frame_get_pinword(&old_minor_bits[word_i*XC6_WORD_BYTES]);
w_new = frame_get_pinword(&new_minor_bits[word_i*XC6_WORD_BYTES]);
if (w_old == w_new) continue;
printf("#I <r%i ma%i %s mi%i pin %s", row, major, v16_str, minor, fmt_word(w_old));
printf("#I >r%i ma%i %s mi%i pin %s", row, major, v16_str, minor, fmt_word(w_new));
}
// print words as bits (cpu bit ordering)
for (word_i = 0; word_i < FRAME_SIZE/XC6_WORD_BYTES; word_i++) {
if (word_i == XC6_HCLK_POS/XC6_WORD_BYTES)
sprintf(v16_str, "v16_clk");
else
sprintf(v16_str, "v16_%i",
word_i<XC6_HCLK_POS/XC6_WORD_BYTES ? word_i : word_i - 1);
w_old = frame_get_pinword(&old_minor_bits[word_i*XC6_WORD_BYTES]);
w_new = frame_get_pinword(&new_minor_bits[word_i*XC6_WORD_BYTES]);
if (w_old == w_new) continue;
printf("#I <r%i ma%i %s mi%i cpu %s", row, major, v16_str, minor, fmt_word(pinword_to_cpu(w_old)));
printf("#I >r%i ma%i %s mi%i cpu %s", row, major, v16_str, minor, fmt_word(pinword_to_cpu(w_new)));
}
}
static void printf_minors(int row, int major, int minor, int num_minors,
const uint8_t *major_bits)
{ {
int word_i, minor_i, w; int word_i, minor_i, w;
char v16_str[32], prefix[128]; char v16_str[32];
// print words as pins (fpga bit ordering) // print words as pins (fpga bit ordering)
for (word_i = 0; word_i < FRAME_SIZE/XC6_WORD_BYTES; word_i++) { for (word_i = 0; word_i < FRAME_SIZE/XC6_WORD_BYTES; word_i++) {
@ -867,8 +903,7 @@ static void printf_minors(int row, int major, int minor, int num_minors, const u
w = frame_get_pinword(&major_bits[minor_i*FRAME_SIZE w = frame_get_pinword(&major_bits[minor_i*FRAME_SIZE
+ word_i*XC6_WORD_BYTES]); + word_i*XC6_WORD_BYTES]);
if (!w) continue; if (!w) continue;
sprintf(prefix, "r%i ma%i %s mi%i pin", row, major, v16_str, minor_i); printf("r%i ma%i %s mi%i pin %s", row, major, v16_str, minor_i, fmt_word(w));
printf_word(prefix, w);
} }
} }
// print words as bits (cpu bit ordering) // print words as bits (cpu bit ordering)
@ -882,8 +917,7 @@ static void printf_minors(int row, int major, int minor, int num_minors, const u
w = frame_get_pinword(&major_bits[minor_i*FRAME_SIZE w = frame_get_pinword(&major_bits[minor_i*FRAME_SIZE
+ word_i*XC6_WORD_BYTES]); + word_i*XC6_WORD_BYTES]);
if (!w) continue; if (!w) continue;
sprintf(prefix, "r%i ma%i %s mi%i cpu", row, major, v16_str, minor_i); printf("r%i ma%i %s mi%i cpu %s", row, major, v16_str, minor_i, fmt_word(pinword_to_cpu(w)));
printf_word(prefix, pinword_to_cpu(w));
} }
} }
} }
@ -1055,7 +1089,7 @@ int dump_config(struct fpga_config* cfg, int flags)
rc = dump_bram(cfg); rc = dump_bram(cfg);
if (rc) FAIL(rc); if (rc) FAIL(rc);
printf_type2(cfg->bits.d, cfg->bits.len, printf_type2(cfg->bits.d, cfg->bits.len,
BRAM_DATA_START + BRAM_DATA_LEN, 896*2/8); BRAM_DATA_START + BRAM_DATA_LEN, IOB_WORDS*2/8);
if (flags & DUMP_CRC) if (flags & DUMP_CRC)
printf("auto-crc 0x%X\n", cfg->auto_crc); printf("auto-crc 0x%X\n", cfg->auto_crc);
} }
@ -1138,10 +1172,10 @@ static int FAR_pos(int FAR_row, int FAR_major, int FAR_minor)
if (FAR_row > 3 || FAR_major > 17 if (FAR_row > 3 || FAR_major > 17
|| FAR_minor >= get_major_minors(XC6SLX9, FAR_major)) || FAR_minor >= get_major_minors(XC6SLX9, FAR_major))
return -1; return -1;
result = FAR_row * 505*130; result = FAR_row * 505*FRAME_SIZE;
for (i = 0; i < FAR_major; i++) for (i = 0; i < FAR_major; i++)
result += get_major_minors(XC6SLX9, i)*130; result += get_major_minors(XC6SLX9, i)*FRAME_SIZE;
return result + FAR_minor*130; return result + FAR_minor*FRAME_SIZE;
} }
static int read_bits(struct fpga_config* cfg, uint8_t* d, int len, static int read_bits(struct fpga_config* cfg, uint8_t* d, int len,
@ -1159,13 +1193,14 @@ static int read_bits(struct fpga_config* cfg, uint8_t* d, int len,
if (cfg->idcode_reg == -1 || cfg->FLR_reg == -1 if (cfg->idcode_reg == -1 || cfg->FLR_reg == -1
|| (cfg->reg[cfg->idcode_reg].int_v != XC6SLX4 || (cfg->reg[cfg->idcode_reg].int_v != XC6SLX4
&& cfg->reg[cfg->idcode_reg].int_v != XC6SLX9) && cfg->reg[cfg->idcode_reg].int_v != XC6SLX9)
|| cfg->reg[cfg->FLR_reg].int_v != 896) || cfg->reg[cfg->FLR_reg].int_v != IOB_WORDS)
FAIL(EINVAL); FAIL(EINVAL);
cfg->bits.len = (4*505 + 4*144) * FRAME_SIZE + 896*2; cfg->bits.len = (4*505 + 4*144) * FRAME_SIZE + IOB_WORDS*2;
cfg->bits.d = calloc(cfg->bits.len, 1 /* elsize */); cfg->bits.d = calloc(cfg->bits.len, 1 /* elsize */);
if (!cfg->bits.d) FAIL(ENOMEM); if (!cfg->bits.d) FAIL(ENOMEM);
cfg->auto_crc = 0; cfg->auto_crc = 0;
POUT(cfg->verbose_read, ("#D expected bits length is %i bytes\n", cfg->bits.len));
FAR_block = -1; FAR_block = -1;
FAR_row = -1; FAR_row = -1;
@ -1269,6 +1304,8 @@ static int read_bits(struct fpga_config* cfg, uint8_t* d, int len,
if (2*u32 < 130) FAIL(EINVAL); if (2*u32 < 130) FAIL(EINVAL);
last_FDRI_pos = src_off+u32*2+/*auto-crc*/4; last_FDRI_pos = src_off+u32*2+/*auto-crc*/4;
POUT(cfg->verbose_read, ("#D src 0x%X: %i fdri words, last_FDRI_pos %i\n",
src_off-4, u32, last_FDRI_pos));
// fdri words u32 // fdri words u32
if (FAR_block == -1 || FAR_block > 1 || FAR_row == -1 if (FAR_block == -1 || FAR_block > 1 || FAR_row == -1
@ -1280,17 +1317,22 @@ static int read_bits(struct fpga_config* cfg, uint8_t* d, int len,
offset_in_bits = FAR_pos(FAR_row, FAR_major, FAR_minor); offset_in_bits = FAR_pos(FAR_row, FAR_major, FAR_minor);
if (offset_in_bits == -1) FAIL(EINVAL); if (offset_in_bits == -1) FAIL(EINVAL);
POUT(cfg->verbose_read,
("#D FAR_pos r%i ma%i mi%i = %i bytes\n",
FAR_row, FAR_major, FAR_minor, offset_in_bits));
if (!FAR_row && !FAR_major && !FAR_minor if (!FAR_row && !FAR_major && !FAR_minor
&& u32 > 4*(505+2)*65) && u32 > 4*(505+2)*XC6_FRAME_WORDS)
block0_words = 4*(505+2)*65; block0_words = 4*(505+2)*XC6_FRAME_WORDS;
else { else {
block0_words = u32; block0_words = u32;
if (block0_words % 65) FAIL(EINVAL); if (block0_words % XC6_FRAME_WORDS) FAIL(EINVAL);
} }
POUT(cfg->verbose_read, ("#D %i block0 words\n", block0_words));
padding_frames = 0; padding_frames = 0;
for (i = 0; i < block0_words/65; i++) { for (i = 0; i < block0_words/XC6_FRAME_WORDS; i++) {
if (i && i+1 == block0_words/65) { if (i && i+1 == block0_words/XC6_FRAME_WORDS) {
for (j = 0; j < 130; j++) { for (j = 0; j < FRAME_SIZE; j++) {
if (d[src_off+i*130+j] if (d[src_off+i*130+j]
!= 0xFF) break; != 0xFF) break;
} }
@ -1313,13 +1355,40 @@ static int read_bits(struct fpga_config* cfg, uint8_t* d, int len,
padding_frames += 2; padding_frames += 2;
continue; continue;
} }
if (cfg->verbose_read && offset_in_bits) {
printf("#D copying %i bytes from file_off 0x%X to bits_off %i\n",
FRAME_SIZE, src_off+i*FRAME_SIZE,
offset_in_bits + (i-padding_frames)*FRAME_SIZE);
for (j = 0; j < FRAME_SIZE; j++) {
if (cfg->bits.d[offset_in_bits + (i-padding_frames)*FRAME_SIZE + j])
break;
}
if (j >= FRAME_SIZE)
printf("dest all-0\n");
else {
printf("dest {\n");
dump_data(1, &cfg->bits.d[offset_in_bits + (i-padding_frames)*FRAME_SIZE],
FRAME_SIZE, 16);
printf("}\n");
}
printf("src {\n");
dump_data(1, &d[src_off + i*FRAME_SIZE], FRAME_SIZE, 16);
printf("}\n");
}
if (offset_in_bits)
printf_minor_diff(FAR_row, FAR_major, FAR_minor,
&cfg->bits.d[offset_in_bits + (i-padding_frames)*FRAME_SIZE],
&d[src_off + i*FRAME_SIZE]);
memcpy(&cfg->bits.d[offset_in_bits memcpy(&cfg->bits.d[offset_in_bits
+ (i-padding_frames)*FRAME_SIZE], + (i-padding_frames)*FRAME_SIZE],
&d[src_off + i*FRAME_SIZE], FRAME_SIZE); &d[src_off + i*FRAME_SIZE], FRAME_SIZE);
} }
} }
if (u32 - block0_words > 0) { if (u32 - block0_words > 0) {
int bram_data_words = 4*144*65 + 896; int bram_data_words = 4*144*XC6_FRAME_WORDS + IOB_WORDS;
POUT(cfg->verbose_read, ("#D block0 words: %i bram_data words: %i fdri words: %i\n",
block0_words, bram_data_words, u32));
if (u32 - block0_words != bram_data_words + 1) FAIL(EINVAL); if (u32 - block0_words != bram_data_words + 1) FAIL(EINVAL);
offset_in_bits = BRAM_DATA_START; offset_in_bits = BRAM_DATA_START;
memcpy(&cfg->bits.d[offset_in_bits], memcpy(&cfg->bits.d[offset_in_bits],
@ -1327,7 +1396,15 @@ static int read_bits(struct fpga_config* cfg, uint8_t* d, int len,
bram_data_words*2); bram_data_words*2);
u16 = __be16_to_cpu(*(uint16_t*)&d[ u16 = __be16_to_cpu(*(uint16_t*)&d[
(src_off+block0_words+bram_data_words)*2]); (src_off+block0_words+bram_data_words)*2]);
if (u16) FAIL(EINVAL); if (u16) {
if (u16 != 0xFFFF) {
PERR(("#E %s:%i post-bram word 0x%Xh (expected 0 or 0xFFFF).\n",
__FILE__, __LINE__, u16));
rc = EINVAL;
goto fail;
}
POUT(cfg->verbose_read, ("#D post-bram word 0xFFFF\n"));
}
} }
src_off += 2*u32; src_off += 2*u32;
cfg->auto_crc = __be32_to_cpu(*(uint32_t*)&d[src_off]); cfg->auto_crc = __be32_to_cpu(*(uint32_t*)&d[src_off]);
@ -1450,7 +1527,7 @@ static int parse_commands(struct fpga_config* cfg, uint8_t* d,
if ((cfg->reg[cfg->idcode_reg].int_v == XC6SLX4 if ((cfg->reg[cfg->idcode_reg].int_v == XC6SLX4
|| cfg->reg[cfg->idcode_reg].int_v == XC6SLX9) || cfg->reg[cfg->idcode_reg].int_v == XC6SLX9)
&& cfg->reg[cfg->FLR_reg].int_v != 896) && cfg->reg[cfg->FLR_reg].int_v != IOB_WORDS)
printf("#W Unexpected FLR value %i on " printf("#W Unexpected FLR value %i on "
"idcode 0x%X.\n", "idcode 0x%X.\n",
cfg->reg[cfg->FLR_reg].int_v, cfg->reg[cfg->FLR_reg].int_v,
@ -1598,7 +1675,7 @@ fail:
static struct fpga_config_reg_rw s_defregs_before_bits[] = static struct fpga_config_reg_rw s_defregs_before_bits[] =
{{ CMD, .int_v = CMD_RCRC }, {{ CMD, .int_v = CMD_RCRC },
{ REG_NOOP }, { REG_NOOP },
{ FLR, .int_v = 896 }, { FLR, .int_v = IOB_WORDS },
{ COR1, .int_v = COR1_DEF | COR1_CRC_BYPASS }, { COR1, .int_v = COR1_DEF | COR1_CRC_BYPASS },
{ COR2, .int_v = COR2_DEF }, { COR2, .int_v = COR2_DEF },
{ IDCODE, .int_v = XC6SLX9 }, { IDCODE, .int_v = XC6SLX9 },

68
libs/helper.c
View File

@ -9,6 +9,22 @@
#include <errno.h> #include <errno.h>
#include "model.h" #include "model.h"
void printf_stdout(const char* fmt, ...)
{
va_list arg_list;
va_start(arg_list, fmt);
vfprintf(stdout, fmt, arg_list);
va_end(arg_list);
}
void printf_stderr(const char* fmt, ...)
{
va_list arg_list;
va_start(arg_list, fmt);
vfprintf(stderr, fmt, arg_list);
va_end(arg_list);
}
const char *bitstr(uint32_t value, int digits) const char *bitstr(uint32_t value, int digits)
{ {
static char str[2 /* "0b" */ + 32 + 1 /* '\0' */]; static char str[2 /* "0b" */ + 32 + 1 /* '\0' */];
@ -22,7 +38,7 @@ const char *bitstr(uint32_t value, int digits)
return str; return str;
} }
static void dump_data(int indent, const uint8_t *data, int len, int base) void dump_data(int indent, const uint8_t *data, int len, int base)
{ {
int i, j, k; int i, j, k;
char fmt_str[16] = "%s@%05x"; char fmt_str[16] = "%s@%05x";
@ -886,64 +902,62 @@ void printf_v64_mi20(const uint8_t* bits, int row, int major)
} }
} }
void printf_word(const char *prefix, int word) const char *fmt_word(int word)
{ {
enum { NUM_BUFS = 16, BUF_SIZE = 64 };
static char buf[NUM_BUFS][BUF_SIZE];
static int last_buf = 0;
char bit_str[XC6_WORD_BITS]; char bit_str[XC6_WORD_BITS];
int i, num_bits_printed; int i, num_bits_printed;
last_buf = (last_buf+1)%NUM_BUFS;
for (i = 0; i < XC6_WORD_BITS; i++) for (i = 0; i < XC6_WORD_BITS; i++)
bit_str[i] = (word & (1ULL << (XC6_WORD_BITS-i-1))) ? '1' : '0'; bit_str[i] = (word & (1ULL << (XC6_WORD_BITS-i-1))) ? '1' : '0';
printf("%s 0b%.*s 0x%.*X", prefix, XC6_WORD_BITS, bit_str, XC6_WORD_BITS/4, word); snprintf(buf[last_buf], sizeof(*buf), "0b%.*s 0x%.*X", XC6_WORD_BITS, bit_str, XC6_WORD_BITS/4, word);
num_bits_printed = 0; num_bits_printed = 0;
for (i = 0; i < XC6_WORD_BITS; i++) { for (i = 0; i < XC6_WORD_BITS; i++) {
if (word & (1 << i)) { if (word & (1 << i)) {
if (num_bits_printed >= 4) { if (num_bits_printed >= 4) {
printf(" ..."); sprintf(&buf[last_buf][strlen(buf[last_buf])], " ...");
break; break;
} }
printf(" %i", i); sprintf(&buf[last_buf][strlen(buf[last_buf])], " %i", i);
num_bits_printed++; num_bits_printed++;
} }
} }
printf("\n"); strcat(buf[last_buf], "\n");
return buf[last_buf];
} }
void printf_lut_words(const uint8_t *major_bits, int row, int major, int minor, int v16_i) void printf_lut_words(const uint8_t *major_bits, int row, int major, int minor, int v16_i)
{ {
int off_in_frame, w; int off_in_frame, w;
char prefix[64];
off_in_frame = v16_i*XC6_WORD_BYTES; off_in_frame = v16_i*XC6_WORD_BYTES;
if (off_in_frame >= XC6_HCLK_POS) if (off_in_frame >= XC6_HCLK_POS)
off_in_frame += XC6_HCLK_BYTES; off_in_frame += XC6_HCLK_BYTES;
w = frame_get_pinword(&major_bits[minor*FRAME_SIZE + off_in_frame]); w = frame_get_pinword(&major_bits[minor*FRAME_SIZE + off_in_frame]);
if (w) { if (w)
sprintf(prefix, "r%i ma%i v%i_%i mi%i pin", row, major, XC6_WORD_BITS, printf("r%i ma%i v%i_%i mi%i pin %s", row, major, XC6_WORD_BITS,
v16_i, minor); v16_i, minor, fmt_word(w));
printf_word(prefix, w);
}
w = frame_get_pinword(&major_bits[minor*FRAME_SIZE + off_in_frame + XC6_WORD_BYTES]); w = frame_get_pinword(&major_bits[minor*FRAME_SIZE + off_in_frame + XC6_WORD_BYTES]);
if (w) { if (w)
sprintf(prefix, "r%i ma%i v%i_%i mi%i pin", row, major, XC6_WORD_BITS, printf("r%i ma%i v%i_%i mi%i pin %s", row, major, XC6_WORD_BITS,
v16_i+1, minor); v16_i+1, minor, fmt_word(w));
printf_word(prefix, w);
}
w = frame_get_pinword(&major_bits[(minor+1)*FRAME_SIZE + off_in_frame]); w = frame_get_pinword(&major_bits[(minor+1)*FRAME_SIZE + off_in_frame]);
if (w) { if (w)
sprintf(prefix, "r%i ma%i v%i_%i mi%i pin", row, major, XC6_WORD_BITS, printf("r%i ma%i v%i_%i mi%i pin %s", row, major, XC6_WORD_BITS,
v16_i, minor+1); v16_i, minor+1, fmt_word(w));
printf_word(prefix, w);
}
w = frame_get_pinword(&major_bits[(minor+1)*FRAME_SIZE + off_in_frame + XC6_WORD_BYTES]); w = frame_get_pinword(&major_bits[(minor+1)*FRAME_SIZE + off_in_frame + XC6_WORD_BYTES]);
if (w) { if (w)
sprintf(prefix, "r%i ma%i v%i_%i mi%i pin", row, major, XC6_WORD_BITS, printf("r%i ma%i v%i_%i mi%i pin %s", row, major, XC6_WORD_BITS,
v16_i+1, minor+1); v16_i+1, minor+1, fmt_word(w));
printf_word(prefix, w);
}
} }
int get_vm_mb(void) int get_vm_mb(void)

20
libs/helper.h
View File

@ -12,17 +12,18 @@
#include <unistd.h> #include <unistd.h>
#include <fcntl.h> #include <fcntl.h>
#include <sys/types.h> #include <sys/types.h>
#include <stdarg.h>
#define PROGRAM_REVISION "2012-06-27"
#define MACRO_STR(arg) #arg #define MACRO_STR(arg) #arg
#define OUT_OF_MEM() { fprintf(stderr, \ #define POUT(on, varfmt) (on) ? printf_stdout varfmt : (void) 0
"#E Out of memory in %s:%i\n", __FILE__, __LINE__); } #define PERR(varfmt) do { fflush(stdout); printf_stderr varfmt; } while (0)
#define EXIT(expr) if (expr) { fprintf(stderr, \ #define PHERE() PERR(("#E Internal error in %s:%i\n", __FILE__, __LINE__))
"#E Internal error in %s:%i\n", __FILE__, __LINE__); exit(1); }
#define HERE() fprintf(stderr, "#E Internal error in %s:%i\n", \ #define OUT_OF_MEM() PERR(("#E Out of memory in %s:%i\n", __FILE__, __LINE__))
__FILE__, __LINE__) #define EXIT(expr) if (expr) { PERR(("#E Internal error in %s:%i\n", __FILE__, __LINE__)); exit(1); }
#define HERE() do { PERR(("#E Internal error in %s:%i\n", __FILE__, __LINE__)); } while (0)
#define FAIL(code) do { HERE(); rc = (code); goto fail; } while (0) #define FAIL(code) do { HERE(); rc = (code); goto fail; } while (0)
#define XOUT() do { HERE(); goto xout; } while (0) #define XOUT() do { HERE(); goto xout; } while (0)
#define ASSERT(what) do { if (!(what)) FAIL(EINVAL); } while (0) #define ASSERT(what) do { if (!(what)) FAIL(EINVAL); } while (0)
@ -36,7 +37,10 @@
#define OUT_OF_U16(val) ((val) < 0 || (val) > 0xFFFF) #define OUT_OF_U16(val) ((val) < 0 || (val) > 0xFFFF)
void printf_stdout(const char* fmt, ...);
void printf_stderr(const char* fmt, ...);
const char* bitstr(uint32_t value, int digits); const char* bitstr(uint32_t value, int digits);
void dump_data(int indent, const uint8_t *data, int len, int base);
uint16_t __swab16(uint16_t x); uint16_t __swab16(uint16_t x);
uint32_t __swab32(uint32_t x); uint32_t __swab32(uint32_t x);
@ -112,7 +116,7 @@ void write_lut64(uint8_t* two_minors, int off_in_frame, uint64_t u64);
void printf_routing_2minors(const uint8_t* bits, int row, int major, void printf_routing_2minors(const uint8_t* bits, int row, int major,
int even_minor); int even_minor);
void printf_v64_mi20(const uint8_t* bits, int row, int major); void printf_v64_mi20(const uint8_t* bits, int row, int major);
void printf_word(const char *prefix, int word); const char *fmt_word(int word);
void printf_lut_words(const uint8_t *major_bits, int row, int major, void printf_lut_words(const uint8_t *major_bits, int row, int major,
int minor, int v16_i); int minor, int v16_i);

1
libs/model.h
View File

@ -665,6 +665,7 @@ enum {
struct fpgadev_bram struct fpgadev_bram
{ {
// rstram and rst_priority must be set for A and B.
}; };
// //

4
libs/parts.h
View File

@ -130,7 +130,9 @@ const struct xc6_pkg_info *xc6_pkg_info(enum xc6_pkg pkg);
// returns 0 if description not found // returns 0 if description not found
const char *xc6_find_pkg_pin(const struct xc6_pkg_info *pkg_info, const char *description); const char *xc6_find_pkg_pin(const struct xc6_pkg_info *pkg_info, const char *description);
#define FRAME_SIZE 130 #define XC6_FRAME_WORDS 65
#define XC6_WORD_BYTES 2
#define FRAME_SIZE (XC6_FRAME_WORDS*XC6_WORD_BYTES)
#define FRAMES_PER_ROW 505 // for slx4 and slx9 #define FRAMES_PER_ROW 505 // for slx4 and slx9
#define PADDING_FRAMES_PER_ROW 2 #define PADDING_FRAMES_PER_ROW 2
#define NUM_ROWS 4 // for slx9 and slx9 #define NUM_ROWS 4 // for slx9 and slx9