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