Commit: 874fa66c4dd785bb2daf39cfb2aa7068d9523656 - h8flash (git)

Commit MetaInfo

• Revisión: 874fa66c4dd785bb2daf39cfb2aa7068d9523656 (tree)
• Tiempo: 2015-04-19 21:28:32
• Autor: Yoshinori Sato <ysato@sa76...>
• Commiter: Yoshinori Sato

Log Message

RX64M protocol support

Cambiar Resumen

• modified: Makefile.am
• modified: comm.c
• add: comm2.c
• modified: h8flash.h
• modified: main.c
• modified: serial.c

Diferencia incremental

--- a/Makefile.am
+++ b/Makefile.am
@@ -1,3 +1,3 @@
 bin_PROGRAMS = h8flash
-h8flash_SOURCES = main.c comm.c serial.c usb.c
+h8flash_SOURCES = main.c comm.c comm2.c serial.c usb.c
 h8flash_LDADD = $(LIBOBJS)

--- a/comm.c
+++ b/comm.c
@@ -19,8 +19,69 @@
 #include <errno.h>
 #include "h8flash.h"
 
-#define TRY1COUNT 60
-#define BAUD_ADJUST_LEN 30
+#define ACK                  0x06
+
+#define QUERY_DEVICE         0x20
+#define QUERY_DEVICE_RES     0x30
+#define QUERY_CLOCKMODE      0x21
+#define QUERY_CLOCKMODE_RES  0x31
+#define QUERY_MULTIRATE      0x22
+#define QUERY_MULTIRATE_RES  0x32
+#define QUERY_FREQ           0x23
+#define QUERY_FREQ_RES       0x33
+#define QUERY_BOOT_AREA      0x24
+#define QUERY_BOOT_AREA_RES  0x34
+#define QUERY_USER_AREA      0x25
+#define QUERY_USER_AREA_RES  0x35
+#define QUERY_WRITESIZE      0x27
+#define QUERY_WRITESIZE_RES  0x37
+
+#define SELECT_DEVICE        0x10
+#define SET_CLOCKMODE        0x11
+
+#define SET_BITRATE          0x3f
+
+#define WRITEMODE            0x40
+#define WRITE_USERBOOT       0x42
+#define WRITE_USER           0x43
+#define BLANKCHECK_USERBOOT  0x4c
+#define BLANKCHECK_USER      0x4d
+#define WRITE                0x50
+
+struct devinfo_t {
+	char code[4];
+	char name[256];
+};
+
+struct devicelist_t {
+	int numdevs;
+	struct devinfo_t devs[0];
+};
+
+struct clockmode_t {
+	int nummode;
+	int mode[0];
+};
+
+struct multirate_t {
+	int numrate;
+	int rate[0];
+};
+
+struct multilist_t {
+	int nummulti;
+	struct multirate_t *muls[0];
+};
+
+struct freq_t {
+	int min;
+	int max;
+};
+
+struct freqlist_t {
+	int numfreq;
+	struct freq_t freq[0];
+};
 
 /* NAK answer list */
 const unsigned char naktable[] = {0x80, 0x90, 0x91, 0xbf, 0xc0, 0xc2, 0xc3, 0xc8,
@@ -107,7 +168,7 @@ static int receive(struct port_t *p, unsigned char *data)
 }
 
 /* get target device list */
-struct devicelist_t *get_devicelist(struct port_t *port)
+static struct devicelist_t *get_devicelist(struct port_t *port)
 {
 	unsigned char rxbuf[255+3];
 	unsigned char *devp;
@@ -139,7 +200,7 @@ struct devicelist_t *get_devicelist(struct port_t *port)
 }
 
 /* set target device ID */
-int select_device(struct port_t *port, const char *code)
+static int select_device(struct port_t *port, const char *code)
 {
 	unsigned char buf[6] = {SELECT_DEVICE, 0x04, 0x00, 0x00, 0x00, 0x00};
 	
@@ -151,7 +212,7 @@ int select_device(struct port_t *port, const char *code)
 }
 
 /* get target clock mode */
-struct clockmode_t *get_clockmode(struct port_t *port)
+static struct clockmode_t *get_clockmode(struct port_t *port)
 {
 	unsigned char rxbuf[255+3];
 	unsigned char *clkmdp;
@@ -183,7 +244,7 @@ struct clockmode_t *get_clockmode(struct port_t *port)
 }
 
 /* set target clock mode */
-int set_clockmode(struct port_t *port, int mode)
+static int set_clockmode(struct port_t *port, int mode)
 {
 	unsigned char buf[3] = {SET_CLOCKMODE, 0x01, 0x00};
 	
@@ -196,7 +257,7 @@ int set_clockmode(struct port_t *port, int mode)
 }
 
 /* get target multiplier/divider rate */
-struct multilist_t *get_multirate(struct port_t *port)
+static struct multilist_t *get_multirate(struct port_t *port)
 {
 	unsigned char rxbuf[255+3];
 	unsigned char *mulp;
@@ -242,7 +303,7 @@ struct multilist_t *get_multirate(struct port_t *port)
 }
 
 /* get target operation frequency list */
-struct freqlist_t *get_freqlist(struct port_t *port)
+static struct freqlist_t *get_freqlist(struct port_t *port)
 {
 	unsigned char rxbuf[255+3];
 	unsigned char *freqp;
@@ -273,13 +334,35 @@ struct freqlist_t *get_freqlist(struct port_t *port)
 }
 
 /* get target rom mapping */
