added v2.0

tools/iceprogduino/Makefile

@@ -0,0 +1,17 @@
+CC = gcc
+CFLAG = -c -Wall
+EXECUTE = iceprogduino
+NAME = iceprogduino
+
+all: $(EXECUTE)
+
+$(EXECUTE): $(NAME).o
+	$(CC) $(NAME).o -o $(EXECUTE)
+	
+clean:
+	rm -rf *.o $(EXECUTE)
+
+install:
+	cp $(EXECUTE) /usr/local/bin/$(EXECUTE)
+
+

tools/iceprogduino/iceprogduino.c

@@ -0,0 +1,824 @@
+/*
+ *  iceprogduino -- simple programming tool for FTDI-based Lattice iCE programmers
+ *  and Olinuxino based programmers for iCE40HX1K-EVB
+ *
+ *  Copyright (C) 2015  Clifford Wolf <clifford@clifford.at>
+ *  Olimexino Nano edition by Chris B. <chris@protonic.co.uk> @ Olimex Ltd. <c> 2016
+ *  
+ *  Permission to use, copy, modify, and/or distribute this software for any
+ *  purpose with or without fee is hereby granted, provided that the above
+ *  copyright notice and this permission notice appear in all copies.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ *  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ *  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ *  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ *  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ *  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ *  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ *  Relevant Documents:
+ *  -------------------
+ *  http://www.latticesemi.com/~/media/Documents/UserManuals/EI/icestickusermanual.pdf
+ *  http://www.micron.com/~/media/documents/products/data-sheet/nor-flash/serial-nor/n25q/n25q_32mb_3v_65nm.pdf
+ *  https://www.olimex.com/ iCE40HX1K-EVB
+ */
+
+//#define Olinuxino
+//#define FTDI
+#define Nano
+
+#define READ_ID 	0x9F
+#define PWR_UP 		0xAB
+#define PWR_DOWN 	0xB9
+#define WR_EN		0x06
+#define BULK_ERASE	0xC7
+#define SEC_ERASE	0xd8
+#define PROG		0x02
+#define READ		0x03
+#define READY  		0x44
+#define READ_ALL    0x83
+#define EMPTY    0x45
+
+
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+
+ 
+
+
+void serial_read(int x);
+
+#define FEND	0xc0
+#define FESC	0xdb
+#define TFEND 	0xdc
+#define TFESC	0xdd
+bool newframe;
+bool timeout;
+bool escaped;
+#include <termios.h>
+#define SerialPort  "/dev/ttyACM0"
+int fd;
+uint8_t rxframe[512], txframe[512], fcs, tfcs;
+uint16_t txp,rxp;
+uint8_t membuf[0x200000];
+uint8_t pages[0x2000];
+
+ 
+
+
+
+
+bool verbose = false;
+
+
+
+
+ 
+
+int set_interface_attribs (int fd, int speed, int parity)
+{
+        struct termios tty;
+        memset (&tty, 0, sizeof tty);
+        if (tcgetattr (fd, &tty) != 0)
+        {
+                fprintf(stderr,"error %d from tcgetattr", errno);
+                return -1;
+        }
+
+        cfsetospeed (&tty, speed);
+        cfsetispeed (&tty, speed);
+
+        tty.c_cflag = (tty.c_cflag & ~CSIZE) | CS8;     // 8-bit chars
+        tty.c_iflag &= ~IGNBRK;         // disable break processing
+        tty.c_lflag = 0;                // no signaling chars, no echo,
+                                        // no canonical processing
+        tty.c_oflag = 0;                // no remapping, no delays
+        tty.c_cc[VMIN]  = 0;            // read doesn't block
+        tty.c_cc[VTIME] = 0;            // no read timeout
+
+        tty.c_iflag &= ~(IXON | IXOFF | IXANY); // shut off xon/xoff ctrl
+
+        tty.c_cflag |= (CLOCAL | CREAD);// ignore modem controls,
+                                        // enable reading
+        tty.c_cflag &= ~(PARENB | PARODD);      // shut off parity
+        tty.c_cflag |= parity;
+        tty.c_cflag |= parity;
+        tty.c_cflag &= ~CSTOPB;
+        tty.c_cflag &= ~CRTSCTS;
+
+        if (tcsetattr (fd, TCSANOW, &tty) != 0)
+        {
+                fprintf(stderr,"error %d from tcsetattr", errno);
+                return -1;
+        }
+        return 0;
+}
+
+void set_blocking (int fd, int should_block)
+{
+        struct termios tty;
+        memset (&tty, 0, sizeof tty);
+        if (tcgetattr (fd, &tty) != 0)
+        {
+                fprintf(stderr,"error %d from tggetattr", errno);
+                return;
+        }
+
+        tty.c_cc[VMIN]  = should_block ? 1 : 0;
+        tty.c_cc[VTIME] = 0;            
+
+        if (tcsetattr (fd, TCSANOW, &tty) != 0)
+               fprintf(stderr,"error %d setting term attributes", errno);
+}
+
+void startframe(uint8_t command){
+  txframe[0]=FEND;
+  txframe[1]=command;
+  tfcs = command;
+  txp = 2;
+}
+
+void addbyte(uint8_t newbyte){
+ tfcs+=newbyte;
+ 
+ switch(newbyte){
+ case FEND:
+  txframe[txp++] = FESC;
+  txframe[txp++] = TFEND;
+  break;
+ case FESC:
+  txframe[txp++] = FESC;
+  txframe[txp++] = TFESC;
+  break; 
+ 
+  default:
+  txframe[txp++] = newbyte;
+  break;
+ }
+}
+
+void sendframe(){
+	tfcs=0xff-tfcs;
+ addbyte(tfcs);	
+ txframe[txp++] = FEND;
+#ifdef frdebug  
+printf("%02X-L:%04X/%02X\n",txframe[txp-1],txp,tfcs);
+#endif 
+if (fd>=0)
+ write(fd,txframe,txp);
+}
+ 
+
+
+void error()
+{
+	exit(1);
+}
+
+
+ 
+
+bool waitframe(uint8_t cmd)
+{
+	rxp = 0;
+	newframe = false;
+	fcs = 0;
+
+uint32_t addr;
+
+for (uint32_t to=0;to<5000;to++)
+{
+serial_read(0);
+usleep(50);	
+
+if (newframe){
+//	int rxpp = rxp;
+	rxp = 0;
+	newframe = false;
+	usleep(10);
+
+	     
+				if ((rxframe[0]==READ_ID) && (cmd == READ_ID)){
+			
+						if (rxframe[1]==0xef) fprintf(stderr, "Winbond Serial Flash ");
+						else fprintf(stderr, "Manufacturer ID: 0x%02X",rxframe[1]);
+						if ((rxframe[2]==0x40) && (rxframe[3]==0x15)) fprintf(stderr, "- W25Q16BV\n");  
+						else fprintf(stderr, " / Device ID: 0x%02X%02X\n",rxframe[2],rxframe[3]);
+						
+						return true;
+						
+										}	 
+	     
+				if (rxframe[0]==READ)
+	     
+					{
+			
+						addr = (rxframe[1]<<16) | (rxframe[2]<<8);
+						pages[addr>>8]=0;
+	              
+						for (int x=3; x < 259;x++)
+						{
+
+							membuf[addr++]=rxframe[x];
+						}
+					}
+
+		if (rxframe[0]==READY)  if (cmd==READY) return true; else to = 0;
+  
+		if (rxframe[0]==EMPTY)  pages[(rxframe[1]<<8) | rxframe[2]]=0;
+	
+		if ((rxframe[0]==READ)||(rxframe[0]==EMPTY)) if (cmd==READ) return true; else to = 0;
+rxframe[0]=0;
+fcs = 0;
+}
+
+}
+return false;
+}
+ 
+
+
+
+void flash_read_id()
+{
+	startframe(READ_ID);
+	sendframe();
+	waitframe(READ_ID);
+	return;
+ 	
+	fprintf(stderr, "\n");
+}
+
+
+void flash_bulk_erase()
+{
+	fprintf(stderr, "\nbulk erase..");
+
+ 
+	startframe(BULK_ERASE);
+	sendframe();
+    waitframe(BULK_ERASE);
+    fprintf(stderr, "\rbulk erased\n");
+ 	
+}
+
+void flash_64kB_sector_erase(int addr)
+{
+	fprintf(stderr, "erase 64kB sector at 0x%06X..", addr);
+ 
+	startframe(SEC_ERASE);
+	addbyte(addr>>16);
+	addbyte(addr>>8);
+	sendframe();
+    waitframe(READY);
+    fprintf(stderr, "erased\n");
+ 
+}
+ 
+void flash_read_all(void){
+	
+  	fprintf(stderr, "read 0x%06X +0x%06X..\n", 0, 0x200000);
+	 memset(&membuf,0xff,sizeof(membuf));
+	 memset(&pages,0xff,sizeof(pages));
+     startframe(READ_ALL);
+     sendframe();
+	 if (!waitframe(READY))
+	 {
+		error();
+		 
+	 }	 
+	 
+	 fprintf(stderr, "Requesting missmatched frames...");
+				bool notready=false;
+				while (1){
+					notready = false;
+					int s = 0;
+				for(int x = 0; x < 0x2000;x++)
+				{
+	
+					if (pages[x]>0){
+				if (s++ > 25)
+					{
+						fprintf(stderr, "ERROR Reading..\n");
+						notready = false;
+						break;
+					} 
+					notready=true;	
+						fprintf(stderr, ".");
+						startframe(READ);
+						addbyte(x >> 8);
+						addbyte(x >> 0);
+						sendframe();
+						waitframe(READ);
+		
+						
+					}
+				
+				}
+		
+				 if (!notready) break;	
+				
+					 
+				}
+				fprintf(stderr, "\n");
+				uint32_t i;
+		if (verbose)
+		for (i = 0; i < 1024; i++)
+			fprintf(stderr, "%02x%c", membuf[i], i == 0 || i % 32 == 31 ? '\n' : ' ');
+			
+			
+
+	
+	
+}	
+ 
+
+
+
+void help(const char *progname)
+{
+
+	fprintf(stderr, "\n");
+	fprintf(stderr, "iceprog -- simple programming tool for Olinuxino Nano-based Lattice iCE programmers\n");
+	fprintf(stderr, "\n");
+	fprintf(stderr, "\n");
+	fprintf(stderr, "Usage: %s [options] <filename>\n", progname);
+	fprintf(stderr, "\n");
+	fprintf(stderr, "    -e\n");
+	fprintf(stderr, "        bulk erase entire flash only\n");
+	fprintf(stderr, "\n");	
+	fprintf(stderr, "    -w\n");
+	fprintf(stderr, "        write only, do not verify\n\n");
+	fprintf(stderr, "    -f\n");
+	fprintf(stderr, "        write all data, including 0xFF's pages\n\n");	
+	fprintf(stderr, "    -I<serialport>\n");
+	fprintf(stderr, "        port to connect Arduino (default /dev/ttyACM0)\n");	
+	fprintf(stderr, "\n");
+	fprintf(stderr, "    -r\n");
+	fprintf(stderr, "        read entire flash (2MB) and write to file\n");
+	fprintf(stderr, "\n");
+
+	 	
+	fprintf(stderr, "    -c\n");
+	fprintf(stderr, "        do not write flash, only verify (check)\n");
+	fprintf(stderr, "\n");
+	fprintf(stderr, "    -b\n");
+	fprintf(stderr, "        bulk erase entire flash before writing\n");
+	fprintf(stderr, "\n");
+	fprintf(stderr, "    -n\n");
+	fprintf(stderr, "        do not erase flash before writing\n");
+	fprintf(stderr, "\n");
+	fprintf(stderr, "    -o <offset in bytes>  start address for write [default: 0]\n");
+	fprintf(stderr, "                          (append 'k' to the argument for size in kilobytes,\n");
+	fprintf(stderr, "                          or 'M' for size in megabytes)\n");
+	fprintf(stderr, "                          this feature works not with all options.\n");
+	fprintf(stderr, "                          tested with -b, -v\n");
+	fprintf(stderr, "    -t\n");
+	fprintf(stderr, "        just read the flash ID sequence\n");
+	fprintf(stderr, "\n");
+	fprintf(stderr, "    -v\n");
+	fprintf(stderr, "        verbose output\n");
+	fprintf(stderr, "\n");
+	exit(1);
+}
+
+ 
+void serial_read(int x)
+{
+	
+	
+while (1)
+{
+	if (rxp>512)
+	{
+	newframe = 0;	
+	rxp = 0;
+	escaped = false;
+	fcs = 0;	
+	break;
+	}	 
+	usleep(5);
+   uint8_t buf[1];
+   		int n;
+ 
+   if (fd < 0)
+		{
+			printf(".");
+			break;
+		}
+	else
+		{
+        n=read(fd, buf, 1);
+		if (n==1){
+			
+	switch(buf[0]){
+		case FEND:
+		if (fcs==0xff)
+		{
+		newframe = 1;
+		return;
+		}
+		newframe = 0;	
+		rxp = 0;
+		escaped = false;
+		fcs = 0;
+        
+		break;
+		
+		case FESC:
+		escaped = true;
+		break;
+		
+		case TFESC:
+		if (escaped)
+		{
+		rxframe[rxp++]=FESC;
+		fcs+=FESC;
+		escaped = false;
+		}
+		else 
+		{
+		rxframe[rxp++]=TFESC;
+		fcs += TFESC;
+		}
+		
+		break;
+		
+		case TFEND:
+		if (escaped)
+		{
+		rxframe[rxp++]=FEND;
+		fcs += FEND;
+		escaped=false;
+		}
+		else
+		{
+		 rxframe[rxp++]=TFEND;
+		fcs += TFEND;
+		}
+		break;
+		
+		default:	
+		escaped=false;
+		rxframe[rxp++]=buf[0];
+		fcs+=buf[0];
+		break;
+	}	
+	}
+	else break;
+	}
+}	
+}
+ 
+int main(int argc, char **argv)
+{
+	int addr;
+	int max_read_size = 0x200000;
+	bool read_mode = false;
+	bool check_mode = false;
+	bool bulk_erase = false;
+	bool dont_erase = false;
+	bool prog_sram = false;
+	bool test_mode = false;
+ 
+	bool noverify = true; // verify performs by arduino board
+	bool ff_mode = false;
+	bool bulk_erase_only = false;
+	const char *filename = NULL;
+	const char *devstr = NULL;
+  int rw_offset = 0;
+
+	int opt;
+  char *endptr;
+
+ 		
+char *portname = SerialPort;
+	while ((opt = getopt(argc, argv, "I:o:rcbntvwfeh")) != -1)
+ 
+
+	{
+		switch (opt)
+		{
+		case 'd':
+			devstr = optarg;
+			break;
+
+ 			
+		case 'I':
+			portname = optarg;
+			break;
+ 			
+		case 'r':
+			read_mode = true;
+			noverify=false;
+			break;
+		case 'e':
+			bulk_erase_only = true;
+			break;			
+		case 'f':
+			ff_mode = true;
+			break;			
+		case 'R':
+			read_mode = true;
+			max_read_size = 256 * 1024;
+			break;
+		case 'c':
+			check_mode = true;
+			noverify=false;
+			break;
+		case 'b':
+			bulk_erase = true;
+			break;
+		case 'n':
+		
+			dont_erase = true;
+			break;
+		case 'S':
+			prog_sram = true;
+			break;
+		case 't':
+			test_mode = true;
+			printf("\nTest mode\n");
+			break;
+		case 'v':
+			verbose = true;
+			break;
+		case 'w':
+			noverify = true;
+			break;			
+    case 'o': /* set address offset */
+      rw_offset = strtol(optarg, &endptr, 0);
+      if (*endptr == '\0')
+        /* ok */;
+      else if (!strcmp(endptr, "k"))
+        rw_offset *= 1024;
+      else if (!strcmp(endptr, "M"))
+        rw_offset *= 1024 * 1024;
+      else {
+        fprintf(stderr, "'%s' is not a valid offset\n", optarg);
+        return EXIT_FAILURE;
+      }
+      break;
+    default:
+			help(argv[0]);
+		}
+	}
+
+
+
+
+	if (read_mode + check_mode + prog_sram + test_mode > 1)
+		help(argv[0]);
+
+	if (bulk_erase && dont_erase)
+		help(argv[0]);
+
+	if (optind+1 != argc && !test_mode && !bulk_erase_only)
+		help(argv[0]);
+
+	filename = argv[optind];
+	
+	//bulk_erase = true;  // comment this line if you do not want to bulk erase by default
+
+ 
+
+		   
+/* open serial port */
+ fd = open(portname, O_RDWR | O_NOCTTY);
+// fd = open(portname, O_RDWR | O_ASYNC | O_NDELAY);
+if (fd < 0)
+{
+        fprintf(stderr,"error %d opening %s: %s\n", errno, portname, strerror (errno));
+        return -1;
+}
+
+set_interface_attribs (fd, B57600, 0);  // set speed to 57600 bps, 8n1 (no parity)
+set_blocking (fd, 0);                // set no blocking
+
+
+
+    fprintf(stderr,"Serial: %s: %s\n",  portname, strerror (errno));
+ 
+
+
+	
+	rxp = 0;
+	
+	if (test_mode)
+	{
+ 
+		
+		flash_read_id();
+	
+	
+		
+
+ 
+	}
+	else if (prog_sram)
+	{
+		fprintf(stderr, "\nprogramming SRAM is not supported!\n");
+	}
+	else
+	{
+		
+		// ---------------------------------------------------------
+		// Program
+		// ---------------------------------------------------------
+
+		if (!read_mode && !check_mode && !bulk_erase_only)
+		{
+			
+			FILE *f = (strcmp(filename, "-") == 0) ? stdin :
+				fopen(filename, "r");
+			if (f == NULL) {
+				fprintf(stderr, "Error: Can't open '%s' for reading: %s\n", filename, strerror(errno));
+				error();
+							}
+
+			if (!dont_erase)
+			{
+				if (bulk_erase)
+				{
+				
+					flash_bulk_erase();
+				    sleep(1);
+				    flash_read_id();
+				    usleep(10000);
+				}
+				else
+				{
+					struct stat st_buf;
+					if (stat(filename, &st_buf)) {
+						fprintf(stderr, "Error: Can't stat '%s': %s\n", filename, strerror(errno));
+						error();
+					}
+
+          fprintf(stderr, "file size: %d\n", (int)st_buf.st_size);
+          /* 64 k */
+          int begin_addr = rw_offset & ~0xffff;
+          int end_addr = (rw_offset + st_buf.st_size + 0xffff) & ~0xffff;
+          for (addr = begin_addr; addr < end_addr; addr += 0x10000) {
+					
+						flash_64kB_sector_erase(addr);
+						
+					}
+				}
+			}
+
+			fprintf(stderr, "\nprogramming..\n");
+int ccc;	
+
+				flash_read_id();
+				
+				
+      /* page is 256 */
+      for (int rc, addr = 0; true; addr += rc) {
+        uint8_t buffer[256];
+        int page_size = 256 - (rw_offset + addr) % 256;
+        rc = fread(buffer, 1, page_size, f);
+
+        int offset_addr = addr + rw_offset;
+				if (rc <= 0) break;
+					if (verbose)
+					fprintf(stderr, "prog 0x%06X +0x%03X..\n", offset_addr, rc);
+					else
+					fprintf(stderr, "\rprog 0x%06X +0x%03X..", offset_addr, rc);
+				for (ccc=0;ccc<rc;ccc++){
+					if ((buffer[ccc] != 0xFF) || (ff_mode))
+						{
+						int x;
+						
+				
+						while(1){
+							
+						startframe(PROG);
+						addbyte(offset_addr>>16);
+						addbyte(offset_addr>>8);
+						for (x=0;x<rc;x++)
+							addbyte(buffer[x]);
+							
+							sendframe();
+							
+							//if (verbose)
+					       fprintf(stderr, ".");
+						
+						//usleep(1000);						
+						if (waitframe(READY)) break;
+						
+						}
+						break;
+					}	
+					}
+			
+			}
+			fprintf(stderr, "\n");
+ 
+
+			if (f != stdin)
+				fclose(f);
+		}
+
+        if (!noverify && !bulk_erase_only)
+        {
+		// ---------------------------------------------------------
+		// Read/Verify
+		// ---------------------------------------------------------
+
+		if (read_mode)
+		{
+			FILE *f = (strcmp(filename, "-") == 0) ? stdout :
+				fopen(filename, "w");
+			if (f == NULL) {
+				fprintf(stderr, "Error: Can't open '%s' for writing: %s\n", filename, strerror(errno));
+				error();
+			}
+
+			fprintf(stderr, "\nreading..\n");
+		
+			
+ 
+	 flash_read_id();
+     flash_read_all();
+				printf("\nWriting data to file %s\n",filename);
+				fwrite(membuf, 0x200000, 1, f);
+ 
+			if (f != stdout)
+				fclose(f);
+		}
+		else
+		{
+			FILE *f = (strcmp(filename, "-") == 0) ? stdin :
+				fopen(filename, "r");
+			if (f == NULL) {
+				fprintf(stderr, "Error: Can't open '%s' for reading: %s\n", filename, strerror(errno));
+				error();
+			}
+
+			fprintf(stderr, "\nreading..\n");
+ 
+				flash_read_id();
+			    flash_read_all();
+				uint8_t buffer_file[0x200000];
+				int rc = fread(buffer_file, 1, 0x200000, f);
+				
+				if (memcmp(buffer_file, membuf, rc)) 
+				{
+					fprintf(stderr, "Found difference between flash and file!\n");
+					error();
+				}
+
+
+ 				
+	
+			
+
+			fprintf(stderr, "\nVERIFY OK\n");
+
+			if (f != stdin)
+				fclose(f);
+		}
+	}
+	if (bulk_erase_only)
+				{
+ 
+
+					flash_bulk_erase();
+ 					
+					fprintf(stderr, "Flash erased!\n");
+				}
+		// ---------------------------------------------------------
+		// Reset
+		// ---------------------------------------------------------
+
+	}
+
+
+	// ---------------------------------------------------------
+	// Exit
+	// ---------------------------------------------------------
+
+	fprintf(stderr, "Bye.\n");
+
+ 
+
+				close(fd);
+ 
+	return 0;
+}
+
+