projects / ecpprog.git / blob
? search:


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