-struct arealist_t *get_arealist(struct port_t *port, enum mat_t mat)
+/* get write page size */
+static int get_writesize(struct port_t *port)
+{
+	unsigned char rxbuf[5];
+	unsigned short size;
+
+	rxbuf[0] = QUERY_WRITESIZE;
+	send(port, rxbuf, 1);
+	if (receive(port, rxbuf) == -1)
+		return -1;
+	if (rxbuf[0] != QUERY_WRITESIZE_RES)
+		return -1;
+
+	if (rxbuf[1] != 2)
+		return -1;
+	size = rxbuf[2] << 8 | rxbuf[3];
+	return size;
+}
+
+static struct arealist_t *get_arealist(struct port_t *port, enum mat_t mat)
 {
 	char ans;
 	unsigned char rxbuf[255+3];
 	unsigned char *areap;
 	struct arealist_t *arealist;
 	int numarea;
+	int wsize;
+
+	wsize = get_writesize(port);
 
 	switch(mat) {
 	case user:
@@ -308,32 +391,20 @@ struct arealist_t *get_arealist(struct port_t *port, enum mat_t mat)
 	arealist->areas = numarea;
 	areap = &rxbuf[3];
 	for(numarea = 0; numarea < arealist->areas; numarea++) {
+		int size;
+
 		arealist->area[numarea].start = getlong(areap);
 		arealist->area[numarea].end   = getlong(areap+4);
+		arealist->area[numarea].size  = wsize;
 		areap += 8;
+		size = arealist->area[numarea].end - arealist->area[numarea].start;
+		if (!(arealist->area[numarea].image = malloc(size)))
+			return NULL;
+		memset(arealist->area[numarea].image, 0xff, size);
 	}
 	return arealist;
 }
 
-/* get write page size */
-int get_writesize(struct port_t *port)
-{
-	unsigned char rxbuf[5];
-	unsigned short size;
-
-	rxbuf[0] = QUERY_WRITESIZE;
-	send(port, rxbuf, 1);
-	if (receive(port, rxbuf) == -1)
-		return -1;
-	if (rxbuf[0] != QUERY_WRITESIZE_RES)
-		return -1;
-
-	if (rxbuf[1] != 2)
-		return -1;
-	size = rxbuf[2] << 8 | rxbuf[3];
-	return size;
-}
-
 /* bitrate candidate list */
 static const int rate_list[]={1152,576,384,192,96};
 
@@ -476,16 +547,12 @@ static int skipcheck(unsigned char *data, unsigned short size)
 }
 
 /* write rom image */
