projects / ecpprog.git / blob
? search:


15368e9caa87e0008629f62f43d843365aa8b096
[ecpprog.git] / ecpprog / ecpprog.c
1 /*
2 * ecpprog -- simple programming tool for FTDI-based JTAG programmers
3 * Based on iceprog
4 *
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>
8 *
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.
12 *
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.
20 *
21 * Relevant Documents:
22 * -------------------
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
25 */
26
27 #define _GNU_SOURCE
28
29 #include <stdio.h>
30 #include <stdint.h>
31 #include <stdbool.h>
32 #include <stdlib.h>
33 #include <unistd.h>
34 #include <string.h>
35 #include <getopt.h>
36 #include <errno.h>
37 #include <sys/types.h>
38 #include <sys/stat.h>
39
40 #ifdef _WIN32
41 #include <io.h> /* _setmode() */
42 #include <fcntl.h> /* _O_BINARY */
43 #endif
44
45 #include "jtag.h"
46 #include "lattice_cmds.h"
47
48 static bool verbose = false;
49
50 // ---------------------------------------------------------
51 // FLASH definitions
52 // ---------------------------------------------------------
53
54 /* Flash command definitions */
55 /* This command list is based on the Winbond W25Q128JV Datasheet */
56 enum flash_cmd {
57 FC_WE = 0x06, /* Write Enable */
58 FC_SRWE = 0x50, /* Volatile SR Write Enable */
59 FC_WD = 0x04, /* Write Disable */
60 FC_RPD = 0xAB, /* Release Power-Down, returns Device ID */
61 FC_MFGID = 0x90, /* Read Manufacturer/Device ID */
62 FC_JEDECID = 0x9F, /* Read JEDEC ID */
63 FC_UID = 0x4B, /* Read Unique ID */
64 FC_RD = 0x03, /* Read Data */
65 FC_FR = 0x0B, /* Fast Read */
66 FC_PP = 0x02, /* Page Program */
67 FC_SE = 0x20, /* Sector Erase 4kb */
68 FC_BE32 = 0x52, /* Block Erase 32kb */
69 FC_BE64 = 0xD8, /* Block Erase 64kb */
70 FC_CE = 0xC7, /* Chip Erase */
71 FC_RSR1 = 0x05, /* Read Status Register 1 */
72 FC_WSR1 = 0x01, /* Write Status Register 1 */
73 FC_RSR2 = 0x35, /* Read Status Register 2 */
74 FC_WSR2 = 0x31, /* Write Status Register 2 */
75 FC_RSR3 = 0x15, /* Read Status Register 3 */
76 FC_WSR3 = 0x11, /* Write Status Register 3 */
77 FC_RSFDP = 0x5A, /* Read SFDP Register */
78 FC_ESR = 0x44, /* Erase Security Register */
79 FC_PSR = 0x42, /* Program Security Register */
80 FC_RSR = 0x48, /* Read Security Register */
81 FC_GBL = 0x7E, /* Global Block Lock */
82 FC_GBU = 0x98, /* Global Block Unlock */
83 FC_RBL = 0x3D, /* Read Block Lock */
84 FC_RPR = 0x3C, /* Read Sector Protection Registers (adesto) */
85 FC_IBL = 0x36, /* Individual Block Lock */
86 FC_IBU = 0x39, /* Individual Block Unlock */
87 FC_EPS = 0x75, /* Erase / Program Suspend */
88 FC_EPR = 0x7A, /* Erase / Program Resume */
89 FC_PD = 0xB9, /* Power-down */
90 FC_QPI = 0x38, /* Enter QPI mode */
91 FC_ERESET = 0x66, /* Enable Reset */
92 FC_RESET = 0x99, /* Reset Device */
93 };
94
95
96 // ---------------------------------------------------------
97 // JTAG -> SPI functions
98 // ---------------------------------------------------------
99
100 /*
101 * JTAG performrs all shifts LSB first, our FLSAH is expeting bytes MSB first,
102 * There are a few ways to fix this, for now we just bit-reverse all the input data to the JTAG core
103 */
104 uint8_t bit_reverse(uint8_t in){
105
106 uint8_t out = (in & 0x01) ? 0x80 : 0x00;
107 out |= (in & 0x02) ? 0x40 : 0x00;
108 out |= (in & 0x04) ? 0x20 : 0x00;
109 out |= (in & 0x08) ? 0x10 : 0x00;
110 out |= (in & 0x10) ? 0x08 : 0x00;
111 out |= (in & 0x20) ? 0x04 : 0x00;
112 out |= (in & 0x40) ? 0x02 : 0x00;
113 out |= (in & 0x80) ? 0x01 : 0x00;
114
115 return out;
116 }
117
118 void xfer_spi(uint8_t* data, uint32_t len){
119 /* Reverse bit order of all bytes */
120 for(int i = 0; i < len; i++){
121 data[i] = bit_reverse(data[i]);
122 }
123
124 /* Don't switch states if we're already in SHIFT-DR */
125 if(jtag_current_state() != STATE_SHIFT_DR)
126 jtag_go_to_state(STATE_SHIFT_DR);
127 jtag_tap_shift(data, data, len * 8, true);
128
129 /* Reverse bit order of all return bytes */
130 for(int i = 0; i < len; i++){
131 data[i] = bit_reverse(data[i]);
132 }
133 }
134
135 void send_spi(uint8_t* data, uint32_t len){
136
137 /* Flip bit order of all bytes */
138 for(int i = 0; i < len; i++){
139 data[i] = bit_reverse(data[i]);
140 }
141
142 jtag_go_to_state(STATE_SHIFT_DR);
143 /* Stay in SHIFT-DR state, this keep CS low */
144 jtag_tap_shift(data, data, len * 8, false);
145
146 /* Flip bit order of all bytes */
147 for(int i = 0; i < len; i++){
148 data[i] = bit_reverse(data[i]);
149 }
150 }
151
152
153 // ---------------------------------------------------------
154 // FLASH function implementations
155 // ---------------------------------------------------------
156
157 static void flash_read_id()
158 {
159 /* JEDEC ID structure:
160 * Byte No. | Data Type
161 * ---------+----------
162 * 0 | FC_JEDECID Request Command
163 * 1 | MFG ID
164 * 2 | Dev ID 1
165 * 3 | Dev ID 2
166 * 4 | Ext Dev Str Len
167 */
168
169 uint8_t data[260] = { FC_JEDECID };
170 int len = 5; // command + 4 response bytes
171
172 if (verbose)
173 fprintf(stderr, "read flash ID..\n");
174
175 // Write command and read first 4 bytes
176 xfer_spi(data, len);
177
178 if (data[4] == 0xFF)
179 fprintf(stderr, "Extended Device String Length is 0xFF, "
180 "this is likely a read error. Ignorig...\n");
181 else {
182 // Read extended JEDEC ID bytes
183 if (data[4] != 0) {
184 len += data[4];
185 data[0] = FC_JEDECID;
186 xfer_spi(data, len);
187 }
188 }
189
190 fprintf(stderr, "flash ID:");
191 for (int i = 1; i < len; i++)
192 fprintf(stderr, " 0x%02X", data[i]);
193 fprintf(stderr, "\n");
194 }
195
196 static void flash_reset()
197 {
198 uint8_t data[8] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
199 xfer_spi(data, 8);
200 }
201
202 static uint8_t read_status_1(){
203 uint8_t data[2] = { FC_RSR1 };
204
205 xfer_spi(data, 2);
206
207 if (verbose) {
208 fprintf(stderr, "SR1: 0x%02X\n", data[1]);
209 fprintf(stderr, " - SPRL: %s\n",
210 ((data[1] & (1 << 7)) == 0) ?
211 "unlocked" :
212 "locked");
213 fprintf(stderr, " - SPM: %s\n",
214 ((data[1] & (1 << 6)) == 0) ?
215 "Byte/Page Prog Mode" :
216 "Sequential Prog Mode");
217 fprintf(stderr, " - EPE: %s\n",
218 ((data[1] & (1 << 5)) == 0) ?
219 "Erase/Prog success" :
220 "Erase/Prog error");
221 fprintf(stderr, "- SPM: %s\n",
222 ((data[1] & (1 << 4)) == 0) ?
223 "~WP asserted" :
224 "~WP deasserted");
225 fprintf(stderr, " - SWP: ");
226 switch((data[1] >> 2) & 0x3) {
227 case 0:
228 fprintf(stderr, "All sectors unprotected\n");
229 break;
230 case 1:
231 fprintf(stderr, "Some sectors protected\n");
232 break;
233 case 2:
234 fprintf(stderr, "Reserved (xxxx 10xx)\n");
235 break;
236 case 3:
237 fprintf(stderr, "All sectors protected\n");
238 break;
239 }
240 fprintf(stderr, " - WEL: %s\n",
241 ((data[1] & (1 << 1)) == 0) ?
242 "Not write enabled" :
243 "Write enabled");
244 fprintf(stderr, " - ~RDY: %s\n",
245 ((data[1] & (1 << 0)) == 0) ?
246 "Ready" :
247 "Busy");
248 }
249
250 return data[1];
251 }
252
253 static uint8_t read_status_2(){
254 uint8_t data[2] = { FC_RSR2 };
255
256 xfer_spi(data, 2);
257
258 if (verbose) {
259 fprintf(stderr, "SR2: 0x%02X\n", data[1]);
260 fprintf(stderr, " - QE: %s\n",
261 ((data[1] & (1 << 2)) == 0) ?
262 "enabled" :
263 "disabled");
264
265 }
266
267 return data[1];
268 }
269
270 static uint8_t flash_read_status()
271 {
272 uint8_t ret = read_status_1();
273 read_status_2();
274
275 return ret;
276 }
277
278
279 static void flash_write_enable()
280 {
281 if (verbose) {
282 fprintf(stderr, "status before enable:\n");
283 flash_read_status();
284 }
285
286 if (verbose)
287 fprintf(stderr, "write enable..\n");
288
289 uint8_t data[1] = { FC_WE };
290 xfer_spi(data, 1);
291
292 if (verbose) {
293 fprintf(stderr, "status after enable:\n");
294 flash_read_status();
295 }
296 }
297
298 static void flash_bulk_erase()
299 {
300 fprintf(stderr, "bulk erase..\n");
301
302 uint8_t data[1] = { FC_CE };
303 xfer_spi(data, 1);
304 }
305
306 static void flash_4kB_sector_erase(int addr)
307 {
308 fprintf(stderr, "erase 4kB sector at 0x%06X..\n", addr);
309
310 uint8_t command[4] = { FC_SE, (uint8_t)(addr >> 16), (uint8_t)(addr >> 8), (uint8_t)addr };
311
312 xfer_spi(command, 4);
313 }
314
315 static void flash_32kB_sector_erase(int addr)
316 {
317 fprintf(stderr, "erase 64kB sector at 0x%06X..\n", addr);
318
319 uint8_t command[4] = { FC_BE32, (uint8_t)(addr >> 16), (uint8_t)(addr >> 8), (uint8_t)addr };
320
321 xfer_spi(command, 4);
322 }
323
324 static void flash_64kB_sector_erase(int addr)
325 {
326 fprintf(stderr, "erase 64kB sector at 0x%06X..\n", addr);
327
328 uint8_t command[4] = { FC_BE64, (uint8_t)(addr >> 16), (uint8_t)(addr >> 8), (uint8_t)addr };
329
330 xfer_spi(command, 4);
331 }
332
333 static void flash_prog(int addr, uint8_t *data, int n)
334 {
335 if (verbose)
336 fprintf(stderr, "prog 0x%06X +0x%03X..\n", addr, n);
337
338 uint8_t command[4] = { FC_PP, (uint8_t)(addr >> 16), (uint8_t)(addr >> 8), (uint8_t)addr };
339
340 send_spi(command, 4);
341 xfer_spi(data, n);
342
343 if (verbose)
344 for (int i = 0; i < n; i++)
345 fprintf(stderr, "%02x%c", data[i], i == n - 1 || i % 32 == 31 ? '\n' : ' ');
346 }
347
348
349 static void flash_start_read(int addr)
350 {
351 if (verbose)
352 fprintf(stderr, "Start Read 0x%06X\n", addr);
353
354 uint8_t command[4] = { FC_RD, (uint8_t)(addr >> 16), (uint8_t)(addr >> 8), (uint8_t)addr };
355
356 send_spi(command, 4);
357 }
358
359 static void flash_continue_read(uint8_t *data, int n)
360 {
361 if (verbose)
362 fprintf(stderr, "Contiune Read +0x%03X..\n", n);
363
364 memset(data, 0, n);
365 send_spi(data, n);
366
367 if (verbose)
368 for (int i = 0; i < n; i++)
369 fprintf(stderr, "%02x%c", data[i], i == n - 1 || i % 32 == 31 ? '\n' : ' ');
370 }
371
372 static void flash_wait()
373 {
374 if (verbose)
375 fprintf(stderr, "waiting..");
376
377 int count = 0;
378 while (1)
379 {
380 uint8_t data[2] = { FC_RSR1 };
381
382 xfer_spi(data, 2);
383
384 if ((data[1] & 0x01) == 0) {
385 if (count < 2) {
386 count++;
387 if (verbose) {
388 fprintf(stderr, "r");
389 fflush(stderr);
390 }
391 } else {
392 if (verbose) {
393 fprintf(stderr, "R");
394 fflush(stderr);
395 }
396 break;
397 }
398 } else {
399 if (verbose) {
400 fprintf(stderr, ".");
401 fflush(stderr);
402 }
403 count = 0;
404 }
405
406 usleep(1000);
407 }
408
409 if (verbose)
410 fprintf(stderr, "\n");
411
412 }
413
414 static void flash_disable_protection()
415 {
416 fprintf(stderr, "disable flash protection...\n");
417
418 // Write Status Register 1 <- 0x00
419 uint8_t data[2] = { FC_WSR1, 0x00 };
420 xfer_spi(data, 2);
421
422 flash_wait();
423
424 // Read Status Register 1
425 data[0] = FC_RSR1;
426
427 xfer_spi(data, 2);
428
429 if (data[1] != 0x00)
430 fprintf(stderr, "failed to disable protection, SR now equal to 0x%02x (expected 0x00)\n", data[1]);
431
432 }
433
434 // ---------------------------------------------------------
435 // ECP5 specific JTAG functions
436 // ---------------------------------------------------------
437
438
439 static void print_idcode(uint32_t idcode){
440 for(int i = 0; i < sizeof(ecp_devices)/sizeof(struct ecp_device_id); i++){
441 if(idcode == ecp_devices[i].device_id)
442 {
443 printf("IDCODE: 0x%08x (%s)\n", idcode ,ecp_devices[i].device_name);
444 return;
445 }
446 }
447 printf("IDCODE: 0x%08x does not match :(\n", idcode);
448 }
449
450 static void read_idcode(){
451
452 uint8_t data[4] = {READ_ID};
453
454 jtag_go_to_state(STATE_SHIFT_IR);
455 jtag_tap_shift(data, data, 8, true);
456
457 data[0] = 0;
458 jtag_go_to_state(STATE_SHIFT_DR);
459 jtag_tap_shift(data, data, 32, true);
460
461 uint32_t idcode = 0;
462
463 /* Format the IDCODE into a 32bit value */
464 for(int i = 0; i< 4; i++)
465 idcode = data[i] << 24 | idcode >> 8;
466
467 print_idcode(idcode);
468 }
469
470
471 static void print_status_register(uint32_t status){
472 printf("ECP5 Status Register: 0x%08x\n", status);
473
474 if(verbose){
475 printf(" Transparent Mode: %s\n", status & (1 << 0) ? "Yes" : "No" );
476 printf(" Config Target: %s\n", status & (7 << 1) ? "eFuse" : "SRAM" );
477 printf(" JTAG Active: %s\n", status & (1 << 4) ? "Yes" : "No" );
478 printf(" PWD Protection: %s\n", status & (1 << 5) ? "Yes" : "No" );
479 printf(" Decrypt Enable: %s\n", status & (1 << 7) ? "Yes" : "No" );
480 printf(" DONE: %s\n", status & (1 << 8) ? "Yes" : "No" );
481 printf(" ISC Enable: %s\n", status & (1 << 9) ? "Yes" : "No" );
482 printf(" Write Enable: %s\n", status & (1 << 10) ? "Writable" : "Not Writable");
483 printf(" Read Enable: %s\n", status & (1 << 11) ? "Readable" : "Not Readable");
484 printf(" Busy Flag: %s\n", status & (1 << 12) ? "Yes" : "No" );
485 printf(" Fail Flag: %s\n", status & (1 << 13) ? "Yes" : "No" );
486 printf(" Feature OTP: %s\n", status & (1 << 14) ? "Yes" : "No" );
487 printf(" Decrypt Only: %s\n", status & (1 << 15) ? "Yes" : "No" );
488 printf(" PWD Enable: %s\n", status & (1 << 16) ? "Yes" : "No" );
489 printf(" Encrypt Preamble: %s\n", status & (1 << 20) ? "Yes" : "No" );
490 printf(" Std Preamble: %s\n", status & (1 << 21) ? "Yes" : "No" );
491 printf(" SPIm Fail 1: %s\n", status & (1 << 22) ? "Yes" : "No" );
492
493 uint8_t bse_error = (status & (7 << 23)) >> 23;
494 switch (bse_error){
495 case 0b000: printf(" BSE Error Code: No Error (0b000)\n"); break;
496 case 0b001: printf(" BSE Error Code: ID Error (0b001)\n"); break;
497 case 0b010: printf(" BSE Error Code: CMD Error - illegal command (0b010)\n"); break;
498 case 0b011: printf(" BSE Error Code: CRC Error (0b011)\n"); break;
499 case 0b100: printf(" BSE Error Code: PRMB Error - preamble error (0b100)\n"); break;
500 case 0b101: printf(" BSE Error Code: ABRT Error - configuration aborted by the user (0b101)\n"); break;
501 case 0b110: printf(" BSE Error Code: OVFL Error - data overflow error (0b110)\n"); break;
502 case 0b111: printf(" BSE Error Code: SDM Error - bitstream pass the size of SRAM array (0b111)\n"); break;
503 }
504
505 printf(" Execution Error: %s\n", status & (1 << 26) ? "Yes" : "No" );
506 printf(" ID Error: %s\n", status & (1 << 27) ? "Yes" : "No" );
507 printf(" Invalid Command: %s\n", status & (1 << 28) ? "Yes" : "No" );
508 printf(" SED Error: %s\n", status & (1 << 29) ? "Yes" : "No" );
509 printf(" Bypass Mode: %s\n", status & (1 << 30) ? "Yes" : "No" );
510 printf(" Flow Through Mode: %s\n", status & (1 << 31) ? "Yes" : "No" );
511 }
512 }
513
514
515 static void read_status_register(){
516
517 uint8_t data[4] = {LSC_READ_STATUS};
518
519 jtag_go_to_state(STATE_SHIFT_IR);
520 jtag_tap_shift(data, data, 8, true);
521
522 data[0] = 0;
523 jtag_go_to_state(STATE_SHIFT_DR);
524 jtag_tap_shift(data, data, 32, true);
525 //jtag_go_to_state(STATE_PAUSE_DR);
526
527 uint32_t status = 0;
528
529 /* Format the IDCODE into a 32bit value */
530 for(int i = 0; i< 4; i++)
531 status = data[i] << 24 | status >> 8;
532
533 print_status_register(status);
534 }
535
536
537
538 static void enter_spi_background_mode(){
539
540 uint8_t data[4] = {0x3A};
541
542 jtag_go_to_state(STATE_SHIFT_IR);
543 jtag_tap_shift(data, data, 8, true);
544
545 /* These bytes seem to be required to un-lock the SPI interface */
546 data[0] = 0xFE;
547 data[1] = 0x68;
548 jtag_go_to_state(STATE_SHIFT_DR);
549 jtag_tap_shift(data, data, 16, true);
550
551 /* Entering IDLE is essential */
552 jtag_go_to_state(STATE_RUN_TEST_IDLE);
553 }
554
555
556 void ecp_jtag_cmd(uint8_t cmd){
557 uint8_t data[1] = {cmd};
558
559 jtag_go_to_state(STATE_SHIFT_IR);
560 jtag_tap_shift(data, data, 8, true);
561
562 jtag_go_to_state(STATE_RUN_TEST_IDLE);
563 jtag_wait_time(32);
564 }
565
566 void ecp_jtag_cmd8(uint8_t cmd, uint8_t param){
567 uint8_t data[1] = {cmd};
568
569 jtag_go_to_state(STATE_SHIFT_IR);
570 jtag_tap_shift(data, data, 8, true);
571
572 data[0] = param;
573 jtag_go_to_state(STATE_SHIFT_DR);
574 jtag_tap_shift(data, data, 8, true);
575
576 jtag_go_to_state(STATE_RUN_TEST_IDLE);
577 jtag_wait_time(32);
578 }
579
580 // ---------------------------------------------------------
581 // iceprog implementation
582 // ---------------------------------------------------------
583
584 static void help(const char *progname)
585 {
586 fprintf(stderr, "Simple programming tool for FTDI-based Lattice ECP JTAG programmers.\n");
587 fprintf(stderr, "Usage: %s [-b|-n|-c] <input file>\n", progname);
588 fprintf(stderr, " %s -r|-R<bytes> <output file>\n", progname);
589 fprintf(stderr, " %s -S <input file>\n", progname);
590 fprintf(stderr, " %s -t\n", progname);
591 fprintf(stderr, "\n");
592 fprintf(stderr, "General options:\n");
593 fprintf(stderr, " -d <device string> use the specified USB device [default: i:0x0403:0x6010 or i:0x0403:0x6014]\n");
594 fprintf(stderr, " d:<devicenode> (e.g. d:002/005)\n");
595 fprintf(stderr, " i:<vendor>:<product> (e.g. i:0x0403:0x6010)\n");
596 fprintf(stderr, " i:<vendor>:<product>:<index> (e.g. i:0x0403:0x6010:0)\n");
597 fprintf(stderr, " s:<vendor>:<product>:<serial-string>\n");
598 fprintf(stderr, " -I [ABCD] connect to the specified interface on the FTDI chip\n");
599 fprintf(stderr, " [default: A]\n");
600 fprintf(stderr, " -o <offset in bytes> start address for read/write [default: 0]\n");
601 fprintf(stderr, " (append 'k' to the argument for size in kilobytes,\n");
602 fprintf(stderr, " or 'M' for size in megabytes)\n");
603 fprintf(stderr, " -s slow SPI (50 kHz instead of 6 MHz)\n");
604 fprintf(stderr, " -v verbose output\n");
605 fprintf(stderr, " -i [4,32,64] select erase block size [default: 64k]\n");
606 fprintf(stderr, "\n");
607 fprintf(stderr, "Mode of operation:\n");
608 fprintf(stderr, " [default] write file contents to flash, then verify\n");
609 fprintf(stderr, " -X write file contents to flash only\n");
610 fprintf(stderr, " -r read first 256 kB from flash and write to file\n");
611 fprintf(stderr, " -R <size in bytes> read the specified number of bytes from flash\n");
612 fprintf(stderr, " (append 'k' to the argument for size in kilobytes,\n");
613 fprintf(stderr, " or 'M' for size in megabytes)\n");
614 fprintf(stderr, " -c do not write flash, only verify (`check')\n");
615 fprintf(stderr, " -S perform SRAM programming\n");
616 fprintf(stderr, " -t just read the flash ID sequence\n");
617 fprintf(stderr, "\n");
618 fprintf(stderr, "Erase mode (only meaningful in default mode):\n");
619 fprintf(stderr, " [default] erase aligned chunks of 64kB in write mode\n");
620 fprintf(stderr, " This means that some data after the written data (or\n");
621 fprintf(stderr, " even before when -o is used) may be erased as well.\n");
622 fprintf(stderr, " -b bulk erase entire flash before writing\n");
623 fprintf(stderr, " -e <size in bytes> erase flash as if we were writing that number of bytes\n");
624 fprintf(stderr, " -n do not erase flash before writing\n");
625 fprintf(stderr, " -p disable write protection before erasing or writing\n");
626 fprintf(stderr, " This can be useful if flash memory appears to be\n");
627 fprintf(stderr, " bricked and won't respond to erasing or programming.\n");
628 fprintf(stderr, "\n");
629 fprintf(stderr, "Miscellaneous options:\n");
630 fprintf(stderr, " --help display this help and exit\n");
631 fprintf(stderr, " -- treat all remaining arguments as filenames\n");
632 fprintf(stderr, "\n");
633 fprintf(stderr, "Exit status:\n");
634 fprintf(stderr, " 0 on success,\n");
635 fprintf(stderr, " 1 if a non-hardware error occurred (e.g., failure to read from or\n");
636 fprintf(stderr, " write to a file, or invoked with invalid options),\n");
637 fprintf(stderr, " 2 if communication with the hardware failed (e.g., cannot find the\n");
638 fprintf(stderr, " iCE FTDI USB device),\n");
639 fprintf(stderr, " 3 if verification of the data failed.\n");
640 fprintf(stderr, "\n");
641 fprintf(stderr, "If you have a bug report, please file an issue on github:\n");
642 fprintf(stderr, " https://github.com/gregdavill/ecpprog/issues\n");
643 }
644
645 int main(int argc, char **argv)
646 {
647 /* used for error reporting */
648 const char *my_name = argv[0];
649 for (size_t i = 0; argv[0][i]; i++)
650 if (argv[0][i] == '/')
651 my_name = argv[0] + i + 1;
652
653 int read_size = 256 * 1024;
654 int erase_block_size = 64;
655 int erase_size = 0;
656 int rw_offset = 0;
657
658 bool read_mode = false;
659 bool check_mode = false;
660 bool erase_mode = false;
661 bool bulk_erase = false;
662 bool dont_erase = false;
663 bool prog_sram = false;
664 bool test_mode = false;
665 bool slow_clock = false;
666 bool disable_protect = false;
667 bool disable_verify = false;
668 const char *filename = NULL;
669 const char *devstr = NULL;
670 int ifnum = 0;
671
672 #ifdef _WIN32
673 _setmode(_fileno(stdin), _O_BINARY);
674 _setmode(_fileno(stdout), _O_BINARY);
675 #endif
676
677 static struct option long_options[] = {
678 {"help", no_argument, NULL, -2},
679 {NULL, 0, NULL, 0}
680 };
681
682 /* Decode command line parameters */
683 int opt;
684 char *endptr;
685 while ((opt = getopt_long(argc, argv, "d:i:I:rR:e:o:cbnStvspX", long_options, NULL)) != -1) {
686 switch (opt) {
687 case 'd': /* device string */
688 devstr = optarg;
689 break;
690 case 'i': /* block erase size */
691 if (!strcmp(optarg, "4"))
692 erase_block_size = 4;
693 else if (!strcmp(optarg, "32"))
694 erase_block_size = 32;
695 else if (!strcmp(optarg, "64"))
696 erase_block_size = 64;
697 else {
698 fprintf(stderr, "%s: `%s' is not a valid erase block size (must be `4', `32' or `64')\n", my_name, optarg);
699 return EXIT_FAILURE;
700 }
701 break;
702 case 'I': /* FTDI Chip interface select */
703 if (!strcmp(optarg, "A"))
704 ifnum = 0;
705 else if (!strcmp(optarg, "B"))
706 ifnum = 1;
707 else if (!strcmp(optarg, "C"))
708 ifnum = 2;
709 else if (!strcmp(optarg, "D"))
710 ifnum = 3;
711 else {
712 fprintf(stderr, "%s: `%s' is not a valid interface (must be `A', `B', `C', or `D')\n", my_name, optarg);
713 return EXIT_FAILURE;
714 }
715 break;
716 case 'r': /* Read 256 bytes to file */
717 read_mode = true;
718 break;
719 case 'R': /* Read n bytes to file */
720 read_mode = true;
721 read_size = strtol(optarg, &endptr, 0);
722 if (*endptr == '\0')
723 /* ok */;
724 else if (!strcmp(endptr, "k"))
725 read_size *= 1024;
726 else if (!strcmp(endptr, "M"))
727 read_size *= 1024 * 1024;
728 else {
729 fprintf(stderr, "%s: `%s' is not a valid size\n", my_name, optarg);
730 return EXIT_FAILURE;
731 }
732 break;
733 case 'e': /* Erase blocks as if we were writing n bytes */
734 erase_mode = true;
735 erase_size = strtol(optarg, &endptr, 0);
736 if (*endptr == '\0')
737 /* ok */;
738 else if (!strcmp(endptr, "k"))
739 erase_size *= 1024;
740 else if (!strcmp(endptr, "M"))
741 erase_size *= 1024 * 1024;
742 else {
743 fprintf(stderr, "%s: `%s' is not a valid size\n", my_name, optarg);
744 return EXIT_FAILURE;
745 }
746 break;
747 case 'o': /* set address offset */
748 rw_offset = strtol(optarg, &endptr, 0);
749 if (*endptr == '\0')
750 /* ok */;
751 else if (!strcmp(endptr, "k"))
752 rw_offset *= 1024;
753 else if (!strcmp(endptr, "M"))
754 rw_offset *= 1024 * 1024;
755 else {
756 fprintf(stderr, "%s: `%s' is not a valid offset\n", my_name, optarg);
757 return EXIT_FAILURE;
758 }
759 break;
760 case 'c': /* do not write just check */
761 check_mode = true;
762 break;
763 case 'b': /* bulk erase before writing */
764 bulk_erase = true;
765 break;
766 case 'n': /* do not erase before writing */
767 dont_erase = true;
768 break;
769 case 'S': /* write to sram directly */
770 prog_sram = true;
771 break;
772 case 't': /* just read flash id */
773 test_mode = true;
774 break;
775 case 'v': /* provide verbose output */
776 verbose = true;
777 break;
778 case 's': /* use slow SPI clock */
779 slow_clock = true;
780 break;
781 case 'p': /* disable flash protect before erase/write */
782 disable_protect = true;
783 break;
784 case 'X': /* disable verification */
785 disable_verify = true;
786 break;
787 case -2:
788 help(argv[0]);
789 return EXIT_SUCCESS;
790 default:
791 /* error message has already been printed */
792 fprintf(stderr, "Try `%s --help' for more information.\n", argv[0]);
793 return EXIT_FAILURE;
794 }
795 }
796
797 /* Make sure that the combination of provided parameters makes sense */
798
799 if (read_mode + erase_mode + check_mode + prog_sram + test_mode > 1) {
800 fprintf(stderr, "%s: options `-r'/`-R', `-e`, `-c', `-S', and `-t' are mutually exclusive\n", my_name);
801 return EXIT_FAILURE;
802 }
803
804 if (bulk_erase && dont_erase) {
805 fprintf(stderr, "%s: options `-b' and `-n' are mutually exclusive\n", my_name);
806 return EXIT_FAILURE;
807 }
808
809 if (disable_protect && (read_mode || check_mode || prog_sram || test_mode)) {
810 fprintf(stderr, "%s: option `-p' only valid in programming mode\n", my_name);
811 return EXIT_FAILURE;
812 }
813
814 if (bulk_erase && (read_mode || check_mode || prog_sram || test_mode)) {
815 fprintf(stderr, "%s: option `-b' only valid in programming mode\n", my_name);
816 return EXIT_FAILURE;
817 }
818
819 if (dont_erase && (read_mode || check_mode || prog_sram || test_mode)) {
820 fprintf(stderr, "%s: option `-n' only valid in programming mode\n", my_name);
821 return EXIT_FAILURE;
822 }
823
824 if (rw_offset != 0 && prog_sram) {
825 fprintf(stderr, "%s: option `-o' not supported in SRAM mode\n", my_name);
826 return EXIT_FAILURE;
827 }
828
829 if (rw_offset != 0 && test_mode) {
830 fprintf(stderr, "%s: option `-o' not supported in test mode\n", my_name);
831 return EXIT_FAILURE;
832 }
833
834 if (optind + 1 == argc) {
835 if (test_mode) {
836 fprintf(stderr, "%s: test mode doesn't take a file name\n", my_name);
837 fprintf(stderr, "Try `%s --help' for more information.\n", argv[0]);
838 return EXIT_FAILURE;
839 }
840 filename = argv[optind];
841 } else if (optind != argc) {
842 fprintf(stderr, "%s: too many arguments\n", my_name);
843 fprintf(stderr, "Try `%s --help' for more information.\n", argv[0]);
844 return EXIT_FAILURE;
845 } else if (bulk_erase || disable_protect) {
846 filename = "/dev/null";
847 } else if (!test_mode && !erase_mode && !disable_protect) {
848 fprintf(stderr, "%s: missing argument\n", my_name);
849 fprintf(stderr, "Try `%s --help' for more information.\n", argv[0]);
850 return EXIT_FAILURE;
851 }
852
853 /* open input/output file in advance
854 so we can fail before initializing the hardware */
855
856 FILE *f = NULL;
857 long file_size = -1;
858
859 if (test_mode) {
860 /* nop */;
861 } else if (erase_mode) {
862 file_size = erase_size;
863 } else if (read_mode) {
864 f = (strcmp(filename, "-") == 0) ? stdout : fopen(filename, "wb");
865 if (f == NULL) {
866 fprintf(stderr, "%s: can't open '%s' for writing: ", my_name, filename);
867 perror(0);
868 return EXIT_FAILURE;
869 }
870 } else {
871 f = (strcmp(filename, "-") == 0) ? stdin : fopen(filename, "rb");
872 if (f == NULL) {
873 fprintf(stderr, "%s: can't open '%s' for reading: ", my_name, filename);
874 perror(0);
875 return EXIT_FAILURE;
876 }
877
878 /* For regular programming, we need to read the file
879 twice--once for programming and once for verifying--and
880 need to know the file size in advance in order to erase
881 the correct amount of memory.
882
883 See if we can seek on the input file. Checking for "-"
884 as an argument isn't enough as we might be reading from a
885 named pipe, or contrarily, the standard input may be an
886 ordinary file. */
887
888 if (!prog_sram && !check_mode) {
889 if (fseek(f, 0L, SEEK_END) != -1) {
890 file_size = ftell(f);
891 if (file_size == -1) {
892 fprintf(stderr, "%s: %s: ftell: ", my_name, filename);
893 perror(0);
894 return EXIT_FAILURE;
895 }
896 if (fseek(f, 0L, SEEK_SET) == -1) {
897 fprintf(stderr, "%s: %s: fseek: ", my_name, filename);
898 perror(0);
899 return EXIT_FAILURE;
900 }
901 } else {
902 FILE *pipe = f;
903
904 f = tmpfile();
905 if (f == NULL) {
906 fprintf(stderr, "%s: can't open temporary file\n", my_name);
907 return EXIT_FAILURE;
908 }
909 file_size = 0;
910
911 while (true) {
912 static unsigned char buffer[4096];
913 size_t rc = fread(buffer, 1, 4096, pipe);
914 if (rc <= 0)
915 break;
916 size_t wc = fwrite(buffer, 1, rc, f);
917 if (wc != rc) {
918 fprintf(stderr, "%s: can't write to temporary file\n", my_name);
919 return EXIT_FAILURE;
920 }
921 file_size += rc;
922 }
923 fclose(pipe);
924
925 /* now seek to the beginning so we can
926 start reading again */
927 fseek(f, 0, SEEK_SET);
928 }
929 }
930 }
931
932 // ---------------------------------------------------------
933 // Initialize USB connection to FT2232H
934 // ---------------------------------------------------------
935
936 fprintf(stderr, "init..\n");
937 jtag_init(ifnum, devstr, slow_clock);
938
939 read_idcode();
940 read_status_register();
941
942 if (test_mode)
943 {
944 /* Reset ECP5 to release SPI interface */
945 ecp_jtag_cmd(ISC_ENABLE);
946 ecp_jtag_cmd(ISC_ERASE);
947 ecp_jtag_cmd(ISC_DISABLE);
948
949 /* Put device into SPI bypass mode */
950 enter_spi_background_mode();
951
952 flash_reset();
953 flash_read_id();
954
955 flash_read_status();
956 }
957 else if (prog_sram)
958 {
959 // ---------------------------------------------------------
960 // Reset
961 // ---------------------------------------------------------
962 fprintf(stderr, "reset..\n");
963
964 ecp_jtag_cmd8(ISC_ENABLE, 0);
965 ecp_jtag_cmd8(ISC_ERASE, 0);
966 ecp_jtag_cmd8(LSC_RESET_CRC, 0);
967
968 read_status_register();
969
970 // ---------------------------------------------------------
971 // Program
972 // ---------------------------------------------------------
973
974 fprintf(stderr, "programming..\n");
975 ecp_jtag_cmd(LSC_BITSTREAM_BURST);
976 while (1) {
977 const uint32_t len = 16*1024;
978 static unsigned char buffer[16*1024];
979 int rc = fread(buffer, 1, len, f);
980 if (rc <= 0)
981 break;
982 if (verbose)
983 fprintf(stderr, "sending %d bytes.\n", rc);
984
985 for(int i = 0; i < len; i++){
986 buffer[i] = bit_reverse(buffer[i]);
987 }
988
989 jtag_go_to_state(STATE_CAPTURE_DR);
990 jtag_tap_shift(buffer, buffer, len*8, false);
991 }
992
993 ecp_jtag_cmd(ISC_DISABLE);
994 read_status_register();
995 }
996 else /* program flash */
997 {
998 // ---------------------------------------------------------
999 // Reset
1000 // ---------------------------------------------------------
1001
1002 fprintf(stderr, "reset..\n");
1003 /* Reset ECP5 to release SPI interface */
1004 ecp_jtag_cmd8(ISC_ENABLE, 0);
1005 ecp_jtag_cmd8(ISC_ERASE, 0);
1006 ecp_jtag_cmd8(ISC_DISABLE, 0);
1007
1008 /* Put device into SPI bypass mode */
1009 enter_spi_background_mode();
1010
1011 flash_reset();
1012
1013 flash_read_id();
1014
1015
1016 // ---------------------------------------------------------
1017 // Program
1018 // ---------------------------------------------------------
1019
1020 if (!read_mode && !check_mode)
1021 {
1022 if (disable_protect)
1023 {
1024 flash_write_enable();
1025 flash_disable_protection();
1026 }
1027
1028 if (!dont_erase)
1029 {
1030 if (bulk_erase)
1031 {
1032 flash_write_enable();
1033 flash_bulk_erase();
1034 flash_wait();
1035 }
1036 else
1037 {
1038 fprintf(stderr, "file size: %ld\n", file_size);
1039
1040 int block_size = erase_block_size << 10;
1041 int block_mask = block_size - 1;
1042 int begin_addr = rw_offset & ~block_mask;
1043 int end_addr = (rw_offset + file_size + block_mask) & ~block_mask;
1044
1045 for (int addr = begin_addr; addr < end_addr; addr += block_size) {
1046 flash_write_enable();
1047 switch(erase_block_size) {
1048 case 4:
1049 flash_4kB_sector_erase(addr);
1050 break;
1051 case 32:
1052 flash_32kB_sector_erase(addr);
1053 break;
1054 case 64:
1055 flash_64kB_sector_erase(addr);
1056 break;
1057 }
1058 if (verbose) {
1059 fprintf(stderr, "Status after block erase:\n");
1060 flash_read_status();
1061 }
1062 flash_wait();
1063 }
1064 }
1065 }
1066
1067 if (!erase_mode)
1068 {
1069 for (int rc, addr = 0; true; addr += rc) {
1070 uint8_t buffer[256];
1071
1072 /* Show progress */
1073 fprintf(stderr, "\r\033[0Kprogramming.. %04u/%04lu", addr, file_size);
1074
1075 int page_size = 256 - (rw_offset + addr) % 256;
1076 rc = fread(buffer, 1, page_size, f);
1077 if (rc <= 0)
1078 break;
1079 flash_write_enable();
1080 flash_prog(rw_offset + addr, buffer, rc);
1081 flash_wait();
1082
1083 }
1084
1085 fprintf(stderr, "\n");
1086 /* seek to the beginning for second pass */
1087 fseek(f, 0, SEEK_SET);
1088 }
1089 }
1090
1091 // ---------------------------------------------------------
1092 // Read/Verify
1093 // ---------------------------------------------------------
1094
1095 if (read_mode) {
1096
1097 flash_start_read(rw_offset);
1098 for (int addr = 0; addr < read_size; addr += 4096) {
1099 uint8_t buffer[4096];
1100
1101 /* Show progress */
1102 fprintf(stderr, "\r\033[0Kreading.. %04u/%04lu", addr, file_size);
1103
1104 flash_continue_read(buffer, 4096);
1105 fwrite(buffer, read_size - addr > 4096 ? 4096 : read_size - addr, 1, f);
1106 }
1107 fprintf(stderr, "\n");
1108 } else if (!erase_mode && !disable_verify) {
1109
1110 flash_start_read(rw_offset);
1111 for (int addr = 0; addr < read_size; addr += 4096) {
1112 uint8_t buffer_flash[4096], buffer_file[4096];
1113
1114 int rc = fread(buffer_file, 1, 4096, f);
1115 if (rc <= 0)
1116 break;
1117
1118 flash_continue_read(buffer_flash, rc);
1119
1120 /* Show progress */
1121 fprintf(stderr, "\r\033[0Kverify.. %04u/%04lu", addr + rc, file_size);
1122 if (memcmp(buffer_file, buffer_flash, rc)) {
1123 fprintf(stderr, "Found difference between flash and file!\n");
1124 jtag_error(3);
1125 }
1126
1127 }
1128 fprintf(stderr, " VERIFY OK\n");
1129 }
1130 }
1131
1132 if (f != NULL && f != stdin && f != stdout)
1133 fclose(f);
1134
1135 // ---------------------------------------------------------
1136 // Exit
1137 // ---------------------------------------------------------
1138
1139 fprintf(stderr, "Bye.\n");
1140 jtag_deinit();
1141 return 0;
1142 }