value
guestfs_int_mllib_progress_bar_init (value machine_readablev)
{
CAMLparam1 (machine_readablev);
CAMLlocal1 (barv);
struct progress_bar *bar;
const int machine_readable = Bool_val (machine_readablev);
unsigned flags = 0;
/* XXX Have to do this to get nl_langinfo to work properly. However
* we should really only call this from main.
*/
setlocale (LC_ALL, "");
if (machine_readable)
flags |= PROGRESS_BAR_MACHINE_READABLE;
bar = progress_bar_init (flags);
if (bar == NULL)
caml_raise_out_of_memory ();
barv = caml_alloc_custom (&progress_bar_custom_operations,
sizeof (struct progress_bar *), 0, 1);
Bar_val (barv) = bar;
CAMLreturn (barv);
}
NETX_CONSOLEAPP_RESULT_T parflash_read(const CMD_PARAMETER_READ_T *ptParameter)
{
NETX_CONSOLEAPP_RESULT_T tResult;
const FLASH_DEVICE_T *ptFlashDescription;
unsigned long ulStartAdr;
unsigned long ulEndAdr;
unsigned char *pucDataStartAdr;
CADR_T tSrc;
ADR_T tDst;
CADR_T tSrcEnd;
unsigned long ulProgressBarPosition;
ptFlashDescription = &(ptParameter->ptDeviceDescription->uInfo.tParFlash);
ulStartAdr = ptParameter->ulStartAdr;
ulEndAdr = ptParameter->ulEndAdr;
pucDataStartAdr = ptParameter->pucData;
tResult = NETX_CONSOLEAPP_RESULT_OK;
uprintf("#Reading from flash...\n");
progress_bar_init(ulEndAdr-ulStartAdr);
ulProgressBarPosition = 0;
/* Get the source start address. */
tSrc.puc = ptFlashDescription->pucFlashBase;
tSrc.puc += ulStartAdr;
/* Get the source end address. */
tSrcEnd.puc = ptFlashDescription->pucFlashBase;
tSrcEnd.puc += ulEndAdr;
/* Get the dest address */
tDst.puc = (unsigned char*) pucDataStartAdr;
/* Loop over the complete area. */
while( tSrc.puc<tSrcEnd.puc )
{
*tDst.puc++ = *tSrc.puc++;
++ulProgressBarPosition;
/* Show progress every 64K bytes. */
if( (ulProgressBarPosition&0xffff)==0 )
{
progress_bar_set_position(ulProgressBarPosition);
}
}
progress_bar_finalize();
uprintf(". done\n");
return tResult;
}
char *funrle_data_to(const u8 *data, ssize_t size, int fd_out)
{
int ret;
const u8 *data_end;
u8 tmp;
char buff[MAX_BUFFER_LEN];
char *p, *end_p;
struct progress_bar prg_bar;
progress_bar_init(&prg_bar, size);
p = buff;
end_p = buff + sizeof(buff);
for (data_end = data + size; data < data_end; data += 2)
{
tmp = *data;
println("tmp = %d", tmp);
while (p + tmp >= end_p)
{
memset(p, data[1], end_p - p);
ret = ffile_writeto(fd_out, buff, MAX_BUFFER_LEN, 0);
if (ret < 0)
{
error_msg("write file failed");
return NULL;
}
tmp -= end_p - p;
p = buff;
}
memset(p, data[1], tmp);
p += tmp;
progress_bar_add(&prg_bar, 2);
}
progress_bar_finish(&prg_bar);
if (p > buff)
{
ret = ffile_writeto(fd_out, buff, p - buff, 0);
if (ret < 0)
{
error_msg("write file failed");
return NULL;
}
}
return (char *) data;
}
char *frle_data_to(const u8 *data, ssize_t size, int fd_out)
{
int ret;
const u8 *data_end = data + size;
u8 tmp;
u8 buff[MAX_BUFFER_LEN];
const u8 *p;
u8 *q, *end_q;
struct progress_bar prg_bar;
q = buff;
end_q = buff + sizeof(buff) - 1;
progress_bar_init(&prg_bar, size);
while (data < data_end)
{
for (p = data, tmp = *p; tmp == *p && p < data_end; p++);
if (q >= end_q)
{
ret = ffile_writeto(fd_out, buff, q - buff, 0);
if (ret < 0)
{
error_msg("write file failed");
return NULL;
}
q = buff;
}
*q++ = p - data;
*q++ = tmp;
progress_bar_add(&prg_bar, p - data);
data = p;
}
progress_bar_finish(&prg_bar);
if (q > buff)
{
ret = ffile_writeto(fd_out, buff, q - buff, 0);
if (ret < 0)
{
error_msg("write file failed");
return NULL;
}
}
return (char *) data;
}
/* return value:
NETX_CONSOLEAPP_RESULT_OK: equal,
NETX_CONSOLEAPP_RESULT_ERROR: not equal
*/
static NETX_CONSOLEAPP_RESULT_T parflash_compare(const FLASH_DEVICE_T *ptFlashDescription, unsigned long ulStartAdr, unsigned long ulEndAdr, const unsigned char* pucDataStartAdr)
{
/* src/srcEnd point to Flash; dst, points to RAM */
CADR_T tSrc;
CADR_T tDst;
CADR_T tSrcEnd;
unsigned long ulProgressBarPosition;
uprintf("# Verifying...\n");
/* Get the source start address. */
tSrc.puc = ptFlashDescription->pucFlashBase;
tSrc.puc += ulStartAdr;
/* Get the source end address. */
tSrcEnd.puc = ptFlashDescription->pucFlashBase;
tSrcEnd.puc += ulEndAdr;
/* Get the dest address */
tDst.puc = (const unsigned char*) pucDataStartAdr;
progress_bar_init(ulEndAdr-ulStartAdr);
ulProgressBarPosition = 0;
/* Loop over the complete area. */
while( tSrc.puc<tSrcEnd.puc )
{
if (*tDst.puc != *tSrc.puc)
{
uprintf("! verify error at address 0x%08x. buffer: 0x%02x, flash: 0x%02x.\n", tSrc.ul, *tDst.puc, *tSrc.puc);
return NETX_CONSOLEAPP_RESULT_ERROR;
}
++tDst.puc;
++tSrc.puc;
++ulProgressBarPosition;
/* Show progress every 64K bytes. */
if( (ulProgressBarPosition&0xffff)==0 )
{
progress_bar_set_position(ulProgressBarPosition);
}
}
progress_bar_finalize();
uprintf(". verify ok\n");
return NETX_CONSOLEAPP_RESULT_OK;
}
NETX_CONSOLEAPP_RESULT_T parflash_sha1(const CMD_PARAMETER_CHECKSUM_T *ptParameter, SHA_CTX *ptSha1Context)
{
NETX_CONSOLEAPP_RESULT_T tResult;
const FLASH_DEVICE_T *ptFlashDescription;
unsigned long ulStartAdr;
unsigned long ulEndAdr;
unsigned long ulOffset;
unsigned long ulBlockSize;
const void *pvFlashAddr;
ptFlashDescription = &(ptParameter->ptDeviceDescription->uInfo.tParFlash);
ulStartAdr = ptParameter->ulStartAdr;
ulEndAdr = ptParameter->ulEndAdr;
tResult = NETX_CONSOLEAPP_RESULT_OK;
uprintf("# Calculating checksum...\n");
ulOffset = 0;
progress_bar_init(ulEndAdr-ulStartAdr);
while (ulOffset < ulEndAdr - ulStartAdr)
{
ulBlockSize = ulEndAdr - ulStartAdr - ulOffset;
if (ulBlockSize > 0x10000)
{
ulBlockSize = 0x10000;
}
pvFlashAddr = (const void*)(ptFlashDescription->pucFlashBase + ulStartAdr + ulOffset);
SHA1_Update(ptSha1Context, pvFlashAddr, ulBlockSize);
ulOffset += ulBlockSize;
progress_bar_set_position(ulOffset);
}
uprintf(". hash done\n");
return tResult;
}
int cftp_server_send_file(struct cftp_descriptor *desc, const char *filename, u32 offset, size_t size)
{
int fd;
int ret;
union cftp_message *msg;
struct cftp_data_package *data_pkg;
ssize_t recvlen, sendlen, readlen;
u16 blk_num;
struct progress_bar bar;
size_t max_xfer_length, max_data_length;
struct stat st;
max_xfer_length = desc->max_xfer_length;
max_data_length = max_xfer_length - sizeof(msg->data_pkg);
msg = malloc(max_xfer_length);
if (msg == NULL) {
pr_err_info("malloc");
return -ENOMEM;
}
fd = open(filename, O_RDONLY);
if (fd < 0) {
pr_err_info("open file %s faild", filename);
cftp_send_error_message(desc, (struct cftp_error_message *) msg, "open file %s faild", filename);
ret = fd;
goto out_free_msg;
}
ret = fstat(fd, &st);
if (ret < 0) {
pr_err_info("fstat");
cftp_send_error_message(desc, (struct cftp_error_message *) msg, "fstat");
goto out_close_file;
}
if (offset) {
ret = lseek(fd, offset, SEEK_SET);
if (ret < 0) {
pr_err_info("lseek");
cftp_send_error_message(desc, (struct cftp_error_message *) msg, "seek file %s faild", filename);
goto out_close_file;
}
}
if (size == 0) {
size = st.st_size - offset;
}
data_pkg = malloc(max_xfer_length);
if (data_pkg == NULL) {
pr_err_info("malloc");
cftp_send_error_message(desc, (struct cftp_error_message *) msg, "malloc");
ret = -ENOMEM;
goto out_close_file;
}
println("filename = %s", filename);
println("offset = %s", size2text(offset));
println("size = %s", size2text(size));
blk_num = 0;
data_pkg->type = CFTP_PACKAGE_DATA;
progress_bar_init(&bar, size, 0, PROGRESS_BAR_TYPE_DATA);
while (1) {
readlen = read(fd, data_pkg->data, max_data_length);
if (readlen < 0) {
pr_err_info("read file failed");
cftp_send_error_message(desc, (struct cftp_error_message *) msg, "read file failed");
ret = readlen;
goto out_free_data_pkg;
}
data_pkg->blk_num = blk_num++;
label_send_data:
sendlen = cftp_send_data_retry(desc, data_pkg, sizeof(*data_pkg) + readlen, desc->retry_count);
if (sendlen < 0) {
pr_err_info("cftp_send_ack_message");
ret = sendlen;
goto out_free_data_pkg;
}
recvlen = cftp_receive_data(desc, msg, max_xfer_length);
if (recvlen < 0) {
pr_err_info("cftp_receive_data");
cftp_send_error_message(desc, (struct cftp_error_message *) msg, "receive file failed");
ret = recvlen;
goto out_free_data_pkg;
}
switch (msg->type) {
case CFTP_PACKAGE_ERROR:
show_error_message((struct cftp_error_message *) msg);
ret = -EFAULT;
goto out_free_data_pkg;
case CFTP_PACKAGE_ACK:
if (msg->ack_msg.blk_num != blk_num) {
pr_warn_info("blk_num %d != %d", msg->ack_msg.blk_num, blk_num);
goto label_send_data;
}
if ((size_t) readlen < max_data_length) {
progress_bar_finish(&bar);
println("Send data complete");
ret = 0;
goto out_free_data_pkg;
}
progress_bar_add(&bar, max_data_length);
break;
default:
pr_err_info("invalid package type");
cftp_send_error_message(desc, (struct cftp_error_message *) msg, "invalid package type");
ret = -EINVAL;
goto out_free_data_pkg;
}
}
out_free_data_pkg:
free(data_pkg);
out_close_file:
close(fd);
out_free_msg:
free(msg);
return ret;
}
int cftp_server_receive_file(struct cftp_descriptor *desc, const char *filename, mode_t mode, u32 offset, size_t size)
{
int fd;
int ret;
union cftp_message *msg;
ssize_t recvlen, sendlen;
u16 blk_num;
struct progress_bar bar;
size_t max_xfer_length;
max_xfer_length = desc->max_xfer_length;
msg = malloc(max_xfer_length);
if (msg == NULL) {
pr_err_info("malloc");
return -ENOMEM;
}
fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, mode);
if (fd < 0) {
pr_err_info("open file %s faild", filename);
cftp_send_error_message(desc, (struct cftp_error_message *) msg, "open file %s faild", filename);
ret = fd;
goto out_free_msg;
}
if (offset) {
ret = lseek(fd, offset, SEEK_SET);
if (ret < 0) {
pr_err_info("lseek");
cftp_send_error_message(desc, (struct cftp_error_message *) msg, "seek file %s faild", filename);
goto out_free_msg;
}
}
println("offset = %s", size2text(offset));
println("size = %s", size2text(size));
blk_num = 0;
progress_bar_init(&bar, size, 0, PROGRESS_BAR_TYPE_DATA);
while (1) {
sendlen = cftp_send_ack_message(desc, (struct cftp_ack_message *) msg, blk_num, desc->retry_count);
if (sendlen < 0) {
pr_err_info("cftp_send_ack_message");
ret = sendlen;
goto out_close_file;
}
recvlen = cftp_receive_data(desc, msg, max_xfer_length);
if (recvlen < 0) {
pr_err_info("cftp_receive_data");
cftp_send_error_message(desc, (struct cftp_error_message *) msg, "receive file failed");
ret = recvlen;
goto out_close_file;
}
switch (msg->type) {
case CFTP_PACKAGE_ERROR:
show_error_message((struct cftp_error_message *) msg);
ret = -EFAULT;
goto out_close_file;
case CFTP_PACKAGE_DATA:
if (msg->data_pkg.blk_num != blk_num) {
pr_warn_info("blk_num %d != %d", msg->data_pkg.blk_num, blk_num);
continue;
}
sendlen = write(fd, msg->data_pkg.data, recvlen - sizeof(msg->data_pkg));
if (sendlen < 0) {
pr_err_info("write");
cftp_send_error_message(desc, (struct cftp_error_message *) msg, "write file failed");
ret = sendlen;
goto out_close_file;
}
blk_num++;
if ((size_t) recvlen < max_xfer_length) {
cftp_send_ack_message(desc, (struct cftp_ack_message *) msg, blk_num, 0);
progress_bar_finish(&bar);
println("Receive data complete");
ret = 0;
goto out_close_file;
} else {
progress_bar_add(&bar, sendlen);
}
break;
default:
pr_err_info("invalid package type");
cftp_send_error_message(desc, (struct cftp_error_message *) msg, "invalid package type");
ret = -EINVAL;
goto out_close_file;
}
}
out_close_file:
close(fd);
out_free_msg:
free(msg);
return ret;
}
int cftp_client_send_file(struct cftp_descriptor *desc, const char *file_in, u32 offset_in, const char *file_out, u32 offset_out, size_t size)
{
int fd;
int ret;
struct stat st;
ssize_t recvlen, sendlen, readlen;
u16 blk_num;
union cftp_message *msg;
struct cftp_data_package *data_msg;
size_t max_xfer_length, max_data_length;
struct progress_bar bar;
ret = file_lstat(file_in, &st);
if (ret < 0) {
pr_err_info("fstat");
return ret;
}
max_xfer_length = desc->max_xfer_length;
msg = malloc(max_xfer_length);
if (msg == NULL) {
pr_err_info("malloc");
return -ENOMEM;
}
switch (st.st_mode & S_IFMT) {
case S_IFREG:
println("Send File: %s => %s", file_in, file_out);
break;
case S_IFBLK:
case S_IFCHR:
println("Send Devicce: %s => %s", file_in, file_out);
return cftp_client_send_special_file(desc, &st, &msg->file_req, text_copy(msg->file_req.filename, file_out) - msg->file_req.filename + 1);
case S_IFLNK:
println("Send Symlink: %s => %s", file_in, file_out); {
char *p;
p = text_copy(msg->file_req.filename, file_out) + 1;
ret = readlink(file_in, p, 1024);
if (ret < 0) {
pr_err_info("readlink");
return ret;
}
return cftp_client_send_special_file(desc, &st, &msg->file_req, p - msg->file_req.filename + ret + 1);
}
case S_IFDIR:
println("Send Directory: %s => %s", file_in, file_out);
ret = cftp_client_send_special_file(desc, &st, &msg->file_req, text_copy(msg->file_req.filename, file_out) - msg->file_req.filename + 1);
if (ret < 0) {
pr_err_info("cftp_client_send_special_file");
return ret;
}
return cftp_client_send_directory(desc, file_in, file_out);
default:
pr_warn_info("File %s type is unknown", file_in);
return 0;
}
fd = open(file_in, O_RDONLY);
if (fd < 0) {
pr_err_info("open file %s failed", file_in);
goto out_free_msg;
}
if (offset_in) {
ret = lseek(fd, offset_in, SEEK_SET);
if (ret < 0) {
pr_err_info("lseek");
goto out_close_file;
}
}
if (size == 0) {
size = st.st_size - offset_in;
}
data_msg = malloc(max_xfer_length);
if (data_msg == NULL) {
pr_err_info("malloc");
ret = -ENOMEM;
goto out_close_file;
}
sendlen = cftp_send_file_reuest(desc, (void *) msg, file_out, &st, offset_out, size, 0);
if (sendlen < 0) {
ret = sendlen;
pr_err_info("cftp_send_data_retry");
goto out_free_data_msg;
}
println("seek = %s", size2text(offset_out));
println("skip = %s", size2text(offset_in));
println("size = %s", size2text(size));
blk_num = 0;
data_msg->type = CFTP_PACKAGE_DATA;
max_data_length = max_xfer_length - sizeof(*data_msg);
progress_bar_init(&bar, size, 0, PROGRESS_BAR_TYPE_DATA);
readlen = max_data_length;
while (1) {
recvlen = cftp_receive_data(desc, msg, max_xfer_length);
if (recvlen < 0) {
pr_err_info("cftp_receive_data");
ret = recvlen;
goto out_free_data_msg;
}
switch (msg->type) {
case CFTP_PACKAGE_ERROR:
show_error_message((struct cftp_error_message *) msg);
ret = -EFAULT;
goto out_free_data_msg;
case CFTP_PACKAGE_ACK:
if (msg->ack_msg.blk_num == blk_num) {
if ((size_t) readlen < max_data_length) {
ret = 0;
progress_bar_finish(&bar);
println("Send data complete");
goto out_free_data_msg;
}
readlen = read(fd, data_msg->data, max_data_length);
if (readlen < 0) {
pr_err_info("read");
cftp_send_error_message(desc, (struct cftp_error_message *) msg, "read file failed");
ret = readlen;
goto out_free_data_msg;
}
data_msg->blk_num = blk_num++;
progress_bar_add(&bar, readlen);
} else {
pr_warn_info("%d != %d", msg->ack_msg.blk_num, blk_num);
if (blk_num == 0) {
continue;
}
}
sendlen = cftp_send_data_retry(desc, data_msg, sizeof(*data_msg) + readlen, desc->retry_count);
if (sendlen < 0) {
pr_err_info("cftp_send_data_retry");
goto out_free_data_msg;
}
break;
default:
pr_err_info("invalid package type");
cftp_send_error_message(desc, (struct cftp_error_message *) msg, "invalid package type");
ret = -EINVAL;
goto out_free_data_msg;
}
}
out_free_data_msg:
free(data_msg);
out_close_file:
close(fd);
out_free_msg:
free(msg);
return ret;
}
void
screen_init(struct mpdclient *c)
{
if (COLS < SCREEN_MIN_COLS || LINES < SCREEN_MIN_ROWS) {
fprintf(stderr, "%s\n", _("Error: Screen too small"));
exit(EXIT_FAILURE);
}
screen.cols = COLS;
screen.rows = LINES;
screen.buf = g_malloc(screen.cols);
screen.buf_size = screen.cols;
screen.findbuf = NULL;
#ifndef NCMPC_MINI
if (options.welcome_screen_list)
screen.welcome_source_id =
g_timeout_add(SCREEN_WELCOME_TIME * 1000,
welcome_timer_callback, c);
#endif
/* create top window */
title_bar_init(&screen.title_bar, screen.cols, 0, 0);
/* create main window */
window_init(&screen.main_window, screen.rows - 4, screen.cols, 2, 0);
if (!options.hardware_cursor)
leaveok(screen.main_window.w, TRUE);
keypad(screen.main_window.w, TRUE);
/* create progress window */
progress_bar_init(&screen.progress_bar, screen.cols,
screen.rows - 2, 0);
progress_bar_paint(&screen.progress_bar);
/* create status window */
status_bar_init(&screen.status_bar, screen.cols, screen.rows - 1, 0);
status_bar_paint(&screen.status_bar, c->status, c->song);
#ifdef ENABLE_COLORS
if (options.enable_colors) {
/* set background attributes */
wbkgd(stdscr, COLOR_PAIR(COLOR_LIST));
wbkgd(screen.main_window.w, COLOR_PAIR(COLOR_LIST));
wbkgd(screen.title_bar.window.w, COLOR_PAIR(COLOR_TITLE));
wbkgd(screen.progress_bar.window.w,
COLOR_PAIR(COLOR_PROGRESSBAR));
wbkgd(screen.status_bar.window.w, COLOR_PAIR(COLOR_STATUS));
colors_use(screen.progress_bar.window.w, COLOR_PROGRESSBAR);
}
#endif
doupdate();
/* initialize screens */
screen_list_init(screen.main_window.w,
screen.main_window.cols, screen.main_window.rows);
if (mode_fn->open != NULL)
mode_fn->open(c);
}
NETX_CONSOLEAPP_RESULT_T parflash_erase(const CMD_PARAMETER_ERASE_T *ptParameter)
{
NETX_CONSOLEAPP_RESULT_T tResult;
unsigned long ulEraseStartAdr;
unsigned long ulEraseEndAdr;
unsigned long ulProgressBarPosition;
const FLASH_DEVICE_T *ptFlashDescription;
const SECTOR_INFO_T *ptSectors;
FLASH_ERRORS_E tFlashError;
size_t sizCnt;
ulEraseStartAdr = ptParameter->ulStartAdr;
ulEraseEndAdr = ptParameter->ulEndAdr;
ptFlashDescription = &(ptParameter->ptDeviceDescription->uInfo.tParFlash);
tResult = NETX_CONSOLEAPP_RESULT_OK;
/* Split the data by erase sectors. */
sizCnt = cfi_find_matching_sector_index(ptFlashDescription, ulEraseStartAdr);
if( sizCnt==0xffffffffU )
{
uprintf("! Can not find sector in table!\n");
tResult = NETX_CONSOLEAPP_RESULT_ERROR;
}
if (tResult == NETX_CONSOLEAPP_RESULT_OK)
{
tResult = parflash_unlock(ptFlashDescription);
}
if (tResult == NETX_CONSOLEAPP_RESULT_OK)
{
uprintf("#Erasing...\n");
progress_bar_init(ulEraseEndAdr - ulEraseStartAdr);
ulProgressBarPosition = 0;
ptSectors = ptFlashDescription->atSectors;
do
{
DEBUGMSG(ZONE_VERBOSE, (". Erasing sector %d: [0x%08x, 0x%08x[\n",
sizCnt, ptSectors[sizCnt].ulOffset,ptSectors[sizCnt].ulOffset+ptSectors[sizCnt].ulSize));
tFlashError = ptFlashDescription->tFlashFunctions.pfnErase(ptFlashDescription, sizCnt);
if( tFlashError!=eFLASH_NO_ERROR )
{
/* failed to erase the sector */
uprintf(". failed to erase flash sector %d\n", sizCnt);
tResult = NETX_CONSOLEAPP_RESULT_ERROR;
break;
}
/* Show progress */
ulProgressBarPosition += ptSectors[sizCnt].ulSize;
progress_bar_set_position(ulProgressBarPosition);
/* Next sector. */
++sizCnt;
} while( sizCnt<ptFlashDescription->ulSectorCnt && ptSectors[sizCnt].ulOffset<ulEraseEndAdr );
uprintf(". Erase complete.\n");
progress_bar_finalize();
}
return tResult;
}
NETX_CONSOLEAPP_RESULT_T parflash_flash(const CMD_PARAMETER_FLASH_T *ptParameter)
{
NETX_CONSOLEAPP_RESULT_T tResult;
const unsigned char *pucDataStartAdr;
unsigned long ulFlashStartAdr;
unsigned long ulDataByteSize;
unsigned long ulProgressBarPosition;
const FLASH_DEVICE_T *ptFlashDescription;
const SECTOR_INFO_T *ptSector;
unsigned long ulSectorOffset;
unsigned long ulChunkSize;
FLASH_ERRORS_E tFlashError;
ulFlashStartAdr = ptParameter->ulStartAdr;
ulDataByteSize = ptParameter->ulDataByteSize;
pucDataStartAdr = ptParameter->pucData;
ptFlashDescription = &(ptParameter->ptDeviceDescription->uInfo.tParFlash);
tResult = parflash_unlock(ptFlashDescription);
if (tResult == NETX_CONSOLEAPP_RESULT_OK)
{
uprintf("#Writing...\n");
progress_bar_init(ulDataByteSize);
ulProgressBarPosition = 0;
while( ulDataByteSize!=0 )
{
/* Split the data by erase sectors. */
ptSector = cfi_find_matching_sector(ptFlashDescription, ulFlashStartAdr);
if( ptSector==NULL )
{
uprintf("Can not find sector in table!\n");
tResult = NETX_CONSOLEAPP_RESULT_ERROR;
break;
}
ulSectorOffset = ulFlashStartAdr - ptSector->ulOffset;
ulChunkSize = ptSector->ulSize - ulSectorOffset;
if( ulChunkSize>ulDataByteSize )
{
ulChunkSize = ulDataByteSize;
}
DEBUGMSG(ZONE_VERBOSE, ("Flashing [0x%08x, 0x%08x[\n", ulFlashStartAdr, ulFlashStartAdr+ulChunkSize));
tFlashError = ptFlashDescription->tFlashFunctions.pfnProgram(ptFlashDescription, ulFlashStartAdr, ulChunkSize, pucDataStartAdr);
if( tFlashError!=eFLASH_NO_ERROR )
{
/* failed to program the sector */
uprintf("Failed to program flash sector!\n");
/* showPflashError(tFlashError); */
tResult = NETX_CONSOLEAPP_RESULT_ERROR;
break;
}
ulFlashStartAdr += ulChunkSize;
pucDataStartAdr += ulChunkSize;
ulDataByteSize -= ulChunkSize;
ulProgressBarPosition += ulChunkSize;
progress_bar_set_position(ulProgressBarPosition);
}
progress_bar_finalize();
}
if (tResult == NETX_CONSOLEAPP_RESULT_OK)
{
ulFlashStartAdr = ptParameter->ulStartAdr;
ulDataByteSize = ptParameter->ulDataByteSize;
pucDataStartAdr = ptParameter->pucData;
tResult = parflash_compare(ptFlashDescription, ulFlashStartAdr, ulFlashStartAdr + ulDataByteSize, pucDataStartAdr);
}
return tResult;
}
NETX_CONSOLEAPP_RESULT_T parflash_isErased(const CMD_PARAMETER_ISERASED_T *ptParameter, NETX_CONSOLEAPP_PARAMETER_T *ptConsoleParams)
{
NETX_CONSOLEAPP_RESULT_T tResult;
const FLASH_DEVICE_T *ptFlashDescription;
unsigned long ulStartAdr;
unsigned long ulEndAdr;
ADR_T tCnt;
ADR_T tEnd;
unsigned long ulProgressBarPosition;
unsigned long ulErased;
ptFlashDescription = &(ptParameter->ptDeviceDescription->uInfo.tParFlash);
ulStartAdr = ptParameter->ulStartAdr;
ulEndAdr = ptParameter->ulEndAdr;
tResult = NETX_CONSOLEAPP_RESULT_OK;
uprintf("# Checking if empty...\n");
progress_bar_init(ulEndAdr-ulStartAdr);
/* Get the start address. */
tCnt.puc = ptFlashDescription->pucFlashBase;
tCnt.puc += ulStartAdr;
/* Get the end address. */
tEnd.puc = ptFlashDescription->pucFlashBase;
tEnd.puc += ulEndAdr;
/* Loop over the complete area. */
ulErased = 0xffU;
while( tCnt.puc<tEnd.puc )
{
ulErased &= *(tCnt.puc++);
if( ulErased!=0xff )
{
break;
}
/* Show progress every 64K bytes. */
if( (tCnt.ul&0xffff)==0 )
{
ulProgressBarPosition = (unsigned long)(tCnt.puc - ptFlashDescription->pucFlashBase);
ulProgressBarPosition -= ulStartAdr;
progress_bar_set_position(ulProgressBarPosition);
}
}
progress_bar_finalize();
if( ulErased==0xff )
{
uprintf(". CLEAN! The area is erased.\n");
}
else
{
uprintf(". DIRTY! The area is not erased.\n");
}
ptConsoleParams->pvReturnMessage = (void*)ulErased;
return tResult;
}