-int write_rom(struct port_t *port, const unsigned char *romimage, struct writeinfo_t *writeinfo)
+static int write_rom(struct port_t *port, struct arealist_t *arealist, enum mat_t mat)
 {
 	unsigned char *buf = NULL;
 	unsigned int romaddr;
-
-	buf = (unsigned char *)malloc(5 + writeinfo->size);
-	if (buf == NULL) {
-		perror("");
-		return 0;
-	}
+	int i;
+	struct area_t *area;
 
 	puts("Erase flash...");
 	/* enter writemode */
@@ -498,7 +565,7 @@ int write_rom(struct port_t *port, const unsigned char *romimage, struct writein
 	}
 
 	/* mat select */
-	switch (writeinfo->mat) {
+	switch (mat) {
 	case user:     
 		buf[0] = WRITE_USER;
 		break;
@@ -514,35 +581,47 @@ int write_rom(struct port_t *port, const unsigned char *romimage, struct writein
 	}
 
 	/* writing loop */
-	for (romaddr = writeinfo->area.start; 
-	     romaddr >= writeinfo->area.start && romaddr < writeinfo->area.end; 
-	     romaddr += writeinfo->size) {
-		if (skipcheck((unsigned char *)(romimage + romaddr - writeinfo->area.start), writeinfo->size))
-			continue;
-		/* set write data */
-		*(buf + 0) = WRITE;
-		setlong(buf + 1, romaddr);
-		if ((romaddr + writeinfo->size) < writeinfo->area.end) {
-			memcpy(buf + 5, romimage + romaddr - writeinfo->area.start, writeinfo->size);
-		} else {
-			/* lastpage  < writesize */
-			memcpy(buf + 5, romimage + romaddr - writeinfo->area.start, 
-			       (writeinfo->area.end - romaddr));
-			memset(buf + 5 + writeinfo->area.end - romaddr, 0xff, 
-			       writeinfo->size - (writeinfo->area.end - romaddr));
-		}
-		/* write */
-		send(port, buf, 5 + writeinfo->size);
-		if (receive(port, buf) != 1) {
-			fprintf(stderr, PROGNAME ": write data %08x failed.", romaddr);
-			goto error;
-		}
-		if (verbose)
-			printf("write - %08x\n",romaddr);
-		else {
-			printf("writing %d/%d byte\r", romaddr - writeinfo->area.start, 
-			       writeinfo->area.end  - writeinfo->area.start); 
-			fflush(stdout);
+	for (i = 0; i < arealist->areas; i++) {
+		area = &arealist->area[i];
+		for (romaddr = area->start; 
+		     romaddr < area->end; 
+		     romaddr += area->size) {
+			if (skipcheck(area->image + romaddr - area->start,
+				      area->size)) {
+				if (verbose)
+					printf("skip - %08x\n",romaddr);
+				else {
+					printf("writing %d/%d byte\r",
+					       romaddr - area->start, 
+					       area->end  - area->start); 
+					fflush(stdout);
+				}
+				continue;
+			}
+			buf = malloc(area->size + 5);
+			if (buf == NULL)
+				goto error;
+			/* set write data */
+			*(buf + 0) = WRITE;
+			setlong(buf + 1, romaddr);
+			memcpy(buf + 5,
+			       area->image + romaddr - area->start,
+			       area->size);
+			/* write */
+			send(port, buf, 5 + area->size);
+			free(buf);
+			if (receive(port, buf) != 1) {
+				fprintf(stderr, PROGNAME ": write data %08x failed.", romaddr);
+				goto error;
+			}
+			if (verbose)
+				printf("write - %08x\n",romaddr);
+			else {
+				printf("writing %d/%d byte\r",
+				       romaddr - area->start, 
+				       area->end  - area->start); 
+				fflush(stdout);
+			}
 		}
 	}
 	/* write finish */
@@ -553,20 +632,16 @@ int write_rom(struct port_t *port, const unsigned char *romimage, struct writein
 		fputs(PROGNAME ": writemode exit failed", stderr);
 		goto error;
 	}
-	free(buf);
 	if (!verbose)
-		printf("writing %d/%d byte\n", writeinfo->area.end  - writeinfo->area.start, 
-		       writeinfo->area.end - writeinfo->area.start); 
-
+		putc('\n', stdout);
 
 	return 1;
  error:
-	free(buf);
 	return 0;
 }
 
 /* connect to target chip */
-int setup_connection(struct port_t *p, int input_freq)
+static int setup_connection(struct port_t *p, int input_freq, char endian)
 {
 	int c;
 	int r = -1;
@@ -575,15 +650,6 @@ int setup_connection(struct port_t *p, int input_freq)
 	struct multilist_t  *multilist  = NULL;
 	struct freqlist_t   *freqlist   = NULL;
 
-	/* connect target */
-	if (!p->connect_target(p->dev)) {
-		if (errno != 0)
-			perror(PROGNAME);
-		else
-			fputs("target no response\n", stderr);
-		goto error;
-	}
-
 	/* query target infomation */
 	devicelist = get_devicelist(p);
 	if (devicelist == NULL) {
@@ -704,7 +770,7 @@ int setup_connection(struct port_t *p, int input_freq)
 }
 
 /* connect to target chip */
-void dump_configs(struct port_t *p)
+static void dump_configs(struct port_t *p)
 {
 	struct devicelist_t *devicelist = NULL;
 	struct clockmode_t  *clockmode  = NULL;
@@ -714,15 +780,6 @@ void dump_configs(struct port_t *p)
 	int clk;
 	int c1,c2;
 
-	/* connect target */
-	if (!p->connect_target(p->dev)) {
-		if (errno != 0)
-			perror(PROGNAME);
-		else
-			fputs("target no response\n", stderr);
-		goto error;
-	}
-
 	/* query target infomation */
 	devicelist = get_devicelist(p);
 	if (devicelist == NULL) {
@@ -795,4 +852,15 @@ error:
 	free(devicelist);
 	free(clockmode);
 }	
-			
+
+static struct comm_t v1 = {
+	.get_arealist = get_arealist,
+	.write_rom = write_rom,
+	.setup_connection = setup_connection,
+	.dump_configs = dump_configs,
+};
+
+struct comm_t *comm_v1(void)
+{
+	return &v1;
+}

--- /dev/null
+++ b/comm2.c
@@ -0,0 +1,488 @@
+/*
+ *  Renesas CPU On-chip Flash memory writer
+ *  target communication (New)
+ *
+ * Yoshinori Sato <[e-mail]>
+ *
+ * This file is subject to the terms and conditions of the GNU Lesser
+ * General Public License version 2.1 (or later).
+ */
+
+#include <stdio.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <string.h>
+#include <termios.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <stdint.h>
+#include "h8flash.h"
+
+#define TRY1COUNT 60
+#define BAUD_ADJUST_LEN 30
+
+#define SOH 0x01
+#define ETX 0x03
+#define ETB 0x17
+#define SOD 0x81
+
+/* big endian to cpu endian convert 32bit */
+static __inline__ int getlong(uint32_t *p)
+{
+	uint8_t *b = (uint8_t *)p;
+	return (*b << 24) | (*(b+1) << 16) | (*(b+2) << 8) | *(b+3);
+}
+	
+/* big endian to cpu endian convert 16bit */
+static __inline__ short getword(uint16_t *p)
+{
+	uint8_t *b = (uint8_t *)p;
+	return (*b << 8) | *(b+1);
+}
+
+/* cpu endian to big endian 32bit */
+static __inline__ void setlong(unsigned char *buf, unsigned long val)
+{
+	*(buf + 0) = (val >> 24) & 0xff;
+	*(buf + 1) = (val >> 16) & 0xff;
+	*(buf + 2) = (val >>  8) & 0xff;
+	*(buf + 3) = (val      ) & 0xff;
+}
+
+/* cpu endian to big endian 16bit */
+static __inline__ void setword(unsigned char *buf, unsigned short val)
+{
+	*(buf + 0) = (val >>  8) & 0xff;
+	*(buf + 1) = (val      ) & 0xff;
+}
+
+/* send multibyte command */
+static void send(struct port_t *p, unsigned char *data, int len,
+		 unsigned char head, unsigned char tail)
+{
+	unsigned char buf[2];
+	unsigned char sum;
+	
+	p->send_data(&head, 1);
+	setword(buf, len);
+	p->send_data(buf, 2);
+	p->send_data(data, len);
+	if (len > 0) {
+		for(sum = 0; len > 0; len--, data++)
+			sum += *data;
+	}
+	sum += buf[0];
+	sum += buf[1];
+	sum = 0x100 - sum;
+	p->send_data(&sum, 1);
+	p->send_data(&tail, 1);
+}
+
+/* receive answer */
+static unsigned int receive(struct port_t *p, unsigned char *data)
+{
+	int len;
+	unsigned char *rxptr;
+	unsigned char sum = 0;
+
+	rxptr = data;
+	/* Header */
+	for (len = 0; len < 3; len++) {
+		if (p->receive_byte(rxptr) != 1)
+			return -1;
+		rxptr++;
+	}
+
+	/* Res + Data */
+	len = getword((uint16_t *)(data + 1));
+	for(; len > 0; len--) {
+		if (p->receive_byte(rxptr) != 1)
+			return -1;
+		rxptr++;
+	}
+
+	/* SUM + ETX/ETB */
+	for (len = 0; len < 2; len++) {
+		if (p->receive_byte(rxptr) != 1)
+			return -1;
+		rxptr++;
+	}
+
+	/* sum check */
+	for (sum = 0, rxptr = data + 1, len = getword((uint16_t *)(data + 1)) + 3;
+	     len > 0; len--, rxptr++)
+		sum += *rxptr;
+	if (sum != 0)
+		return -1;
+	return *(data + 3);
+}
+
+struct raw_devtype_t {
+	uint8_t  sod;
+	uint16_t len;
+	uint8_t  res;
+	uint64_t typ;
+	uint32_t osa;
+	uint32_t osi;
+	uint32_t cpa;
+	uint32_t cpi;
+	uint8_t  sum;
+	uint8_t  etx;
+} __attribute__((packed,aligned(1)));
+
+struct devtype_t {
+	uint64_t typ;
+	uint32_t osa;
+	uint32_t osi;
+	uint32_t cpa;
+	uint32_t cpi;
+};
+
+/* get target device type */
+static  int get_devtype(struct port_t *port, struct devtype_t *type)
+{
+	struct raw_devtype_t raw_type;
+	unsigned char cmd[] = {0x38};
+
+	send(port, cmd, 1, SOH, ETX);
+	if (receive(port, (unsigned char *)&raw_type) == -1)
+		return -1;
+	send(port, cmd, 1, SOD, ETX);
+       	if (receive(port, (unsigned char *)&raw_type) == -1)
+		return -1;
+	if (raw_type.res != 0x38)
+		return -1;
+	type->typ = raw_type.typ;
+	type->osa = getlong(&raw_type.osa);
+	type->osi = getlong(&raw_type.osi);
+	type->cpa = getlong(&raw_type.cpa);
+	type->cpi = getlong(&raw_type.cpi);
+	return 0;
+}
+
+/* set endian */
+static int set_endian(struct port_t *port, unsigned int endian)
+{
+	unsigned char cmd[2] = {0x36, 0x00};
+	unsigned char rcv[8];
+
+	cmd[1] = endian;
+	send(port, cmd, 2, SOH, ETX);
+	return receive(port, rcv);
+}
+
+struct raw_freq_t {
+	uint8_t  sod;
+	uint16_t len;
+	uint8_t  res;
+	uint32_t fq;
+	uint32_t pf;
+	uint8_t  sum;
+	uint8_t  etx;
+} __attribute__((packed,aligned(1)));
+
+/* set frequency */
+static int set_frequency(struct port_t *port, unsigned int input, unsigned int system)
+{
+	unsigned char cmd[] = {0x32, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+	struct raw_freq_t freq;
+	unsigned int core, peripheral;
+	setlong(cmd + 1, input);
+	setlong(cmd + 5, system);
+	send(port, cmd, sizeof(cmd), SOH, ETX);
+	if (receive(port, (unsigned char *)&freq) == -1)
+		return -1;
+	send(port, cmd, 1, SOD, ETX);
+       	if (receive(port, (unsigned char *)&freq) == -1)
+		return -1;
+	core = getlong(&freq.fq);
+	peripheral = getlong(&freq.pf);
+	VERBOSE_PRINT("Core %dHz / Pereipheral %dHz\n", core, peripheral);
+	return peripheral;
+}
+
+/* bitrate candidate list */
+static const int rate_list[]={115200,57600,38400,19200,9600};
+
+/* bitrate error margine (%) */
+#define ERR_MARGIN 4
+
+/* select communication bitrate */
+static int adjust_bitrate(int p_freq)
+{
+ 	int brr;
+	int errorrate;
+	int rate_no;
+
+	for (rate_no = 0; rate_no < sizeof(rate_list) / sizeof(int); rate_no++) {
+		brr = p_freq / (32 * rate_list[rate_no]) - 2;
+		errorrate = abs(p_freq / ((brr + 1) * rate_list[rate_no] * 32));
+		if (errorrate <= ERR_MARGIN)
+			return rate_list[rate_no];
+	}
+	return 0;
+}
+
+/* set target bitrate */
+static int set_bitrate(struct port_t *p, int bitrate)
+{
+	unsigned char cmd[] = {0x34, 0x00, 0x00, 0x00, 0x00};
+	unsigned char rcv[6];
+	setlong(cmd + 1, bitrate);
+	send(p, cmd, sizeof(cmd), SOH, ETX);
+	if (receive(p, rcv) != 0x34)
+		return 0;
+
+	if (p->setbaud) {
+		if (!p->setbaud(bitrate / 100))
+			return 0;
+
+	}
+	usleep(10000);
+	return 1;
+}
+
+#define C_MULNO 0
+#define P_MULNO 1
+#define C_FREQNO 0
+#define P_FREQNO 1
+
+/* change communicate bitrate */
+static int change_bitrate(struct port_t *p, int peripheral_freq)
+{
+	int rate;
+
+
+	/* select bitrate from peripheral cock*/
+	rate = adjust_bitrate(peripheral_freq);
+	if (rate == 0)
+		return 0;
+
+	VERBOSE_PRINT("bitrate %d bps\n",rate);
+
+	/* setup host/target bitrate */
+	return set_bitrate(p, rate);
+}
+
+static int syncro(struct port_t *p)
+{
+	unsigned char cmd[] = {0x00};
+	unsigned char rcv[6];
+	send(p, cmd, sizeof(cmd), SOH, ETX);
+	return receive(p, rcv) == 0x00;
+}
+
+struct raw_signature_t {
+	uint8_t  sod;
+	uint16_t len;
+	uint8_t  res;
+	uint8_t  dev[16];
+	struct {
+		uint8_t  type;
+		uint32_t size;
+		uint16_t num;
+	} __attribute__((packed,aligned(1))) bank[6] ;
+        uint8_t  sum;
+	uint8_t  etx;
+} __attribute__((packed,aligned(1)));
+
+/* get target rom mapping */
+static struct arealist_t *get_arealist(struct port_t *p, enum mat_t mat)
+{
+	unsigned char cmd[] = {0x3a};
+	struct raw_signature_t raw_sig;
+	unsigned int id[] = {0x00, 0x02};
+	int numarea;
+	int i;
+	unsigned int addr = 0;
+	struct arealist_t *arealist;
+
+	send(p, cmd, 1, SOH, ETX);
+	if (receive(p, (unsigned char *)&raw_sig) < 0)
+		return NULL;
+	send(p, cmd, 1, SOD, ETX);
+	if (receive(p, (unsigned char *)&raw_sig) < 0)
+		return NULL;
+	
+	/* lookup area */
+	for(numarea = 0, i = 0; i < 6; i++) {
+		if (raw_sig.bank[i].type == id[mat])
+			numarea += getword(&raw_sig.bank[i].num);
+	}
+	arealist = (struct arealist_t *)malloc(sizeof(struct arealist_t) + 
+                                               sizeof(struct area_t) * numarea);
+	if (arealist == NULL)
+		return NULL;
+
+	arealist->areas = numarea;
+	/* setup area list*/
+	for(numarea = 0, i = 0; i < 6; i++) {
+		if (raw_sig.bank[i].type == id[mat]) {
+			unsigned int sz;
+			int j;
+			sz = getlong(&raw_sig.bank[i].size);
+			for(j = 0; j < getword(&raw_sig.bank[i].num); j++) {
+				arealist->area[numarea].start = addr - sz;
+				arealist->area[numarea].end = addr - 1;
+				arealist->area[numarea].size = sz;
+				if (!(arealist->area[numarea].image = malloc(sz)))
+					return NULL;
+				memset(arealist->area[numarea].image, 0xff, arealist->area[numarea].size);
+				addr -= sz;
+				numarea++;
+			}
+		}
+	}
+	return arealist;
+}
+
+/* check blank page */
+static int skipcheck(unsigned char *data, unsigned short size)
+{
+	unsigned char r = 0xff;
+	int c;
+	for (c = 0; c < size; c++)
+		r &= *data++;
+	return (r == 0xff);
+}
+
+/* write rom image */
+static int write_rom(struct port_t *port, struct arealist_t *arealist, enum mat_t mat)
+{
+	uint8_t erase[] = {0x12, 0x00, 0x00, 0x00, 0x00};
+	uint8_t write[] = {0x13, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+	uint8_t data[257];
+	unsigned char rcv[8];
+	unsigned int wsize, total;
+	int i, j, r;
+	struct area_t *area;
+	for (total = 0, i = 0; i < arealist->areas; i++) {
+		total += arealist->area[i].size;
+	}
+	/* writing loop */
+	for (wsize = 0, i = 0; i < arealist->areas; i++) {
+		area = &arealist->area[i];
+		if (skipcheck(area->image, area->size)) {
+			wsize += area->size;
+			if (verbose)
+				printf("skip - %08x\n",area->start);
+			else {
+				printf("writing %d/%d byte\r",
+				       wsize, 
+				       total); 
+				fflush(stdout);
+			}
+			continue;
+		}
+		setlong(erase + 1, area->start);
+		send(port, erase, sizeof(erase), SOH, ETX);
+		if ((r=receive(port, rcv)) > 0x80) {
+			return -1;
+		}
+		setlong(write + 1, area->start);
+		setlong(write + 5, area->end);
+		send(port, write, sizeof(write), SOH, ETX);
+		if (receive(port, rcv) > 0x80)
+			return -1;
+		for(j = 0; j < area->size / 256; j++) {
+			data[0] = 0x13;
+			memcpy(&data[1],
+			       area->image + j * (sizeof(data) - 1),
+			       sizeof(data) -1);
+			if (j < (area->size / 256 -1))
+				send(port, data, sizeof(data), SOD, ETB);
+			else
+				send(port, data, sizeof(data), SOD, ETX);
+			if ((r = receive(port, rcv)) > 0x80) {
+				return -1;
+			}
+		}
+		wsize += area->size;
+		if (verbose)
+			printf("write - %08x\n", area->start);
+		else {
+			printf("writing %d/%d byte\r",
+			       wsize, 
+			       total); 
+			fflush(stdout);
+		}
+	}
+	if (!verbose)
+		putc('\n', stdout);
+
+	return 0;
+}
+
+/* connect to target chip */
+static int setup_connection(struct port_t *p, int input_freq, char endian)
+{
+	struct devtype_t dt;
+	int e = -1;
+	int pf;
+
+	input_freq *= 10000;
+	if(get_devtype(p, &dt) < 0) {
+		fputs("device type failed", stderr);
+		return -1;
+	}
+	switch(toupper(endian)) {
+	case 'L':
+		e = 1;
+		break;
+	case 'B':
+		e = 0;
+		break;
+	}
+	if (e == -1 || set_endian(p, e) < 0) {
+		fputs("endian setup failed", stderr);
+		return -1;
+	}
+
+	pf = set_frequency(p, input_freq, dt.cpa);
+	if (pf < 0) {
+		fputs("frequency setup failed", stderr);
+		return -1;
+	}
+		
+	/* set writeing bitrate */
+	if (!change_bitrate(p, pf)) {
+		fputs("set bitrate failed\n",stderr);
+		return -1;
+	}
+
+	if (!syncro(p)) {
+		fputs("sync failed\n",stderr);
+		return -1;
+	}
+
+	return 0;
+}
+
+static void dump_configs(struct port_t *p)
+{
+	struct devtype_t dt;
+
+	if(get_devtype(p, &dt) < 0) {
+		fputs("device type failed", stderr);
+		return;
+	}
+	printf("type code: %016llx\n", dt.typ);
+	printf("input max: %dHz\n", dt.osa);
+	printf("input min: %dHz\n", dt.osi);
+	printf("sys max: %dHz\n", dt.cpa);
+	printf("sys min: %dHz\n", dt.cpi);
+}	
+
+static struct comm_t v2 = {
+	.get_arealist = get_arealist,
+	.write_rom = write_rom,
+	.setup_connection = setup_connection,
+	.dump_configs = dump_configs,
+};
+
+struct comm_t *comm_v2(void)
+{
+	return &v2;
+}

--- a/h8flash.h
+++ b/h8flash.h
@@ -31,75 +31,13 @@
 #define PROGNAME "h8flash"
 #define VERBOSE_PRINT(...) do { if (verbose) printf(__VA_ARGS__); } while(0)
 
-#define ACK                  0x06
-
-#define QUERY_DEVICE         0x20
-#define QUERY_DEVICE_RES     0x30
-#define QUERY_CLOCKMODE      0x21
-#define QUERY_CLOCKMODE_RES  0x31
-#define QUERY_MULTIRATE      0x22
-#define QUERY_MULTIRATE_RES  0x32
-#define QUERY_FREQ           0x23
-#define QUERY_FREQ_RES       0x33
-#define QUERY_BOOT_AREA      0x24
-#define QUERY_BOOT_AREA_RES  0x34
-#define QUERY_USER_AREA      0x25
-#define QUERY_USER_AREA_RES  0x35
-#define QUERY_WRITESIZE      0x27
-#define QUERY_WRITESIZE_RES  0x37
-
-#define SELECT_DEVICE        0x10
-#define SET_CLOCKMODE        0x11
-
-#define SET_BITRATE          0x3f
-
-#define WRITEMODE            0x40
-#define WRITE_USERBOOT       0x42
-#define WRITE_USER           0x43
-#define BLANKCHECK_USERBOOT  0x4c
-#define BLANKCHECK_USER      0x4d
-#define WRITE                0x50
-
 enum mat_t {user, userboot};
 
-struct devinfo_t {
-	char code[4];
-	char name[256];
-};
-
-struct devicelist_t {
-	int numdevs;
-	struct devinfo_t devs[0];
-};
-
-struct clockmode_t {
-	int nummode;
-	int mode[0];
-};
-
-struct multirate_t {
-	int numrate;
-	int rate[0];
-};
-
-struct multilist_t {
-	int nummulti;
-	struct multirate_t *muls[0];
-};
-
-struct freq_t {
-	int min;
-	int max;
-};
-
-struct freqlist_t {
-	int numfreq;
-	struct freq_t freq[0];
-};
-
 struct area_t {
 	unsigned int start;
 	unsigned int end;
+	int size;
+	char *image;
 };
 
 struct arealist_t {
@@ -107,12 +45,6 @@ struct arealist_t {
 	struct area_t area[0];
 };
 
-struct writeinfo_t {
-	enum mat_t mat;
-	struct area_t area;
-	int size;
-};
-
 enum port_type {serial, usb};
 
 struct port_t {
@@ -125,19 +57,17 @@ struct port_t {
 	void (*close)(void);
 };
 
+struct comm_t {
+	struct arealist_t *(*get_arealist)(struct port_t *port, enum mat_t mat);
+	int (*write_rom)(struct port_t *port, struct arealist_t *arealist,
+			 enum mat_t mat);
+	int (*setup_connection)(struct port_t *port, int input_freq, char endian);
+	void (*dump_configs)(struct port_t *p);
+};
+
 struct port_t *open_serial(char *portname);
 struct port_t *open_usb(unsigned short vid, unsigned short pid);
-struct devicelist_t *get_devicelist(struct port_t *port);
-struct clockmode_t *get_clockmode(struct port_t *port);
-struct multilist_t *get_multirate(struct port_t *port);
-struct freqlist_t *get_freqlist(struct port_t *port);
-struct arealist_t *get_arealist(struct port_t *port, enum mat_t mat);
-int get_writesize(struct port_t *port);
-int select_device(struct port_t *port, const char *code);
-int set_clockmode(struct port_t *port, int mode);
-int write_rom(struct port_t *port, const unsigned char *romimage, 
-	      struct writeinfo_t *writeinfo);
-int setup_connection(struct port_t *port, int input_freq);
-void dump_configs(struct port_t *p);
+struct comm_t *comm_v1();
+struct comm_t *comm_v2();
 
 extern int verbose;

--- a/main.c
+++ b/main.c
@@ -38,6 +38,7 @@ const static struct option long_options[] = {
 	{"binary", no_argument, NULL, 'b'},
 	{"verbose", no_argument, NULL, 'V'},
 	{"list", no_argument, NULL, 'l'},
+	{"endian", required_argument, NULL, 'e'},
 	{0, 0, 0, 0}
 };
 
@@ -47,40 +48,59 @@ static void usage(void)
 	     "[-b][--userboot][-l][-V] filename");
 }
 
+static struct area_t *lookup_area(struct arealist_t *arealist,
+				  unsigned int addr)
+{
+	int i;
+	for (i = 0; i < arealist->areas; i++) {
+		if (arealist->area[i].start <= addr &&
+		    arealist->area[i].end >= addr)
+			return &arealist->area[i];
+	}
+	return NULL;
+}
+
 /* read raw binary */
-static int write_binary(FILE *fp, struct writeinfo_t *writeinfo,
-			struct port_t *p)
+static int write_binary(FILE *fp, struct comm_t *com,
+			struct port_t *p, struct arealist_t *arealist,
+			enum mat_t mat)
 {
 	int fno;
 	struct stat bin_st;
-	unsigned char *bin_buf;
-	unsigned long bin_len;
+	size_t bin_len, len;
+	unsigned int addr;
+	struct area_t *area;
 
 	fno = fileno(fp);
 
 	fstat(fno, &bin_st);
 	bin_len = bin_st.st_size;
-
-	if ((bin_buf = (unsigned char *)mmap(NULL, bin_len, PROT_READ,
-					     MAP_SHARED, fno, 0)) == MAP_FAILED)
-		goto error_perror;
-	writeinfo->area.end = bin_len - 1;
-	if (!write_rom(p, bin_buf, writeinfo))
+	addr = arealist->area[0].start;
+
+	while(bin_len > 0) {
+		area = lookup_area(arealist, addr);
+		len = bin_len < (area->end - area->start)?
+			bin_len:(area->end - area->start);
+		if (len > read(area->image, len, fno))
+			goto error_perror;
+		bin_len -= len;
+		addr += len;
+	}
+	if (!com->write_rom(p, arealist, mat))
 		goto error;
-	munmap(bin_buf, bin_len);
 	fclose(fp);
 	return bin_len;
  error_perror:
 	perror(PROGNAME);
  error:	
-	if (bin_buf)
-		munmap(bin_buf, bin_len);
 	fclose(fp);
 	return 0;
 }
 
 /* read srec binary */
-static int write_srec(FILE *fp, struct writeinfo_t *writeinfo, struct port_t *p)
+static int write_srec(FILE *fp, struct comm_t *com,
+		      struct port_t *p, struct arealist_t *arealist,
+		      enum mat_t mat)
 {
 	unsigned char *romimage = NULL;
 	unsigned char *bufp;
@@ -95,15 +115,7 @@ static int write_srec(FILE *fp, struct writeinfo_t *writeinfo, struct port_t *p)
 	const static int address_len[]={0,4,6,8,0,0,0,8,6,4};
 	int r = 0;
 	int l;
-	unsigned int romsize;
-
-	romsize = writeinfo->area.end - writeinfo->area.start + 1;
-	romimage = (unsigned char *)malloc(romsize);
-	if (!romimage) {
-		perror(PROGNAME);
-		goto error;
-	}
-	memset(romimage, 0xff, romsize);
+	struct area_t *area;
 
 	while (fgets(linebuf, sizeof(linebuf), fp)) {
 		/* check valid Srecord */
@@ -132,16 +144,12 @@ static int write_srec(FILE *fp, struct writeinfo_t *writeinfo, struct port_t *p)
 			sum += strtoul(hexbuf, NULL, 16);
 		}
 
-		/* area check */
-		if (addr < writeinfo->area.start || 
-		    (addr + len - 1) > writeinfo->area.end) {
-			fprintf(stderr,
-				"srec address %08x is out of rom\n", addr);
+		area = lookup_area(arealist, addr);
+		if (area == NULL) {
+			fprintf(stderr, "%08x is out of ROM.", addr);
 			goto error;
 		}
-		bufp = romimage + addr - writeinfo->area.start;
-		if (last_addr < (addr + len - 1))
-			last_addr = (addr + len - 1);
+		bufp = area->image + addr - area->start;
 
 		/* parse body */
 		for (; len > 1; --len, lp += 2, buff_size++) {
@@ -163,36 +171,29 @@ static int write_srec(FILE *fp, struct writeinfo_t *writeinfo, struct port_t *p)
 			goto error;
 		}
 	}
-	writeinfo->area.end = last_addr;
-	r = write_rom(p, romimage, writeinfo);
+	r = com->write_rom(p, arealist, mat);
  error:
-	free(romimage);
 	fclose(fp);
 	return r;
 }
 
 #ifdef HAVE_GELF_H
-static int write_elf(FILE *fp, struct writeinfo_t *writeinfo,
-			 struct port_t *p)
+static int write_elf(FILE *fp, struct comm_t *com,
+		     struct port_t *p, struct arealist_t *arealist,
+		     enum mat_t mat)
 {
 	unsigned char *romimage = NULL;
 	unsigned int romsize;
 	int fd;
 	size_t n;
-	int i;
+	int i,j;
 	Elf *elf = NULL;
 	GElf_Phdr phdr;
-	unsigned long last_addr = 0;
+	unsigned long top, last_addr = 0;
 	int ret = -1;
-	size_t sz;
-
-	romsize = writeinfo->area.end - writeinfo->area.start + 1;
-	romimage = (unsigned char *)malloc(romsize);
-	if (!romimage) {
-		perror(PROGNAME);
-		goto error;
-	}
-	memset(romimage, 0xff, romsize);
+	size_t sz, remain;
+	struct area_t *area;
+	
 	elf_version(EV_CURRENT);
 	fd = fileno(fp);
 	elf = elf_begin(fd, ELF_C_READ, NULL);
@@ -219,37 +220,42 @@ static int write_elf(FILE *fp, struct writeinfo_t *writeinfo,
 		}
 		if (phdr.p_filesz == 0)
 			continue ;
-		if (phdr.p_paddr < writeinfo->area.start ||
-		    (phdr.p_paddr + phdr.p_filesz) > writeinfo->area.end) {
-			fprintf(stderr, "%08lx - %08lx is out of rom\n",
-				(unsigned long)phdr.p_paddr,
-				(unsigned long)(phdr.p_paddr + phdr.p_filesz));
-			goto error;
-		}
 		lseek(fd, phdr.p_offset, SEEK_SET);
-		sz = read(fd, romimage + (phdr.p_paddr - writeinfo->area.start),
-			  phdr.p_filesz);
-		if (sz != phdr.p_filesz) {
-			fputs("File read error", stderr);
-			goto error;
+		remain = phdr.p_filesz;
+		top = phdr.p_paddr;
+		while(remain > 0) {
+			area = lookup_area(arealist, top);
+			if (area == NULL) {
+				fprintf(stderr, "%08x - %08x is out of ROM",
+					top, top + remain);
+				goto error;
+			}
+			j = remain < (area->end - area->start)?
+				remain:(area->size);
+			sz = read(fd, area->image + top - area->start, j);
+			if (sz != j) {
+				perror(PROGNAME);
+				goto error;
+			}
+			remain -= j;
+			top += j;
 		}
-		if (last_addr < (phdr.p_paddr + phdr.p_filesz))
-			last_addr = phdr.p_paddr + phdr.p_filesz;
 	}
-	writeinfo->area.end = last_addr;
-	ret = write_rom(p, romimage, writeinfo);
+	ret = com->write_rom(p, arealist, mat);
 error:
 	if (elf)
 		elf_end(elf);
 	fclose(fp);
-	free(romimage);
 	return ret;
 }		
 #endif
 
 /* read rom writing data */
-static int writefile_to_rom(char *fn, int force_binary, struct writeinfo_t *writeinfo, 
-			    struct port_t *port)
+static int writefile_to_rom(char *fn, int force_binary,
+			    struct comm_t *com,
+			    struct port_t *port,
+			    struct arealist_t *arealist,
+			    enum mat_t mat)
 {
 	FILE *fp = NULL;
 	static char linebuf[SREC_MAXLEN + 1];
@@ -276,13 +282,13 @@ static int writefile_to_rom(char *fn, int force_binary, struct writeinfo_t *writ
 #ifdef HAVE_GELF_H
 	/* check ELF */
 	if (!force_binary && memcmp(linebuf, ELFMAG, SELFMAG) == 0)
-		return write_elf(fp, writeinfo, port);
+		return write_elf(fp, com, port, arealist, mat);
 #endif
 	/* check 'S??' */
 	if (force_binary ||
 	    linebuf[0] != 'S' ||
 	    isdigit(linebuf[1]) == 0)
-		return write_binary(fp, writeinfo, port);
+		return write_binary(fp, com, port, arealist, mat);
 
 	/* check body (calcurate checksum) */
 	memcpy(hexbuf, &linebuf[2], 2);
@@ -293,53 +299,43 @@ static int writefile_to_rom(char *fn, int force_binary, struct writeinfo_t *writ
 	}
 	if ((sum & 0xff) == 0xff)
 		/* checksum ok is Srecord format */
-		return write_srec(fp, writeinfo, port);
+		return write_srec(fp, com, port, arealist, mat);
 	else
-		return write_binary(fp, writeinfo, port);
+		return write_binary(fp, com, port, arealist, mat);
 }
 
 /* get target rommap */
-static int get_rominfo(struct port_t *port, struct writeinfo_t *writeinfo)
+static struct arealist_t *get_rominfo(struct comm_t *com, struct port_t *port,
+				    enum mat_t mat)
 {
 	struct arealist_t *arealist = NULL;
 	int c;
 	
 	/* get target rommap list */
-	arealist = get_arealist(port, writeinfo->mat);
+	arealist = com->get_arealist(port, mat);
 	if (arealist == NULL) {
 		if (errno != 0)
 			perror(PROGNAME);
 		else
-			fputs("area list error\n",stderr);
-		return 0;
+			fputs("area list error\n", stderr);
+		return NULL;
 	}
 	if (verbose) {
 		printf("area map\n");
 		for (c = 0; c < arealist->areas; c++)
-			printf("%08x - %08x\n", arealist->area[c].start, 
-                                                  arealist->area[c].end); 
+			printf("%08x - %08x %08xbyte\n",
+			       arealist->area[c].start, 
+			       arealist->area[c].end,
+			       arealist->area[c].size); 
 	}
 
 	/* check write area info */
-	if (arealist->areas < SELAREA) {
+	if (arealist->areas < 0) {
 		fputs("illigal areamap\n", stderr);
 		free(arealist);
-		return 0;
+		return NULL;
 	}
-	writeinfo->area = arealist->area[SELAREA];
-	free(arealist);
-
-	/* get writeing size */
-	writeinfo->size = get_writesize(port);
-	if (writeinfo->size < 0) {
-		if (errno != 0)
-			perror(PROGNAME);
-		else
-			fputs("writesize error\n", stderr);
-		return 0;
-	}
-	VERBOSE_PRINT("writesize %d byte\n", writeinfo->size);
-	return 1;
+	return arealist;
 }
 
 static int get_freq_num(const char *arg)
@@ -372,24 +368,22 @@ int main(int argc, char *argv[])
 	char port[FILENAME_MAX] = DEFAULT_SERIAL;
 	int c;
 	int long_index;
-	int input_freq;
-	int force_binary;
-	int config_list;
+	int input_freq = 0;
+	int force_binary = 0;
+	int config_list = 0;
 	int r;
-	struct writeinfo_t writeinfo;
 	struct port_t *p = NULL;
-
-	writeinfo.mat = user;
-	force_binary = 0;
-	input_freq = 0;
-	config_list = 0;
+	struct comm_t *com = NULL;
+	struct arealist_t *arealist;
+	enum mat_t mat = user;
+	char endian='l';
 
 	/* parse argment */
-	while ((c = getopt_long(argc, argv, "p:f:bVl", 
+	while ((c = getopt_long(argc, argv, "p:f:bVle:", 
 				long_options, &long_index)) >= 0) {
 		switch (c) {
 		case 'u':
-			writeinfo.mat = userboot;
+			mat = userboot;
 			break ;
 		case 'p':
 			strncpy(port, optarg, sizeof(port));
@@ -407,6 +401,13 @@ int main(int argc, char *argv[])
 		case 'l':
 			config_list = 1;
 			break;
+		case 'e':
+			endian = optarg[0];
+			if (endian != 'l' && endian !='b') {
+				usage();
+				return 1;
+			}
+			break;
 		case '?':
 			usage();
 			return 1;
@@ -438,25 +439,38 @@ int main(int argc, char *argv[])
 	if (p == NULL)
 		goto error;
 
+	switch (p->connect_target(port)) {
+	case 0xff:
+		r = -1;
+		goto error;
+	case 0xe6:
+		VERBOSE_PRINT("Detect old protocol\n");
+		com = comm_v1();
+		break;
+	case 0xc1:
+		VERBOSE_PRINT("Detect new protocol\n");
+		com = comm_v2();
+		break;
+	default:
+		fputs("unknown_target", stderr);
+		goto error;
+	}
+
 	if (config_list) {
-		dump_configs(p);
+		com->dump_configs(p);
 		p->close();
 		return 0;
 	}
 
-	if (setup_connection(p, input_freq) < 0)
+	if (com->setup_connection(p, input_freq, endian) < 0)
 		goto error;
 	puts("Connect target");
 
-	if (!get_rominfo(p, &writeinfo))
+	if (!(arealist = get_rominfo(com, p, mat)))
 		goto error;
 		
-	if (writefile_to_rom(argv[optind], force_binary, 
-						&writeinfo, p)) {
-		VERBOSE_PRINT("write %08x - %08x ", writeinfo.area.start, 
-			      writeinfo.area.end);
-		r = 0;
-	}
+	r = writefile_to_rom(argv[optind], force_binary, 
+			     com, p, arealist, mat);
  error:
 	puts((r==0)?"done":"write failed");
 	if (p)

--- a/serial.c
+++ b/serial.c
@@ -44,12 +44,12 @@ static int receive_byte(unsigned char *data)
 	fd_set fdset;
 
 	*data = 0;
-	tv.tv_sec = 60;
+	tv.tv_sec = 10;
 	tv.tv_usec = 0;
 	FD_ZERO(&fdset);
 	FD_SET(ser_fd, &fdset);
 	r = select(ser_fd + 1, &fdset, NULL, NULL, &tv);
-	if (r == -1)
+	if (r < 1)
 		return -1;
 	return read(ser_fd, data, 1);
 }
@@ -110,15 +110,16 @@ static int connect_target(char *port)
 		}
 	}
 	putchar('\n');
-	return 0;
- connect:
+	return 0xff;
+connect:
+	putchar('\n');
 	/* connect done */
 	buf[0] = 0x55;
 	write(ser_fd, buf, 1);
-	if ((receive_byte(buf) == 1) && (buf[0] == 0xe6))
-		return 1; /* ok */
+	if (receive_byte(buf) == 1)
+		return buf[0]; /* ok */
 	else
-		return 0; /* ng */
+		return 0xff; /* ng */
 }
 
 static void port_close(void)