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