2 * ecpprog -- simple programming tool for FTDI-based JTAG programmers
5 * Copyright (C) 2015 Clifford Wolf <clifford@clifford.at>
6 * Copyright (C) 2018 Piotr Esden-Tempski <piotr@esden.net>
7 * Copyright (C) 2020 Gregory Davill <greg.davill@gmail.com>
9 * Permission to use, copy, modify, and/or distribute this software for any
10 * purpose with or without fee is hereby granted, provided that the above
11 * copyright notice and this permission notice appear in all copies.
13 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
14 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
15 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
16 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
17 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
18 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
19 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
23 * http://www.latticesemi.com/~/media/Documents/UserManuals/EI/icestickusermanual.pdf
24 * http://www.micron.com/~/media/documents/products/data-sheet/nor-flash/serial-nor/n25q/n25q_32mb_3v_65nm.pdf
37 #include <sys/types.h>
41 #include <io.h> /* _setmode() */
42 #include <fcntl.h> /* _O_BINARY */
46 #include "lattice_cmds.h"
48 static bool verbose
= false;
59 enum device_type type
;
62 static struct device_info connected_device
= {0};
65 // ---------------------------------------------------------
67 // ---------------------------------------------------------
69 /* Flash command definitions */
70 /* This command list is based on the Winbond W25Q128JV Datasheet */
72 FC_WE
= 0x06, /* Write Enable */
73 FC_SRWE
= 0x50, /* Volatile SR Write Enable */
74 FC_WD
= 0x04, /* Write Disable */
75 FC_RPD
= 0xAB, /* Release Power-Down, returns Device ID */
76 FC_MFGID
= 0x90, /* Read Manufacturer/Device ID */
77 FC_JEDECID
= 0x9F, /* Read JEDEC ID */
78 FC_UID
= 0x4B, /* Read Unique ID */
79 FC_RD
= 0x03, /* Read Data */
80 FC_FR
= 0x0B, /* Fast Read */
81 FC_PP
= 0x02, /* Page Program */
82 FC_SE
= 0x20, /* Sector Erase 4kb */
83 FC_BE32
= 0x52, /* Block Erase 32kb */
84 FC_BE64
= 0xD8, /* Block Erase 64kb */
85 FC_CE
= 0xC7, /* Chip Erase */
86 FC_RSR1
= 0x05, /* Read Status Register 1 */
87 FC_WSR1
= 0x01, /* Write Status Register 1 */
88 FC_RSR2
= 0x35, /* Read Status Register 2 */
89 FC_WSR2
= 0x31, /* Write Status Register 2 */
90 FC_RSR3
= 0x15, /* Read Status Register 3 */
91 FC_WSR3
= 0x11, /* Write Status Register 3 */
92 FC_RSFDP
= 0x5A, /* Read SFDP Register */
93 FC_ESR
= 0x44, /* Erase Security Register */
94 FC_PSR
= 0x42, /* Program Security Register */
95 FC_RSR
= 0x48, /* Read Security Register */
96 FC_GBL
= 0x7E, /* Global Block Lock */
97 FC_GBU
= 0x98, /* Global Block Unlock */
98 FC_RBL
= 0x3D, /* Read Block Lock */
99 FC_RPR
= 0x3C, /* Read Sector Protection Registers (adesto) */
100 FC_IBL
= 0x36, /* Individual Block Lock */
101 FC_IBU
= 0x39, /* Individual Block Unlock */
102 FC_EPS
= 0x75, /* Erase / Program Suspend */
103 FC_EPR
= 0x7A, /* Erase / Program Resume */
104 FC_PD
= 0xB9, /* Power-down */
105 FC_QPI
= 0x38, /* Enter QPI mode */
106 FC_ERESET
= 0x66, /* Enable Reset */
107 FC_RESET
= 0x99, /* Reset Device */
111 // ---------------------------------------------------------
112 // JTAG -> SPI functions
113 // ---------------------------------------------------------
116 * JTAG performrs all shifts LSB first, our FLSAH is expeting bytes MSB first,
117 * There are a few ways to fix this, for now we just bit-reverse all the input data to the JTAG core
119 uint8_t bit_reverse(uint8_t in
){
121 uint8_t out
= (in
& 0x01) ? 0x80 : 0x00;
122 out
|= (in
& 0x02) ? 0x40 : 0x00;
123 out
|= (in
& 0x04) ? 0x20 : 0x00;
124 out
|= (in
& 0x08) ? 0x10 : 0x00;
125 out
|= (in
& 0x10) ? 0x08 : 0x00;
126 out
|= (in
& 0x20) ? 0x04 : 0x00;
127 out
|= (in
& 0x40) ? 0x02 : 0x00;
128 out
|= (in
& 0x80) ? 0x01 : 0x00;
133 void xfer_spi(uint8_t* data
, uint32_t len
){
134 /* Reverse bit order of all bytes */
135 for(int i
= 0; i
< len
; i
++){
136 data
[i
] = bit_reverse(data
[i
]);
139 /* Don't switch states if we're already in SHIFT-DR */
140 if(jtag_current_state() != STATE_SHIFT_DR
)
141 jtag_go_to_state(STATE_SHIFT_DR
);
142 jtag_tap_shift(data
, data
, len
* 8, true);
144 /* Reverse bit order of all return bytes */
145 for(int i
= 0; i
< len
; i
++){
146 data
[i
] = bit_reverse(data
[i
]);
150 void send_spi(uint8_t* data
, uint32_t len
){
152 /* Flip bit order of all bytes */
153 for(int i
= 0; i
< len
; i
++){
154 data
[i
] = bit_reverse(data
[i
]);
157 jtag_go_to_state(STATE_SHIFT_DR
);
158 /* Stay in SHIFT-DR state, this keep CS low */
159 jtag_tap_shift(data
, data
, len
* 8, false);
161 /* Flip bit order of all bytes */
162 for(int i
= 0; i
< len
; i
++){
163 data
[i
] = bit_reverse(data
[i
]);
168 // ---------------------------------------------------------
169 // FLASH function implementations
170 // ---------------------------------------------------------
172 static void flash_read_id()
174 /* JEDEC ID structure:
175 * Byte No. | Data Type
176 * ---------+----------
177 * 0 | FC_JEDECID Request Command
181 * 4 | Ext Dev Str Len
184 uint8_t data
[260] = { FC_JEDECID
};
185 int len
= 4; // command + 4 response bytes
188 fprintf(stderr
, "read flash ID..\n");
190 // Write command and read first 4 bytes
193 fprintf(stderr
, "flash ID:");
194 for (int i
= 1; i
< len
; i
++)
195 fprintf(stderr
, " 0x%02X", data
[i
]);
196 fprintf(stderr
, "\n");
199 static void flash_reset()
201 uint8_t data
[8] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
205 static uint8_t read_status_1(){
206 uint8_t data
[2] = { FC_RSR1
};
211 fprintf(stderr
, "SR1: 0x%02X\n", data
[1]);
212 fprintf(stderr
, " - SPRL: %s\n",
213 ((data
[1] & (1 << 7)) == 0) ?
216 fprintf(stderr
, " - SPM: %s\n",
217 ((data
[1] & (1 << 6)) == 0) ?
218 "Byte/Page Prog Mode" :
219 "Sequential Prog Mode");
220 fprintf(stderr
, " - EPE: %s\n",
221 ((data
[1] & (1 << 5)) == 0) ?
222 "Erase/Prog success" :
224 fprintf(stderr
, "- SPM: %s\n",
225 ((data
[1] & (1 << 4)) == 0) ?
228 fprintf(stderr
, " - SWP: ");
229 switch((data
[1] >> 2) & 0x3) {
231 fprintf(stderr
, "All sectors unprotected\n");
234 fprintf(stderr
, "Some sectors protected\n");
237 fprintf(stderr
, "Reserved (xxxx 10xx)\n");
240 fprintf(stderr
, "All sectors protected\n");
243 fprintf(stderr
, " - WEL: %s\n",
244 ((data
[1] & (1 << 1)) == 0) ?
245 "Not write enabled" :
247 fprintf(stderr
, " - ~RDY: %s\n",
248 ((data
[1] & (1 << 0)) == 0) ?
256 static uint8_t read_status_2(){
257 uint8_t data
[2] = { FC_RSR2
};
262 fprintf(stderr
, "SR2: 0x%02X\n", data
[1]);
263 fprintf(stderr
, " - QE: %s\n",
264 ((data
[1] & (1 << 2)) == 0) ?
273 static uint8_t flash_read_status()
275 uint8_t ret
= read_status_1();
282 static void flash_write_enable()
285 fprintf(stderr
, "status before enable:\n");
290 fprintf(stderr
, "write enable..\n");
292 uint8_t data
[1] = { FC_WE
};
296 fprintf(stderr
, "status after enable:\n");
301 static void flash_bulk_erase()
303 fprintf(stderr
, "bulk erase..\n");
305 uint8_t data
[1] = { FC_CE
};
309 static void flash_4kB_sector_erase(int addr
)
311 fprintf(stderr
, "erase 4kB sector at 0x%06X..\n", addr
);
313 uint8_t command
[4] = { FC_SE
, (uint8_t)(addr
>> 16), (uint8_t)(addr
>> 8), (uint8_t)addr
};
315 xfer_spi(command
, 4);
318 static void flash_32kB_sector_erase(int addr
)
320 fprintf(stderr
, "erase 64kB sector at 0x%06X..\n", addr
);
322 uint8_t command
[4] = { FC_BE32
, (uint8_t)(addr
>> 16), (uint8_t)(addr
>> 8), (uint8_t)addr
};
324 xfer_spi(command
, 4);
327 static void flash_64kB_sector_erase(int addr
)
329 fprintf(stderr
, "erase 64kB sector at 0x%06X..\n", addr
);
331 uint8_t command
[4] = { FC_BE64
, (uint8_t)(addr
>> 16), (uint8_t)(addr
>> 8), (uint8_t)addr
};
333 xfer_spi(command
, 4);
336 static void flash_prog(int addr
, uint8_t *data
, int n
)
339 fprintf(stderr
, "prog 0x%06X +0x%03X..\n", addr
, n
);
341 uint8_t command
[4] = { FC_PP
, (uint8_t)(addr
>> 16), (uint8_t)(addr
>> 8), (uint8_t)addr
};
343 send_spi(command
, 4);
347 for (int i
= 0; i
< n
; i
++)
348 fprintf(stderr
, "%02x%c", data
[i
], i
== n
- 1 || i
% 32 == 31 ? '\n' : ' ');
352 static void flash_start_read(int addr
)
355 fprintf(stderr
, "Start Read 0x%06X\n", addr
);
357 uint8_t command
[4] = { FC_RD
, (uint8_t)(addr
>> 16), (uint8_t)(addr
>> 8), (uint8_t)addr
};
359 send_spi(command
, 4);
362 static void flash_continue_read(uint8_t *data
, int n
)
365 fprintf(stderr
, "Contiune Read +0x%03X..\n", n
);
371 for (int i
= 0; i
< n
; i
++)
372 fprintf(stderr
, "%02x%c", data
[i
], i
== n
- 1 || i
% 32 == 31 ? '\n' : ' ');
375 static void flash_wait()
378 fprintf(stderr
, "waiting..");
383 uint8_t data
[2] = { FC_RSR1
};
387 if ((data
[1] & 0x01) == 0) {
391 fprintf(stderr
, "r");
396 fprintf(stderr
, "R");
403 fprintf(stderr
, ".");
413 fprintf(stderr
, "\n");
417 static void flash_disable_protection()
419 fprintf(stderr
, "disable flash protection...\n");
421 // Write Status Register 1 <- 0x00
422 uint8_t data
[2] = { FC_WSR1
, 0x00 };
427 // Read Status Register 1
433 fprintf(stderr
, "failed to disable protection, SR now equal to 0x%02x (expected 0x00)\n", data
[1]);
437 // ---------------------------------------------------------
438 // ECP5 specific JTAG functions
439 // ---------------------------------------------------------
441 static void print_idcode(uint32_t idcode
){
442 connected_device
.id
= idcode
;
445 for(int i
= 0; i
< sizeof(ecp_devices
)/sizeof(struct device_id_pair
); i
++){
446 if(idcode
== ecp_devices
[i
].device_id
)
448 connected_device
.name
= ecp_devices
[i
].device_name
;
449 connected_device
.type
= TYPE_ECP5
;
450 printf("IDCODE: 0x%08x (%s)\n", idcode
,ecp_devices
[i
].device_name
);
456 for(int i
= 0; i
< sizeof(nx_devices
)/sizeof(struct device_id_pair
); i
++){
457 if(idcode
== nx_devices
[i
].device_id
)
459 connected_device
.name
= nx_devices
[i
].device_name
;
460 connected_device
.type
= TYPE_NX
;
461 printf("IDCODE: 0x%08x (%s)\n", idcode
,nx_devices
[i
].device_name
);
465 printf("IDCODE: 0x%08x does not match :(\n", idcode
);
468 static void read_idcode(){
470 uint8_t data
[4] = {READ_ID
};
472 jtag_go_to_state(STATE_SHIFT_IR
);
473 jtag_tap_shift(data
, data
, 8, true);
476 jtag_go_to_state(STATE_SHIFT_DR
);
477 jtag_tap_shift(data
, data
, 32, true);
481 /* Format the IDCODE into a 32bit value */
482 for(int i
= 0; i
< 4; i
++)
483 idcode
= data
[i
] << 24 | idcode
>> 8;
485 print_idcode(idcode
);
488 void print_ecp5_status_register(uint32_t status
){
489 printf("ECP5 Status Register: 0x%08x\n", status
);
492 printf(" Transparent Mode: %s\n", status
& (1 << 0) ? "Yes" : "No" );
493 printf(" Config Target: %s\n", status
& (7 << 1) ? "eFuse" : "SRAM" );
494 printf(" JTAG Active: %s\n", status
& (1 << 4) ? "Yes" : "No" );
495 printf(" PWD Protection: %s\n", status
& (1 << 5) ? "Yes" : "No" );
496 printf(" Decrypt Enable: %s\n", status
& (1 << 7) ? "Yes" : "No" );
497 printf(" DONE: %s\n", status
& (1 << 8) ? "Yes" : "No" );
498 printf(" ISC Enable: %s\n", status
& (1 << 9) ? "Yes" : "No" );
499 printf(" Write Enable: %s\n", status
& (1 << 10) ? "Writable" : "Not Writable");
500 printf(" Read Enable: %s\n", status
& (1 << 11) ? "Readable" : "Not Readable");
501 printf(" Busy Flag: %s\n", status
& (1 << 12) ? "Yes" : "No" );
502 printf(" Fail Flag: %s\n", status
& (1 << 13) ? "Yes" : "No" );
503 printf(" Feature OTP: %s\n", status
& (1 << 14) ? "Yes" : "No" );
504 printf(" Decrypt Only: %s\n", status
& (1 << 15) ? "Yes" : "No" );
505 printf(" PWD Enable: %s\n", status
& (1 << 16) ? "Yes" : "No" );
506 printf(" Encrypt Preamble: %s\n", status
& (1 << 20) ? "Yes" : "No" );
507 printf(" Std Preamble: %s\n", status
& (1 << 21) ? "Yes" : "No" );
508 printf(" SPIm Fail 1: %s\n", status
& (1 << 22) ? "Yes" : "No" );
510 uint8_t bse_error
= (status
& (7 << 23)) >> 23;
512 case 0b000: printf(" BSE Error Code: No Error (0b000)\n"); break;
513 case 0b001: printf(" BSE Error Code: ID Error (0b001)\n"); break;
514 case 0b010: printf(" BSE Error Code: CMD Error - illegal command (0b010)\n"); break;
515 case 0b011: printf(" BSE Error Code: CRC Error (0b011)\n"); break;
516 case 0b100: printf(" BSE Error Code: PRMB Error - preamble error (0b100)\n"); break;
517 case 0b101: printf(" BSE Error Code: ABRT Error - configuration aborted by the user (0b101)\n"); break;
518 case 0b110: printf(" BSE Error Code: OVFL Error - data overflow error (0b110)\n"); break;
519 case 0b111: printf(" BSE Error Code: SDM Error - bitstream pass the size of SRAM array (0b111)\n"); break;
522 printf(" Execution Error: %s\n", status
& (1 << 26) ? "Yes" : "No" );
523 printf(" ID Error: %s\n", status
& (1 << 27) ? "Yes" : "No" );
524 printf(" Invalid Command: %s\n", status
& (1 << 28) ? "Yes" : "No" );
525 printf(" SED Error: %s\n", status
& (1 << 29) ? "Yes" : "No" );
526 printf(" Bypass Mode: %s\n", status
& (1 << 30) ? "Yes" : "No" );
527 printf(" Flow Through Mode: %s\n", status
& (1 << 31) ? "Yes" : "No" );
531 void print_nx_status_register(uint32_t status
){
532 printf("NX Status Register: 0x%08x\n", status
);
536 void print_status_register(uint32_t status
){
537 if(connected_device
.type
== TYPE_ECP5
){
538 print_ecp5_status_register(status
);
539 }else if(connected_device
.type
== TYPE_NX
){
540 print_nx_status_register(status
);
546 static void read_status_register(){
548 uint8_t data
[4] = {LSC_READ_STATUS
};
550 jtag_go_to_state(STATE_SHIFT_IR
);
551 jtag_tap_shift(data
, data
, 8, true);
554 jtag_go_to_state(STATE_SHIFT_DR
);
555 jtag_tap_shift(data
, data
, 32, true);
556 //jtag_go_to_state(STATE_PAUSE_DR);
560 /* Format the IDCODE into a 32bit value */
561 for(int i
= 0; i
< 4; i
++)
562 status
= data
[i
] << 24 | status
>> 8;
564 print_status_register(status
);
569 static void enter_spi_background_mode(){
571 uint8_t data
[4] = {0x3A};
573 jtag_go_to_state(STATE_SHIFT_IR
);
574 jtag_tap_shift(data
, data
, 8, true);
576 /* These bytes seem to be required to un-lock the SPI interface */
579 jtag_go_to_state(STATE_SHIFT_DR
);
580 jtag_tap_shift(data
, data
, 16, true);
582 /* Entering IDLE is essential */
583 jtag_go_to_state(STATE_RUN_TEST_IDLE
);
587 void ecp_jtag_cmd(uint8_t cmd
){
588 uint8_t data
[1] = {cmd
};
590 jtag_go_to_state(STATE_SHIFT_IR
);
591 jtag_tap_shift(data
, data
, 8, true);
593 jtag_go_to_state(STATE_RUN_TEST_IDLE
);
597 void ecp_jtag_cmd8(uint8_t cmd
, uint8_t param
){
598 uint8_t data
[1] = {cmd
};
600 jtag_go_to_state(STATE_SHIFT_IR
);
601 jtag_tap_shift(data
, data
, 8, true);
604 jtag_go_to_state(STATE_SHIFT_DR
);
605 jtag_tap_shift(data
, data
, 8, true);
607 jtag_go_to_state(STATE_RUN_TEST_IDLE
);
611 // ---------------------------------------------------------
612 // iceprog implementation
613 // ---------------------------------------------------------
615 static void help(const char *progname
)
617 fprintf(stderr
, "Simple programming tool for Lattice ECP5/NX using FTDI-based JTAG programmers.\n");
618 fprintf(stderr
, "Usage: %s [-b|-n|-c] <input file>\n", progname
);
619 fprintf(stderr
, " %s -r|-R<bytes> <output file>\n", progname
);
620 fprintf(stderr
, " %s -S <input file>\n", progname
);
621 fprintf(stderr
, " %s -t\n", progname
);
622 fprintf(stderr
, "\n");
623 fprintf(stderr
, "General options:\n");
624 fprintf(stderr
, " -d <device string> use the specified USB device [default: i:0x0403:0x6010 or i:0x0403:0x6014]\n");
625 fprintf(stderr
, " d:<devicenode> (e.g. d:002/005)\n");
626 fprintf(stderr
, " i:<vendor>:<product> (e.g. i:0x0403:0x6010)\n");
627 fprintf(stderr
, " i:<vendor>:<product>:<index> (e.g. i:0x0403:0x6010:0)\n");
628 fprintf(stderr
, " s:<vendor>:<product>:<serial-string>\n");
629 fprintf(stderr
, " -I [ABCD] connect to the specified interface on the FTDI chip\n");
630 fprintf(stderr
, " [default: A]\n");
631 fprintf(stderr
, " -o <offset in bytes> start address for read/write [default: 0]\n");
632 fprintf(stderr
, " (append 'k' to the argument for size in kilobytes,\n");
633 fprintf(stderr
, " or 'M' for size in megabytes)\n");
634 fprintf(stderr
, " -k <divider> divider for SPI clock [default: 1]\n");
635 fprintf(stderr
, " clock speed is 6MHz/divider");
636 fprintf(stderr
, " -s slow SPI. (50 kHz instead of 6 MHz)\n");
637 fprintf(stderr
, " Equivalent to -k 30\n");
638 fprintf(stderr
, " -v verbose output\n");
639 fprintf(stderr
, " -i [4,32,64] select erase block size [default: 64k]\n");
640 fprintf(stderr
, "\n");
641 fprintf(stderr
, "Mode of operation:\n");
642 fprintf(stderr
, " [default] write file contents to flash, then verify\n");
643 fprintf(stderr
, " -X write file contents to flash only\n");
644 fprintf(stderr
, " -r read first 256 kB from flash and write to file\n");
645 fprintf(stderr
, " -R <size in bytes> read the specified number of bytes from flash\n");
646 fprintf(stderr
, " (append 'k' to the argument for size in kilobytes,\n");
647 fprintf(stderr
, " or 'M' for size in megabytes)\n");
648 fprintf(stderr
, " -c do not write flash, only verify (`check')\n");
649 fprintf(stderr
, " -S perform SRAM programming\n");
650 fprintf(stderr
, " -t just read the flash ID sequence\n");
651 fprintf(stderr
, "\n");
652 fprintf(stderr
, "Erase mode (only meaningful in default mode):\n");
653 fprintf(stderr
, " [default] erase aligned chunks of 64kB in write mode\n");
654 fprintf(stderr
, " This means that some data after the written data (or\n");
655 fprintf(stderr
, " even before when -o is used) may be erased as well.\n");
656 fprintf(stderr
, " -b bulk erase entire flash before writing\n");
657 fprintf(stderr
, " -e <size in bytes> erase flash as if we were writing that number of bytes\n");
658 fprintf(stderr
, " -n do not erase flash before writing\n");
659 fprintf(stderr
, " -p disable write protection before erasing or writing\n");
660 fprintf(stderr
, " This can be useful if flash memory appears to be\n");
661 fprintf(stderr
, " bricked and won't respond to erasing or programming.\n");
662 fprintf(stderr
, "\n");
663 fprintf(stderr
, "Miscellaneous options:\n");
664 fprintf(stderr
, " --help display this help and exit\n");
665 fprintf(stderr
, " -- treat all remaining arguments as filenames\n");
666 fprintf(stderr
, "\n");
667 fprintf(stderr
, "Exit status:\n");
668 fprintf(stderr
, " 0 on success,\n");
669 fprintf(stderr
, " 1 if a non-hardware error occurred (e.g., failure to read from or\n");
670 fprintf(stderr
, " write to a file, or invoked with invalid options),\n");
671 fprintf(stderr
, " 2 if communication with the hardware failed (e.g., cannot find the\n");
672 fprintf(stderr
, " iCE FTDI USB device),\n");
673 fprintf(stderr
, " 3 if verification of the data failed.\n");
674 fprintf(stderr
, "\n");
675 fprintf(stderr
, "If you have a bug report, please file an issue on github:\n");
676 fprintf(stderr
, " https://github.com/gregdavill/ecpprog/issues\n");
679 int main(int argc
, char **argv
)
681 /* used for error reporting */
682 const char *my_name
= argv
[0];
683 for (size_t i
= 0; argv
[0][i
]; i
++)
684 if (argv
[0][i
] == '/')
685 my_name
= argv
[0] + i
+ 1;
687 int read_size
= 256 * 1024;
688 int erase_block_size
= 64;
693 bool read_mode
= false;
694 bool check_mode
= false;
695 bool erase_mode
= false;
696 bool bulk_erase
= false;
697 bool dont_erase
= false;
698 bool prog_sram
= false;
699 bool test_mode
= false;
700 bool disable_protect
= false;
701 bool disable_verify
= false;
702 const char *filename
= NULL
;
703 const char *devstr
= NULL
;
707 _setmode(_fileno(stdin
), _O_BINARY
);
708 _setmode(_fileno(stdout
), _O_BINARY
);
711 static struct option long_options
[] = {
712 {"help", no_argument
, NULL
, -2},
716 /* Decode command line parameters */
719 while ((opt
= getopt_long(argc
, argv
, "d:i:I:rR:e:o:k:scbnStvpX", long_options
, NULL
)) != -1) {
721 case 'd': /* device string */
724 case 'i': /* block erase size */
725 if (!strcmp(optarg
, "4"))
726 erase_block_size
= 4;
727 else if (!strcmp(optarg
, "32"))
728 erase_block_size
= 32;
729 else if (!strcmp(optarg
, "64"))
730 erase_block_size
= 64;
732 fprintf(stderr
, "%s: `%s' is not a valid erase block size (must be `4', `32' or `64')\n", my_name
, optarg
);
736 case 'I': /* FTDI Chip interface select */
737 if (!strcmp(optarg
, "A"))
739 else if (!strcmp(optarg
, "B"))
741 else if (!strcmp(optarg
, "C"))
743 else if (!strcmp(optarg
, "D"))
746 fprintf(stderr
, "%s: `%s' is not a valid interface (must be `A', `B', `C', or `D')\n", my_name
, optarg
);
750 case 'r': /* Read 256 bytes to file */
753 case 'R': /* Read n bytes to file */
755 read_size
= strtol(optarg
, &endptr
, 0);
758 else if (!strcmp(endptr
, "k"))
760 else if (!strcmp(endptr
, "M"))
761 read_size
*= 1024 * 1024;
763 fprintf(stderr
, "%s: `%s' is not a valid size\n", my_name
, optarg
);
767 case 'e': /* Erase blocks as if we were writing n bytes */
769 erase_size
= strtol(optarg
, &endptr
, 0);
772 else if (!strcmp(endptr
, "k"))
774 else if (!strcmp(endptr
, "M"))
775 erase_size
*= 1024 * 1024;
777 fprintf(stderr
, "%s: `%s' is not a valid size\n", my_name
, optarg
);
781 case 'o': /* set address offset */
782 rw_offset
= strtol(optarg
, &endptr
, 0);
785 else if (!strcmp(endptr
, "k"))
787 else if (!strcmp(endptr
, "M"))
788 rw_offset
*= 1024 * 1024;
790 fprintf(stderr
, "%s: `%s' is not a valid offset\n", my_name
, optarg
);
794 case 'k': /* set clock div */
795 clkdiv
= strtol(optarg
, &endptr
, 0);
796 if (clkdiv
< 1 || clkdiv
> 65536) {
797 fprintf(stderr
, "%s: clock divider must be in range 1-65536 `%s' is not a valid divider\n", my_name
, optarg
);
801 case 's': /* use slow SPI clock */
804 case 'c': /* do not write just check */
807 case 'b': /* bulk erase before writing */
810 case 'n': /* do not erase before writing */
813 case 'S': /* write to sram directly */
816 case 't': /* just read flash id */
819 case 'v': /* provide verbose output */
822 case 'p': /* disable flash protect before erase/write */
823 disable_protect
= true;
825 case 'X': /* disable verification */
826 disable_verify
= true;
832 /* error message has already been printed */
833 fprintf(stderr
, "Try `%s --help' for more information.\n", argv
[0]);
838 /* Make sure that the combination of provided parameters makes sense */
840 if (read_mode
+ erase_mode
+ check_mode
+ prog_sram
+ test_mode
> 1) {
841 fprintf(stderr
, "%s: options `-r'/`-R', `-e`, `-c', `-S', and `-t' are mutually exclusive\n", my_name
);
845 if (bulk_erase
&& dont_erase
) {
846 fprintf(stderr
, "%s: options `-b' and `-n' are mutually exclusive\n", my_name
);
850 if (disable_protect
&& (read_mode
|| check_mode
|| prog_sram
|| test_mode
)) {
851 fprintf(stderr
, "%s: option `-p' only valid in programming mode\n", my_name
);
855 if (bulk_erase
&& (read_mode
|| check_mode
|| prog_sram
|| test_mode
)) {
856 fprintf(stderr
, "%s: option `-b' only valid in programming mode\n", my_name
);
860 if (dont_erase
&& (read_mode
|| check_mode
|| prog_sram
|| test_mode
)) {
861 fprintf(stderr
, "%s: option `-n' only valid in programming mode\n", my_name
);
865 if (rw_offset
!= 0 && prog_sram
) {
866 fprintf(stderr
, "%s: option `-o' not supported in SRAM mode\n", my_name
);
870 if (rw_offset
!= 0 && test_mode
) {
871 fprintf(stderr
, "%s: option `-o' not supported in test mode\n", my_name
);
875 if (optind
+ 1 == argc
) {
877 fprintf(stderr
, "%s: test mode doesn't take a file name\n", my_name
);
878 fprintf(stderr
, "Try `%s --help' for more information.\n", argv
[0]);
881 filename
= argv
[optind
];
882 } else if (optind
!= argc
) {
883 fprintf(stderr
, "%s: too many arguments\n", my_name
);
884 fprintf(stderr
, "Try `%s --help' for more information.\n", argv
[0]);
886 } else if (bulk_erase
|| disable_protect
) {
887 filename
= "/dev/null";
888 } else if (!test_mode
&& !erase_mode
&& !disable_protect
) {
889 fprintf(stderr
, "%s: missing argument\n", my_name
);
890 fprintf(stderr
, "Try `%s --help' for more information.\n", argv
[0]);
894 /* open input/output file in advance
895 so we can fail before initializing the hardware */
902 } else if (erase_mode
) {
903 file_size
= erase_size
;
904 } else if (read_mode
) {
905 f
= (strcmp(filename
, "-") == 0) ? stdout
: fopen(filename
, "wb");
907 fprintf(stderr
, "%s: can't open '%s' for writing: ", my_name
, filename
);
911 file_size
= read_size
;
913 f
= (strcmp(filename
, "-") == 0) ? stdin
: fopen(filename
, "rb");
915 fprintf(stderr
, "%s: can't open '%s' for reading: ", my_name
, filename
);
920 /* For regular programming, we need to read the file
921 twice--once for programming and once for verifying--and
922 need to know the file size in advance in order to erase
923 the correct amount of memory.
925 See if we can seek on the input file. Checking for "-"
926 as an argument isn't enough as we might be reading from a
927 named pipe, or contrarily, the standard input may be an
931 if (fseek(f
, 0L, SEEK_END
) != -1) {
932 file_size
= ftell(f
);
933 if (file_size
== -1) {
934 fprintf(stderr
, "%s: %s: ftell: ", my_name
, filename
);
938 if (fseek(f
, 0L, SEEK_SET
) == -1) {
939 fprintf(stderr
, "%s: %s: fseek: ", my_name
, filename
);
948 fprintf(stderr
, "%s: can't open temporary file\n", my_name
);
954 static unsigned char buffer
[4096];
955 size_t rc
= fread(buffer
, 1, 4096, pipe
);
958 size_t wc
= fwrite(buffer
, 1, rc
, f
);
960 fprintf(stderr
, "%s: can't write to temporary file\n", my_name
);
967 /* now seek to the beginning so we can
968 start reading again */
969 fseek(f
, 0, SEEK_SET
);
974 // ---------------------------------------------------------
975 // Initialize USB connection to FT2232H
976 // ---------------------------------------------------------
978 fprintf(stderr
, "init..\n");
979 jtag_init(ifnum
, devstr
, clkdiv
);
982 read_status_register();
986 /* Reset ECP5 to release SPI interface */
987 ecp_jtag_cmd(ISC_ENABLE
);
988 ecp_jtag_cmd(ISC_ERASE
);
989 ecp_jtag_cmd(ISC_DISABLE
);
991 /* Put device into SPI bypass mode */
992 enter_spi_background_mode();
1001 // ---------------------------------------------------------
1003 // ---------------------------------------------------------
1004 fprintf(stderr
, "reset..\n");
1006 ecp_jtag_cmd8(ISC_ENABLE
, 0);
1007 ecp_jtag_cmd8(ISC_ERASE
, 0);
1008 ecp_jtag_cmd8(LSC_RESET_CRC
, 0);
1010 read_status_register();
1012 // ---------------------------------------------------------
1014 // ---------------------------------------------------------
1016 fprintf(stderr
, "programming..\n");
1017 ecp_jtag_cmd(LSC_BITSTREAM_BURST
);
1019 const uint32_t len
= 16*1024;
1020 static unsigned char buffer
[16*1024];
1021 int rc
= fread(buffer
, 1, len
, f
);
1025 fprintf(stderr
, "sending %d bytes.\n", rc
);
1027 for(int i
= 0; i
< len
; i
++){
1028 buffer
[i
] = bit_reverse(buffer
[i
]);
1031 jtag_go_to_state(STATE_CAPTURE_DR
);
1032 jtag_tap_shift(buffer
, buffer
, len
*8, false);
1035 ecp_jtag_cmd(ISC_DISABLE
);
1036 read_status_register();
1038 else /* program flash */
1040 // ---------------------------------------------------------
1042 // ---------------------------------------------------------
1044 fprintf(stderr
, "reset..\n");
1045 /* Reset ECP5 to release SPI interface */
1046 ecp_jtag_cmd8(ISC_ENABLE
, 0);
1047 ecp_jtag_cmd8(ISC_ERASE
, 0);
1048 ecp_jtag_cmd8(ISC_DISABLE
, 0);
1050 /* Put device into SPI bypass mode */
1051 enter_spi_background_mode();
1058 // ---------------------------------------------------------
1060 // ---------------------------------------------------------
1062 if (!read_mode
&& !check_mode
)
1064 if (disable_protect
)
1066 flash_write_enable();
1067 flash_disable_protection();
1074 flash_write_enable();
1080 fprintf(stderr
, "file size: %ld\n", file_size
);
1082 int block_size
= erase_block_size
<< 10;
1083 int block_mask
= block_size
- 1;
1084 int begin_addr
= rw_offset
& ~block_mask
;
1085 int end_addr
= (rw_offset
+ file_size
+ block_mask
) & ~block_mask
;
1087 for (int addr
= begin_addr
; addr
< end_addr
; addr
+= block_size
) {
1088 flash_write_enable();
1089 switch(erase_block_size
) {
1091 flash_4kB_sector_erase(addr
);
1094 flash_32kB_sector_erase(addr
);
1097 flash_64kB_sector_erase(addr
);
1101 fprintf(stderr
, "Status after block erase:\n");
1102 flash_read_status();
1111 for (int rc
, addr
= 0; true; addr
+= rc
) {
1112 uint8_t buffer
[256];
1115 fprintf(stderr
, "\r\033[0Kprogramming.. %04u/%04lu", addr
, file_size
);
1117 int page_size
= 256 - (rw_offset
+ addr
) % 256;
1118 rc
= fread(buffer
, 1, page_size
, f
);
1121 flash_write_enable();
1122 flash_prog(rw_offset
+ addr
, buffer
, rc
);
1127 fprintf(stderr
, "\n");
1128 /* seek to the beginning for second pass */
1129 fseek(f
, 0, SEEK_SET
);
1133 // ---------------------------------------------------------
1135 // ---------------------------------------------------------
1139 flash_start_read(rw_offset
);
1140 for (int addr
= 0; addr
< read_size
; addr
+= 4096) {
1141 uint8_t buffer
[4096];
1144 fprintf(stderr
, "\r\033[0Kreading.. %04u/%04u", addr
+ 4096, read_size
);
1146 flash_continue_read(buffer
, 4096);
1147 fwrite(buffer
, read_size
- addr
> 4096 ? 4096 : read_size
- addr
, 1, f
);
1149 fprintf(stderr
, "\n");
1150 } else if (!erase_mode
&& !disable_verify
) {
1152 flash_start_read(rw_offset
);
1153 for (int addr
= 0; addr
< file_size
; addr
+= 4096) {
1154 uint8_t buffer_flash
[4096], buffer_file
[4096];
1156 int rc
= fread(buffer_file
, 1, 4096, f
);
1160 flash_continue_read(buffer_flash
, rc
);
1163 fprintf(stderr
, "\r\033[0Kverify.. %04u/%04lu", addr
+ rc
, file_size
);
1164 if (memcmp(buffer_file
, buffer_flash
, rc
)) {
1165 fprintf(stderr
, "Found difference between flash and file!\n");
1170 fprintf(stderr
, " VERIFY OK\n");
1174 if (f
!= NULL
&& f
!= stdin
&& f
!= stdout
)
1177 // ---------------------------------------------------------
1179 // ---------------------------------------------------------
1181 fprintf(stderr
, "Bye.\n");