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 */
47 #include "lattice_cmds.h"
49 static bool verbose
= false;
51 // ---------------------------------------------------------
53 // ---------------------------------------------------------
55 /* Flash command definitions */
56 /* This command list is based on the Winbond W25Q128JV Datasheet */
58 FC_WE
= 0x06, /* Write Enable */
59 FC_SRWE
= 0x50, /* Volatile SR Write Enable */
60 FC_WD
= 0x04, /* Write Disable */
61 FC_RPD
= 0xAB, /* Release Power-Down, returns Device ID */
62 FC_MFGID
= 0x90, /* Read Manufacturer/Device ID */
63 FC_JEDECID
= 0x9F, /* Read JEDEC ID */
64 FC_UID
= 0x4B, /* Read Unique ID */
65 FC_RD
= 0x03, /* Read Data */
66 FC_FR
= 0x0B, /* Fast Read */
67 FC_PP
= 0x02, /* Page Program */
68 FC_SE
= 0x20, /* Sector Erase 4kb */
69 FC_BE32
= 0x52, /* Block Erase 32kb */
70 FC_BE64
= 0xD8, /* Block Erase 64kb */
71 FC_CE
= 0xC7, /* Chip Erase */
72 FC_RSR1
= 0x05, /* Read Status Register 1 */
73 FC_WSR1
= 0x01, /* Write Status Register 1 */
74 FC_RSR2
= 0x35, /* Read Status Register 2 */
75 FC_WSR2
= 0x31, /* Write Status Register 2 */
76 FC_RSR3
= 0x15, /* Read Status Register 3 */
77 FC_WSR3
= 0x11, /* Write Status Register 3 */
78 FC_RSFDP
= 0x5A, /* Read SFDP Register */
79 FC_ESR
= 0x44, /* Erase Security Register */
80 FC_PSR
= 0x42, /* Program Security Register */
81 FC_RSR
= 0x48, /* Read Security Register */
82 FC_GBL
= 0x7E, /* Global Block Lock */
83 FC_GBU
= 0x98, /* Global Block Unlock */
84 FC_RBL
= 0x3D, /* Read Block Lock */
85 FC_RPR
= 0x3C, /* Read Sector Protection Registers (adesto) */
86 FC_IBL
= 0x36, /* Individual Block Lock */
87 FC_IBU
= 0x39, /* Individual Block Unlock */
88 FC_EPS
= 0x75, /* Erase / Program Suspend */
89 FC_EPR
= 0x7A, /* Erase / Program Resume */
90 FC_PD
= 0xB9, /* Power-down */
91 FC_QPI
= 0x38, /* Enter QPI mode */
92 FC_ERESET
= 0x66, /* Enable Reset */
93 FC_RESET
= 0x99, /* Reset Device */
96 // ---------------------------------------------------------
97 // FLASH function implementations
98 // ---------------------------------------------------------
100 static void flash_read_id()
102 /* JEDEC ID structure:
103 * Byte No. | Data Type
104 * ---------+----------
105 * 0 | FC_JEDECID Request Command
109 * 4 | Ext Dev Str Len
112 uint8_t data
[260] = { FC_JEDECID
};
113 int len
= 5; // command + 4 response bytes
116 fprintf(stderr
, "read flash ID..\n");
118 //flash_chip_select();
120 // Write command and read first 4 bytes
121 ////mpsse_xfer_spi(data, len);
123 //jtag_go_to_state(STATE_SHIFT_DR);
124 //jtag_tap_shift(data, data, 8*5, false);
127 fprintf(stderr
, "Extended Device String Length is 0xFF, "
128 "this is likely a read error. Ignorig...\n");
130 // Read extended JEDEC ID bytes
133 data
[0] = FC_JEDECID
;
138 fprintf(stderr
, "flash ID:");
139 for (int i
= 1; i
< len
; i
++)
140 fprintf(stderr
, " 0x%02X", data
[i
]);
141 fprintf(stderr
, "\n");
145 static void flash_reset()
147 uint8_t data
[8] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
151 static void flash_power_up()
153 uint8_t data_rpd
[1] = { FC_RPD
};
154 xfer_spi(data_rpd
, 1);
157 static void flash_power_down()
159 uint8_t data
[1] = { FC_PD
};
160 jtag_go_to_state(STATE_SHIFT_DR
);
161 jtag_tap_shift(data
, data
, 8, true);
164 static uint8_t flash_read_status()
166 uint8_t data
[2] = { FC_RSR1
};
171 fprintf(stderr
, "SR1: 0x%02X\n", data
[1]);
172 fprintf(stderr
, " - SPRL: %s\n",
173 ((data
[1] & (1 << 7)) == 0) ?
176 fprintf(stderr
, " - SPM: %s\n",
177 ((data
[1] & (1 << 6)) == 0) ?
178 "Byte/Page Prog Mode" :
179 "Sequential Prog Mode");
180 fprintf(stderr
, " - EPE: %s\n",
181 ((data
[1] & (1 << 5)) == 0) ?
182 "Erase/Prog success" :
184 fprintf(stderr
, "- SPM: %s\n",
185 ((data
[1] & (1 << 4)) == 0) ?
188 fprintf(stderr
, " - SWP: ");
189 switch((data
[1] >> 2) & 0x3) {
191 fprintf(stderr
, "All sectors unprotected\n");
194 fprintf(stderr
, "Some sectors protected\n");
197 fprintf(stderr
, "Reserved (xxxx 10xx)\n");
200 fprintf(stderr
, "All sectors protected\n");
203 fprintf(stderr
, " - WEL: %s\n",
204 ((data
[1] & (1 << 1)) == 0) ?
205 "Not write enabled" :
207 fprintf(stderr
, " - ~RDY: %s\n",
208 ((data
[1] & (1 << 0)) == 0) ?
218 static void flash_write_enable()
221 fprintf(stderr
, "status before enable:\n");
226 fprintf(stderr
, "write enable..\n");
228 uint8_t data
[1] = { FC_WE
};
229 //flash_chip_select();
230 //mpsse_xfer_spi(data, 1);
231 //flash_chip_deselect();
234 fprintf(stderr
, "status after enable:\n");
239 static void flash_bulk_erase()
241 fprintf(stderr
, "bulk erase..\n");
243 uint8_t data
[1] = { FC_CE
};
244 //flash_chip_select();
245 //mpsse_xfer_spi(data, 1);
246 //flash_chip_deselect();
249 static void flash_4kB_sector_erase(int addr
)
251 fprintf(stderr
, "erase 4kB sector at 0x%06X..\n", addr
);
253 uint8_t command
[4] = { FC_SE
, (uint8_t)(addr
>> 16), (uint8_t)(addr
>> 8), (uint8_t)addr
};
255 //flash_chip_select();
256 //mpsse_send_spi(command, 4);
257 //flash_chip_deselect();
260 static void flash_32kB_sector_erase(int addr
)
262 fprintf(stderr
, "erase 64kB sector at 0x%06X..\n", addr
);
264 uint8_t command
[4] = { FC_BE32
, (uint8_t)(addr
>> 16), (uint8_t)(addr
>> 8), (uint8_t)addr
};
266 //flash_chip_select();
267 //mpsse_send_spi(command, 4);
268 //flash_chip_deselect();
271 static void flash_64kB_sector_erase(int addr
)
273 fprintf(stderr
, "erase 64kB sector at 0x%06X..\n", addr
);
275 uint8_t command
[4] = { FC_BE64
, (uint8_t)(addr
>> 16), (uint8_t)(addr
>> 8), (uint8_t)addr
};
277 //flash_chip_select();
278 //mpsse_send_spi(command, 4);
279 //flash_chip_deselect();
282 static void flash_prog(int addr
, uint8_t *data
, int n
)
285 fprintf(stderr
, "prog 0x%06X +0x%03X..\n", addr
, n
);
287 uint8_t command
[4] = { FC_PP
, (uint8_t)(addr
>> 16), (uint8_t)(addr
>> 8), (uint8_t)addr
};
289 //flash_chip_select();
290 //mpsse_send_spi(command, 4);
291 //mpsse_send_spi(data, n);
292 //flash_chip_deselect();
295 for (int i
= 0; i
< n
; i
++)
296 fprintf(stderr
, "%02x%c", data
[i
], i
== n
- 1 || i
% 32 == 31 ? '\n' : ' ');
299 static void flash_read(int addr
, uint8_t *data
, int n
)
302 fprintf(stderr
, "read 0x%06X +0x%03X..\n", addr
, n
);
304 uint8_t command
[4] = { FC_RD
, (uint8_t)(addr
>> 16), (uint8_t)(addr
>> 8), (uint8_t)addr
};
306 //flash_chip_select();
307 //mpsse_send_spi(command, 4);
309 //mpsse_xfer_spi(data, n);
310 //flash_chip_deselect();
313 for (int i
= 0; i
< n
; i
++)
314 fprintf(stderr
, "%02x%c", data
[i
], i
== n
- 1 || i
% 32 == 31 ? '\n' : ' ');
317 static void flash_wait()
320 fprintf(stderr
, "waiting..");
325 uint8_t data
[2] = { FC_RSR1
};
327 //flash_chip_select();
328 //mpsse_xfer_spi(data, 2);
329 //flash_chip_deselect();
331 if ((data
[1] & 0x01) == 0) {
335 fprintf(stderr
, "r");
340 fprintf(stderr
, "R");
347 fprintf(stderr
, ".");
357 fprintf(stderr
, "\n");
361 static void flash_disable_protection()
363 fprintf(stderr
, "disable flash protection...\n");
365 // Write Status Register 1 <- 0x00
366 uint8_t data
[2] = { FC_WSR1
, 0x00 };
367 //flash_chip_select();
368 //mpsse_xfer_spi(data, 2);
369 //flash_chip_deselect();
373 // Read Status Register 1
376 //flash_chip_select();
377 //mpsse_xfer_spi(data, 2);
378 //flash_chip_deselect();
381 fprintf(stderr
, "failed to disable protection, SR now equal to 0x%02x (expected 0x00)\n", data
[1]);
385 // ---------------------------------------------------------
386 // JTAG -> SPI functions
387 // ---------------------------------------------------------
390 * JTAG performrs all shifts LSB first, our FLSAH is expeting bytes MSB first,
391 * There are a few ways to fix this, for now we just bit-reverse all the input data to the JTAG core
393 uint8_t bit_reverse(uint8_t in
){
395 uint8_t out
= (in
& 0x01) ? 0x80 : 0x00;
396 out
|= (in
& 0x02) ? 0x40 : 0x00;
397 out
|= (in
& 0x04) ? 0x20 : 0x00;
398 out
|= (in
& 0x08) ? 0x10 : 0x00;
399 out
|= (in
& 0x10) ? 0x08 : 0x00;
400 out
|= (in
& 0x20) ? 0x04 : 0x00;
401 out
|= (in
& 0x40) ? 0x02 : 0x00;
402 out
|= (in
& 0x80) ? 0x01 : 0x00;
407 void xfer_spi(uint8_t* data
, uint32_t len
){
408 /* Flip bit order of all bytes */
409 for(int i
= 0; i
< len
; i
++){
410 data
[i
] = bit_reverse(data
[i
]);
413 jtag_go_to_state(STATE_SHIFT_DR
);
414 jtag_tap_shift(data
, data
, len
* 8, true);
416 /* Flip bit order of all bytes */
417 for(int i
= 0; i
< len
; i
++){
418 data
[i
] = bit_reverse(data
[i
]);
422 // ---------------------------------------------------------
423 // ECP5 specific JTAG functions
424 // ---------------------------------------------------------
427 static void print_idcode(uint32_t idcode
){
428 for(int i
= 0; i
< sizeof(ecp_devices
)/sizeof(struct ecp_device_id
); i
++){
429 if(idcode
== ecp_devices
[i
].device_id
)
431 printf("IDCODE: 0x%08x (%s)\n", idcode
,ecp_devices
[i
].device_name
);
435 printf("IDCODE: 0x%08x does not match :(\n", idcode
);
438 static void read_idcode(){
440 uint8_t data
[4] = {READ_ID
};
442 jtag_go_to_state(STATE_SHIFT_IR
);
443 jtag_tap_shift(data
, data
, 8, true);
446 jtag_go_to_state(STATE_SHIFT_DR
);
447 jtag_tap_shift(data
, data
, 32, true);
451 /* Format the IDCODE into a 32bit value */
452 for(int i
= 0; i
< 4; i
++)
453 idcode
= data
[i
] << 24 | idcode
>> 8;
455 print_idcode(idcode
);
459 static void print_status_register(uint32_t status
){
460 printf("ECP5 Status Register: 0x%08x\n", status
);
463 printf(" Transparent Mode: %s\n", status
& (1 << 0) ? "Yes" : "No" );
464 printf(" Config Target: %s\n", status
& (7 << 1) ? "eFuse" : "SRAM" );
465 printf(" JTAG Active: %s\n", status
& (1 << 4) ? "Yes" : "No" );
466 printf(" PWD Protection: %s\n", status
& (1 << 5) ? "Yes" : "No" );
467 printf(" Decrypt Enable: %s\n", status
& (1 << 7) ? "Yes" : "No" );
468 printf(" DONE: %s\n", status
& (1 << 8) ? "Yes" : "No" );
469 printf(" ISC Enable: %s\n", status
& (1 << 9) ? "Yes" : "No" );
470 printf(" Write Enable: %s\n", status
& (1 << 10) ? "Writable" : "Not Writable");
471 printf(" Read Enable: %s\n", status
& (1 << 11) ? "Readable" : "Not Readable");
472 printf(" Busy Flag: %s\n", status
& (1 << 12) ? "Yes" : "No" );
473 printf(" Fail Flag: %s\n", status
& (1 << 13) ? "Yes" : "No" );
474 printf(" Feature OTP: %s\n", status
& (1 << 14) ? "Yes" : "No" );
475 printf(" Decrypt Only: %s\n", status
& (1 << 15) ? "Yes" : "No" );
476 printf(" PWD Enable: %s\n", status
& (1 << 16) ? "Yes" : "No" );
477 printf(" Encrypt Preamble: %s\n", status
& (1 << 20) ? "Yes" : "No" );
478 printf(" Std Preamble: %s\n", status
& (1 << 21) ? "Yes" : "No" );
479 printf(" SPIm Fail 1: %s\n", status
& (1 << 22) ? "Yes" : "No" );
481 uint8_t bse_error
= (status
& (7 << 23)) >> 23;
483 case 0b000: printf(" BSE Error Code: No Error (0b000)\n"); break;
484 case 0b001: printf(" BSE Error Code: ID Error (0b001)\n"); break;
485 case 0b010: printf(" BSE Error Code: CMD Error - illegal command (0b010)\n"); break;
486 case 0b011: printf(" BSE Error Code: CRC Error (0b011)\n"); break;
487 case 0b100: printf(" BSE Error Code: PRMB Error - preamble error (0b100)\n"); break;
488 case 0b101: printf(" BSE Error Code: ABRT Error - configuration aborted by the user (0b101)\n"); break;
489 case 0b110: printf(" BSE Error Code: OVFL Error - data overflow error (0b110)\n"); break;
490 case 0b111: printf(" BSE Error Code: SDM Error - bitstream pass the size of SRAM array (0b111)\n"); break;
493 printf(" Execution Error: %s\n", status
& (1 << 26) ? "Yes" : "No" );
494 printf(" ID Error: %s\n", status
& (1 << 27) ? "Yes" : "No" );
495 printf(" Invalid Command: %s\n", status
& (1 << 28) ? "Yes" : "No" );
496 printf(" SED Error: %s\n", status
& (1 << 29) ? "Yes" : "No" );
497 printf(" Bypass Mode: %s\n", status
& (1 << 30) ? "Yes" : "No" );
498 printf(" Flow Through Mode: %s\n", status
& (1 << 31) ? "Yes" : "No" );
503 static void read_status_register(){
505 uint8_t data
[4] = {LSC_READ_STATUS
};
507 jtag_go_to_state(STATE_SHIFT_IR
);
508 jtag_tap_shift(data
, data
, 8, true);
511 jtag_go_to_state(STATE_SHIFT_DR
);
512 jtag_tap_shift(data
, data
, 32, true);
516 /* Format the IDCODE into a 32bit value */
517 for(int i
= 0; i
< 4; i
++)
518 status
= data
[i
] << 24 | status
>> 8;
520 print_status_register(status
);
525 static void enter_spi_background_mode(){
527 uint8_t data_in
[4] = {0,0,0,0};
528 uint8_t data_out
[4] = {0,0,0,0};
531 jtag_go_to_state(STATE_SHIFT_IR
);
532 jtag_tap_shift(data_in
, data_out
, 8, true);
534 /* These bytes seem to be required to un-lock the SPI interface */
537 jtag_go_to_state(STATE_SHIFT_DR
);
538 jtag_tap_shift(data_in
, data_out
, 16, true);
540 /* Entering IDLE is essential */
541 jtag_go_to_state(STATE_RUN_TEST_IDLE
);
545 void ecp_jtag_cmd(uint8_t cmd
){
546 uint8_t data
[1] = {cmd
};
548 jtag_go_to_state(STATE_SHIFT_IR
);
549 jtag_tap_shift(data
, data
, 8, true);
551 jtag_go_to_state(STATE_RUN_TEST_IDLE
);
555 // ---------------------------------------------------------
556 // iceprog implementation
557 // ---------------------------------------------------------
559 static void help(const char *progname
)
561 fprintf(stderr
, "Simple programming tool for FTDI-based Lattice ECP JTAG programmers.\n");
562 fprintf(stderr
, "Usage: %s [-b|-n|-c] <input file>\n", progname
);
563 fprintf(stderr
, " %s -r|-R<bytes> <output file>\n", progname
);
564 fprintf(stderr
, " %s -S <input file>\n", progname
);
565 fprintf(stderr
, " %s -t\n", progname
);
566 fprintf(stderr
, "\n");
567 fprintf(stderr
, "General options:\n");
568 fprintf(stderr
, " -d <device string> use the specified USB device [default: i:0x0403:0x6010 or i:0x0403:0x6014]\n");
569 fprintf(stderr
, " d:<devicenode> (e.g. d:002/005)\n");
570 fprintf(stderr
, " i:<vendor>:<product> (e.g. i:0x0403:0x6010)\n");
571 fprintf(stderr
, " i:<vendor>:<product>:<index> (e.g. i:0x0403:0x6010:0)\n");
572 fprintf(stderr
, " s:<vendor>:<product>:<serial-string>\n");
573 fprintf(stderr
, " -I [ABCD] connect to the specified interface on the FTDI chip\n");
574 fprintf(stderr
, " [default: A]\n");
575 fprintf(stderr
, " -o <offset in bytes> start address for read/write [default: 0]\n");
576 fprintf(stderr
, " (append 'k' to the argument for size in kilobytes,\n");
577 fprintf(stderr
, " or 'M' for size in megabytes)\n");
578 fprintf(stderr
, " -s slow SPI (50 kHz instead of 6 MHz)\n");
579 fprintf(stderr
, " -v verbose output\n");
580 fprintf(stderr
, " -i [4,32,64] select erase block size [default: 64k]\n");
581 fprintf(stderr
, "\n");
582 fprintf(stderr
, "Mode of operation:\n");
583 fprintf(stderr
, " [default] write file contents to flash, then verify\n");
584 fprintf(stderr
, " -X write file contents to flash only\n");
585 fprintf(stderr
, " -r read first 256 kB from flash and write to file\n");
586 fprintf(stderr
, " -R <size in bytes> read the specified number of bytes from flash\n");
587 fprintf(stderr
, " (append 'k' to the argument for size in kilobytes,\n");
588 fprintf(stderr
, " or 'M' for size in megabytes)\n");
589 fprintf(stderr
, " -c do not write flash, only verify (`check')\n");
590 fprintf(stderr
, " -S perform SRAM programming\n");
591 fprintf(stderr
, " -t just read the flash ID sequence\n");
592 fprintf(stderr
, "\n");
593 fprintf(stderr
, "Erase mode (only meaningful in default mode):\n");
594 fprintf(stderr
, " [default] erase aligned chunks of 64kB in write mode\n");
595 fprintf(stderr
, " This means that some data after the written data (or\n");
596 fprintf(stderr
, " even before when -o is used) may be erased as well.\n");
597 fprintf(stderr
, " -b bulk erase entire flash before writing\n");
598 fprintf(stderr
, " -e <size in bytes> erase flash as if we were writing that number of bytes\n");
599 fprintf(stderr
, " -n do not erase flash before writing\n");
600 fprintf(stderr
, " -p disable write protection before erasing or writing\n");
601 fprintf(stderr
, " This can be useful if flash memory appears to be\n");
602 fprintf(stderr
, " bricked and won't respond to erasing or programming.\n");
603 fprintf(stderr
, "\n");
604 fprintf(stderr
, "Miscellaneous options:\n");
605 fprintf(stderr
, " --help display this help and exit\n");
606 fprintf(stderr
, " -- treat all remaining arguments as filenames\n");
607 fprintf(stderr
, "\n");
608 fprintf(stderr
, "Exit status:\n");
609 fprintf(stderr
, " 0 on success,\n");
610 fprintf(stderr
, " 1 if a non-hardware error occurred (e.g., failure to read from or\n");
611 fprintf(stderr
, " write to a file, or invoked with invalid options),\n");
612 fprintf(stderr
, " 2 if communication with the hardware failed (e.g., cannot find the\n");
613 fprintf(stderr
, " iCE FTDI USB device),\n");
614 fprintf(stderr
, " 3 if verification of the data failed.\n");
615 fprintf(stderr
, "\n");
616 fprintf(stderr
, "If you have a bug report, please file an issue on github:\n");
617 fprintf(stderr
, " https://github.com/gregdavill/ecpprog/issues\n");
620 int main(int argc
, char **argv
)
622 /* used for error reporting */
623 const char *my_name
= argv
[0];
624 for (size_t i
= 0; argv
[0][i
]; i
++)
625 if (argv
[0][i
] == '/')
626 my_name
= argv
[0] + i
+ 1;
628 int read_size
= 256 * 1024;
629 int erase_block_size
= 64;
633 bool read_mode
= false;
634 bool check_mode
= false;
635 bool erase_mode
= false;
636 bool bulk_erase
= false;
637 bool dont_erase
= false;
638 bool prog_sram
= false;
639 bool test_mode
= false;
640 bool slow_clock
= false;
641 bool disable_protect
= false;
642 bool disable_verify
= false;
643 const char *filename
= NULL
;
644 const char *devstr
= NULL
;
648 _setmode(_fileno(stdin
), _O_BINARY
);
649 _setmode(_fileno(stdout
), _O_BINARY
);
652 static struct option long_options
[] = {
653 {"help", no_argument
, NULL
, -2},
657 /* Decode command line parameters */
660 while ((opt
= getopt_long(argc
, argv
, "d:i:I:rR:e:o:cbnStvspX", long_options
, NULL
)) != -1) {
662 case 'd': /* device string */
665 case 'i': /* block erase size */
666 if (!strcmp(optarg
, "4"))
667 erase_block_size
= 4;
668 else if (!strcmp(optarg
, "32"))
669 erase_block_size
= 32;
670 else if (!strcmp(optarg
, "64"))
671 erase_block_size
= 64;
673 fprintf(stderr
, "%s: `%s' is not a valid erase block size (must be `4', `32' or `64')\n", my_name
, optarg
);
677 case 'I': /* FTDI Chip interface select */
678 if (!strcmp(optarg
, "A"))
680 else if (!strcmp(optarg
, "B"))
682 else if (!strcmp(optarg
, "C"))
684 else if (!strcmp(optarg
, "D"))
687 fprintf(stderr
, "%s: `%s' is not a valid interface (must be `A', `B', `C', or `D')\n", my_name
, optarg
);
691 case 'r': /* Read 256 bytes to file */
694 case 'R': /* Read n bytes to file */
696 read_size
= strtol(optarg
, &endptr
, 0);
699 else if (!strcmp(endptr
, "k"))
701 else if (!strcmp(endptr
, "M"))
702 read_size
*= 1024 * 1024;
704 fprintf(stderr
, "%s: `%s' is not a valid size\n", my_name
, optarg
);
708 case 'e': /* Erase blocks as if we were writing n bytes */
710 erase_size
= strtol(optarg
, &endptr
, 0);
713 else if (!strcmp(endptr
, "k"))
715 else if (!strcmp(endptr
, "M"))
716 erase_size
*= 1024 * 1024;
718 fprintf(stderr
, "%s: `%s' is not a valid size\n", my_name
, optarg
);
722 case 'o': /* set address offset */
723 rw_offset
= strtol(optarg
, &endptr
, 0);
726 else if (!strcmp(endptr
, "k"))
728 else if (!strcmp(endptr
, "M"))
729 rw_offset
*= 1024 * 1024;
731 fprintf(stderr
, "%s: `%s' is not a valid offset\n", my_name
, optarg
);
735 case 'c': /* do not write just check */
738 case 'b': /* bulk erase before writing */
741 case 'n': /* do not erase before writing */
744 case 'S': /* write to sram directly */
747 case 't': /* just read flash id */
750 case 'v': /* provide verbose output */
753 case 's': /* use slow SPI clock */
756 case 'p': /* disable flash protect before erase/write */
757 disable_protect
= true;
759 case 'X': /* disable verification */
760 disable_verify
= true;
766 /* error message has already been printed */
767 fprintf(stderr
, "Try `%s --help' for more information.\n", argv
[0]);
772 /* Make sure that the combination of provided parameters makes sense */
774 if (read_mode
+ erase_mode
+ check_mode
+ prog_sram
+ test_mode
> 1) {
775 fprintf(stderr
, "%s: options `-r'/`-R', `-e`, `-c', `-S', and `-t' are mutually exclusive\n", my_name
);
779 if (bulk_erase
&& dont_erase
) {
780 fprintf(stderr
, "%s: options `-b' and `-n' are mutually exclusive\n", my_name
);
784 if (disable_protect
&& (read_mode
|| check_mode
|| prog_sram
|| test_mode
)) {
785 fprintf(stderr
, "%s: option `-p' only valid in programming mode\n", my_name
);
789 if (bulk_erase
&& (read_mode
|| check_mode
|| prog_sram
|| test_mode
)) {
790 fprintf(stderr
, "%s: option `-b' only valid in programming mode\n", my_name
);
794 if (dont_erase
&& (read_mode
|| check_mode
|| prog_sram
|| test_mode
)) {
795 fprintf(stderr
, "%s: option `-n' only valid in programming mode\n", my_name
);
799 if (rw_offset
!= 0 && prog_sram
) {
800 fprintf(stderr
, "%s: option `-o' not supported in SRAM mode\n", my_name
);
804 if (rw_offset
!= 0 && test_mode
) {
805 fprintf(stderr
, "%s: option `-o' not supported in test mode\n", my_name
);
809 if (optind
+ 1 == argc
) {
811 fprintf(stderr
, "%s: test mode doesn't take a file name\n", my_name
);
812 fprintf(stderr
, "Try `%s --help' for more information.\n", argv
[0]);
815 filename
= argv
[optind
];
816 } else if (optind
!= argc
) {
817 fprintf(stderr
, "%s: too many arguments\n", my_name
);
818 fprintf(stderr
, "Try `%s --help' for more information.\n", argv
[0]);
820 } else if (bulk_erase
|| disable_protect
) {
821 filename
= "/dev/null";
822 } else if (!test_mode
&& !erase_mode
&& !disable_protect
) {
823 fprintf(stderr
, "%s: missing argument\n", my_name
);
824 fprintf(stderr
, "Try `%s --help' for more information.\n", argv
[0]);
828 /* open input/output file in advance
829 so we can fail before initializing the hardware */
836 } else if (erase_mode
) {
837 file_size
= erase_size
;
838 } else if (read_mode
) {
839 f
= (strcmp(filename
, "-") == 0) ? stdout
: fopen(filename
, "wb");
841 fprintf(stderr
, "%s: can't open '%s' for writing: ", my_name
, filename
);
846 f
= (strcmp(filename
, "-") == 0) ? stdin
: fopen(filename
, "rb");
848 fprintf(stderr
, "%s: can't open '%s' for reading: ", my_name
, filename
);
853 /* For regular programming, we need to read the file
854 twice--once for programming and once for verifying--and
855 need to know the file size in advance in order to erase
856 the correct amount of memory.
858 See if we can seek on the input file. Checking for "-"
859 as an argument isn't enough as we might be reading from a
860 named pipe, or contrarily, the standard input may be an
863 if (!prog_sram
&& !check_mode
) {
864 if (fseek(f
, 0L, SEEK_END
) != -1) {
865 file_size
= ftell(f
);
866 if (file_size
== -1) {
867 fprintf(stderr
, "%s: %s: ftell: ", my_name
, filename
);
871 if (fseek(f
, 0L, SEEK_SET
) == -1) {
872 fprintf(stderr
, "%s: %s: fseek: ", my_name
, filename
);
881 fprintf(stderr
, "%s: can't open temporary file\n", my_name
);
887 static unsigned char buffer
[4096];
888 size_t rc
= fread(buffer
, 1, 4096, pipe
);
891 size_t wc
= fwrite(buffer
, 1, rc
, f
);
893 fprintf(stderr
, "%s: can't write to temporary file\n", my_name
);
900 /* now seek to the beginning so we can
901 start reading again */
902 fseek(f
, 0, SEEK_SET
);
907 // ---------------------------------------------------------
908 // Initialize USB connection to FT2232H
909 // ---------------------------------------------------------
911 fprintf(stderr
, "init..");
912 mpsse_init(ifnum
, devstr
, slow_clock
);
914 fprintf(stderr
, "jtag..\n");
917 fprintf(stderr
, "idcode..\n");
920 fprintf(stderr
, "status..\n");
921 read_status_register();
929 /* Reset ECP5 to release SPI interface */
930 ecp_jtag_cmd(ISC_ENABLE
);
931 ecp_jtag_cmd(ISC_ERASE
);
932 ecp_jtag_cmd(ISC_DISABLE
);
934 /* Put device into SPI bypass mode */
935 enter_spi_background_mode();
942 // ---------------------------------------------------------
944 // ---------------------------------------------------------
946 fprintf(stderr
, "reset..\n");
951 //sram_chip_select();
955 // ---------------------------------------------------------
957 // ---------------------------------------------------------
959 fprintf(stderr
, "programming..\n");
961 static unsigned char buffer
[4096];
962 int rc
= fread(buffer
, 1, 4096, f
);
966 fprintf(stderr
, "sending %d bytes.\n", rc
);
967 //mpsse_send_spi(buffer, rc);
970 //mpsse_send_dummy_bytes(6);
971 //mpsse_send_dummy_bit();
975 else /* program flash */
977 // ---------------------------------------------------------
979 // ---------------------------------------------------------
981 fprintf(stderr
, "reset..\n");
983 //flash_chip_deselect();
994 // ---------------------------------------------------------
996 // ---------------------------------------------------------
998 if (!read_mode
&& !check_mode
)
1000 if (disable_protect
)
1002 flash_write_enable();
1003 flash_disable_protection();
1010 flash_write_enable();
1016 fprintf(stderr
, "file size: %ld\n", file_size
);
1018 int block_size
= erase_block_size
<< 10;
1019 int block_mask
= block_size
- 1;
1020 int begin_addr
= rw_offset
& ~block_mask
;
1021 int end_addr
= (rw_offset
+ file_size
+ block_mask
) & ~block_mask
;
1023 for (int addr
= begin_addr
; addr
< end_addr
; addr
+= block_size
) {
1024 flash_write_enable();
1025 switch(erase_block_size
) {
1027 flash_4kB_sector_erase(addr
);
1030 flash_32kB_sector_erase(addr
);
1033 flash_64kB_sector_erase(addr
);
1037 fprintf(stderr
, "Status after block erase:\n");
1038 flash_read_status();
1047 fprintf(stderr
, "programming..\n");
1049 for (int rc
, addr
= 0; true; addr
+= rc
) {
1050 uint8_t buffer
[256];
1051 int page_size
= 256 - (rw_offset
+ addr
) % 256;
1052 rc
= fread(buffer
, 1, page_size
, f
);
1055 flash_write_enable();
1056 flash_prog(rw_offset
+ addr
, buffer
, rc
);
1060 /* seek to the beginning for second pass */
1061 fseek(f
, 0, SEEK_SET
);
1065 // ---------------------------------------------------------
1067 // ---------------------------------------------------------
1070 fprintf(stderr
, "reading..\n");
1071 for (int addr
= 0; addr
< read_size
; addr
+= 256) {
1072 uint8_t buffer
[256];
1073 flash_read(rw_offset
+ addr
, buffer
, 256);
1074 fwrite(buffer
, read_size
- addr
> 256 ? 256 : read_size
- addr
, 1, f
);
1076 } else if (!erase_mode
&& !disable_verify
) {
1077 fprintf(stderr
, "reading..\n");
1078 for (int addr
= 0; true; addr
+= 256) {
1079 uint8_t buffer_flash
[256], buffer_file
[256];
1080 int rc
= fread(buffer_file
, 1, 256, f
);
1083 flash_read(rw_offset
+ addr
, buffer_flash
, rc
);
1084 if (memcmp(buffer_file
, buffer_flash
, rc
)) {
1085 fprintf(stderr
, "Found difference between flash and file!\n");
1090 fprintf(stderr
, "VERIFY OK\n");
1094 // ---------------------------------------------------------
1096 // ---------------------------------------------------------
1098 //flash_power_down();
1105 if (f
!= NULL
&& f
!= stdin
&& f
!= stdout
)
1108 // ---------------------------------------------------------
1110 // ---------------------------------------------------------
1112 fprintf(stderr
, "Bye.\n");