dnw-linux-v1.01.tar.gz

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

const char* dev = “/dev/secbulk0“;
#define BLOCK_SIZE	（1*1024*1024）

struct download_buffer {
	uint32_t	load_addr;  /* load address */
	uint32_t	size; /* data size */
	uint8_t		data[0];
	/* uint16_t checksum; */
};

static int _download_buffer（struct download_buffer *buf）
{
	int fd_dev = open（dev O_WRONLY）;
	if（ -1 == fd_dev） {
		printf（“Can not open %s: %s\n“ dev strerror（errno））;
		return -1;
	}

	printf（“Writing data...\n“）;
	size_t remain_size = buf->size;
	size_t block_size = BLOCK_SIZE;
	size_t writed = 0;
	while（remain_size>0） {
		size_t to_write = remain_size > block_size ? block_size : remain_size;
		if（ to_write != write（fd_dev （unsigned char*）buf + writed to_write）） {
			perror（“write failed“）;
			close（fd_dev）;
			return -1;
		}
		remain_size -= to_write;
		writed += to_write;
		printf（“\r%02zu%%\t0x%08zX bytes （%zu K）“
			（size_t）（（uint64_t）writed*100/（buf->size））
			writed
			writed/1024）;
		fflush（stdout）;
	}
	printf（“\n“）;
	close（fd_dev）;
	return 0;
}

static inline void cal_and_set_checksum（struct download_buffer *buf）
{
	uint16_t sum = 0;
	int i;

	for（i = 0; i < buf->size; i++） {
		sum += buf->data[i];
	}
	*（（uint16_t*）（&（（uint8_t*）buf）[buf->size - 2]）） = sum;
}

static struct download_buffer* alloc_buffer（size_t data_size）
{
	struct download_buffer	*buffer = NULL;
	size_t total_size = data_size + sizeof（struct download_buffer） + 2;

	buffer = （typeof（buffer））malloc（total_size）;
	if（NULL == buffer）
		return NULL;
	buffer->size = total_size;
	return buffer;
}

static void free_buffer（struct download_buffer *buf）
{
	free（buf）;
}

static struct download_buffer *load_file（const char *path unsigned long load_addr）
{
	struct stat		file_stat;
	struct download_buffer	*buffer = NULL;
	unsigned long		total_size;
	int			fd;

	fd = open（path O_RDONLY）;
	if（-1 == fd） {
		printf（“Can not open file %s: %s\n“ path strerror（errno））;
		return NULL;
	}

	if（ -1 == fstat（fd &file_stat） ） {
		perror（“Get file size filed!\n“）;
		goto error;
	}	

	buffer = alloc_buffer（file_stat.st_size）;
	if（NULL == buffer） {
		perror（“malloc failed!\n“）;
		goto error;
	}
	if（ file_stat.st_size !=  read（fd buffer->data file_stat.st_size）） {
		perror（“Read file failed!\n“）;
		goto error;
	}

	buffer->load_addr = load_addr;
	cal_and_set_checksum（buffer）;

	return buffer;

error:
	if（fd != -1）
		close（fd）;
	if（ NULL != buffer ）
		free（buffer）;
	return NULL;
}

static int download_file（const char *path unsigned long load_addr）
{
	struct download_buffer *buffer;
	struct timeval __start __end;
	long __time_val = 0;
	float speed = 0.0;

	buffer = load_file（path load_addr）;
	gettimeofday（&__startNULL）;
	if （buffer != NULL） {
		if （_download_buffer（buffer） == 0） {
			gettimeofday（&__endNULL）;
			__time_val = （long）（__end.tv_usec - __s