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; }