Revert "Merging code for reading additional file data from info block section."

This reverts commit 8afd8db, reversing
changes made to c7da983.

Reverting changes from pull-request #62.
Issues found in frame size while flashing.

Author: mgong98

src/libmaxtouch/config.c

@@ -507,32 +507,17 @@ static int mxt_load_xcfg_file(struct libmaxtouch_ctx *ctx, const char *filename,
 
     ignore_line = false;
 
-    /* Extract the info and checksums */
+    /* Extract the checksum */
     if (!strcmp(object, "VERSION_INFO_HEADER")) {
       while (false == ignore_line) {
         if (fscanf(fp, "%s", tmp) != 1) {
           mxt_err(ctx, "Version info header parse error");
           ret = MXT_ERROR_FILE_FORMAT;
           goto close;
         }
-        if (!strncmp(tmp, "FAMILY_ID", 9)) {
-          sscanf(tmp, "%[^'=']=%hhu", object, &cfg->id.family);
-          mxt_dbg(ctx, "Family ID from file: %s", tmp);
-        } else if (!strncmp(tmp, "VARIANT", 7)) {
-          sscanf(tmp, "%[^'=']=%hhu", object, &cfg->id.variant);
-          mxt_dbg(ctx, "Variant from file: %s", tmp);
-        } else if (!strncmp(tmp, "VERSION", 7)) {
-          sscanf(tmp, "%[^'=']=%hhu", object, &cfg->id.version);
-          mxt_dbg(ctx, "Version from file: %s", tmp);
-        } else if (!strncmp(tmp, "BUILD", 5)) {
-          sscanf(tmp, "%[^'=']=%hhu", object, &cfg->id.build);
-          mxt_dbg(ctx, "Build from file: %s", tmp);
-        } else if (!strncmp(tmp, "CHECKSUM", 8)) {
+        if (!strncmp(tmp, "CHECKSUM", 8)) {
           sscanf(tmp, "%[^'=']=%x", object, &cfg->config_crc);
           mxt_dbg(ctx, "Config CRC from file: %s", tmp);
-        } else if (!strncmp(tmp, "INFO_BLOCK_CHECKSUM", 19)) {
-          sscanf(tmp, "%[^'=']=%x", object, &cfg->info_crc);
-          mxt_dbg(ctx, "Info CRC from file: %s", tmp);
           ignore_line = true;
         }
       }
@@ -889,31 +874,6 @@ int mxt_save_config_file(struct mxt_device *mxt, const char *filename)
   return ret;
 }
 
-//******************************************************************************
-/// \brief  Load configuration from .xcfg or RAW file and save to new file in
-//          .xcfg or RAW format (automatically detect formats)
-/// \return #mxt_rc
-int mxt_convert_config_file(struct libmaxtouch_ctx *ctx, const char *in_filename, const char *out_filename)
-{
-  int ret;
-
-  char *extension = strrchr(out_filename, '.');
-  struct mxt_config cfg = {{0}};
-
-  ret = mxt_get_config_from_file(ctx, in_filename, &cfg);
-  if (ret)
-    return ret;
-
-  if (extension && !strcmp(extension, ".xcfg"))
-    ret = mxt_save_xcfg_file(ctx, out_filename, &cfg);
-  else
-    ret = mxt_save_raw_file(ctx, out_filename, &cfg);
-
-  mxt_free_config(&cfg);
-
-  return ret;
-}
-
 //******************************************************************************
 /// \brief  Zero all configuration settings
 /// \return #mxt_rc

src/libmaxtouch/libmaxtouch.h

@@ -196,7 +196,6 @@ int mxt_calibrate_chip(struct mxt_device *mxt);
 int mxt_backup_config(struct mxt_device *mxt, uint8_t backup_command);
 int mxt_load_config_file(struct mxt_device *mxt, const char *cfg_file);
 int mxt_save_config_file(struct mxt_device *mxt, const char *filename);
-int mxt_convert_config_file(struct libmaxtouch_ctx *ctx, const char *in_filename, const char *out_filename);
 int mxt_zero_config(struct mxt_device *mxt);
 int mxt_get_msg_count(struct mxt_device *mxt, int *count);
 char *mxt_get_msg_string(struct mxt_device *mxt);

src/mxt-app/bootloader.c

@@ -64,14 +64,6 @@
 #define MXT_RESET_TIME           2
 #define MXT_BOOTLOADER_DELAY     50000
 
-//******************************************************************************
-/// \brief File operation wrapper object
-struct file_context {
-  FILE *fp;
-  int (*get)(struct file_context *fpc, unsigned char *ptr);
-  int (*put)(struct file_context *fpc, unsigned char val);
-};
-
 //******************************************************************************
 /// \brief Bootloader context object
 struct flash_context {
@@ -80,7 +72,7 @@ struct flash_context {
   struct libmaxtouch_ctx *ctx;
   bool have_bootloader_version;
   bool extended_id_mode;
-  struct file_context fpc;
+  FILE *fp;
   long file_size;
   char curr_version[MXT_FW_VER_LEN];
   int i2c_adapter;
@@ -91,112 +83,6 @@ struct flash_context {
   bool usb_bootloader;
 };
 
-//******************************************************************************
-/// \brief Read value from binary file
-static int fpc_get_value(struct file_context *fpc, unsigned char *ptr)
-{
-  int val;
-
-  val = fgetc(fpc->fp);
-
-  if (feof(fpc->fp)) return EOF;
-
-  *ptr = val;
-
-  return 0;
-}
-
-//******************************************************************************
-/// \brief Read hexadecimal value from file
-static int fpc_get_hex_value(struct file_context *fpc, unsigned char *ptr)
-{
-  char str[] = "00\0";
-  int val;
-
-  str[0] = fgetc(fpc->fp);
-  str[1] = fgetc(fpc->fp);
-
-  if (feof(fpc->fp)) return EOF;
-
-  if (sscanf(str, "%x", &val) != 1) {
-    return EOF;
-  }
-
-  *ptr =  val;
-
-  return 0;
-}
-
-//******************************************************************************
-/// \brief Read value from binary file
-static int fpc_put_value(struct file_context *fpc, unsigned char val)
-{
-  fputc(val, fpc->fp);
-
-  return ferror(fpc->fp);
-}
-
-//******************************************************************************
-/// \brief Read hexadecimal value from file
-static int fpc_put_hex_value(struct file_context *fpc, unsigned char val)
-{
-  int ret;
-
-  ret = fprintf(fpc->fp, "%02hhX", val);
-
-  if(ret != 2) {
-    return ret;
-  }
-
-  return 0;
-}
-
-//******************************************************************************
-/// \brief Open file in hex format
-static int open_hex_file(struct file_context *fpc, const char *filename, const char* mode)
-{
-  fpc->fp = fopen(filename, mode);
-  if (!fpc->fp) {
-    return errno;
-  }
-
-  fpc->get = fpc_get_hex_value;
-  fpc->put = fpc_put_hex_value;
-
-  return 0;
-}
-
-//******************************************************************************
-/// \brief Open binary file
-static int open_bin_file(struct file_context *fpc, const char *filename, const char* mode)
-{
-  fpc->fp = fopen(filename, mode);
-  if (!fpc->fp) {
-    return errno;
-  }
-
-  fpc->get = fpc_get_value;
-  fpc->put = fpc_put_value;
-
-  return 0;
-}
-
-//******************************************************************************
-/// \brief Open file in format based on filename
-static int open_file(struct file_context *fpc, const char *filename, const char* mode)
-{
-  int ret;
-
-  char *extension = strrchr(filename, '.');
-
-  if (extension && !strcmp(extension, ".enc"))
-    ret = open_hex_file(fpc, filename, mode);
-  else
-    ret = open_bin_file(fpc, filename, mode);
-
-  return ret;
-}
-
 //******************************************************************************
 /// \brief Wait for CHG line to indicate bootloader state change
 /// \return #mxt_rc
@@ -356,6 +242,26 @@ static int mxt_check_bootloader(struct flash_context *fw, unsigned int state)
   return MXT_SUCCESS;
 }
 
+//******************************************************************************
+/// \brief Read hexadecimal value from file
+static int get_hex_value(struct flash_context *fw, unsigned char *ptr)
+{
+  char str[] = "00\0";
+  int val;
+  int ret;
+
+  str[0] = fgetc(fw->fp);
+  str[1] = fgetc(fw->fp);
+
+  if (feof(fw->fp)) return EOF;
+
+  ret = sscanf(str, "%x", &val);
+
+  *ptr =  val;
+
+  return ret;
+}
+
 //******************************************************************************
 /// \brief Send firmware frames to bootloader
 /// \return #mxt_rc
@@ -396,14 +302,14 @@ static int send_frames(struct flash_context *fw)
 
   frame = 1;
 
-  while (!feof(fw->fpc.fp)) {
+  while (!feof(fw->fp)) {
     if (frame_retry == 0) {
-      if (fw->fpc.get(&fw->fpc, &buffer[0]) == EOF) {
+      if (get_hex_value(fw, &buffer[0]) == EOF) {
         mxt_info(fw->ctx, "End of file");
         break;
       }
 
-      if (fw->fpc.get(&fw->fpc, &buffer[1]) == EOF) {
+      if (get_hex_value(fw, &buffer[1]) == EOF) {
         mxt_err(fw->ctx, "Unexpected end of firmware file");
         return MXT_ERROR_FILE_FORMAT;
       }
@@ -421,7 +327,7 @@ static int send_frames(struct flash_context *fw)
       }
 
       for (i = 2; i < frame_size; i++) {
-        ret = fw->fpc.get(&fw->fpc, &buffer[i]);
+        ret = get_hex_value(fw, &buffer[i]);
 
         if (ret == EOF) {
           mxt_err(fw->ctx, "Unexpected end of firmware file");
@@ -459,7 +365,7 @@ static int send_frames(struct flash_context *fw)
       frame_retry = 0;
       frame++;
       bytes_sent += frame_size;
-      cur_percent = (unsigned char)(0.5f + (100.0 * ftell(fw->fpc.fp)) / fw->file_size);
+      cur_percent = (unsigned char)(0.5f + (100.0 * ftell(fw->fp)) / fw->file_size);
 
       /* Display at 10% or difference is greater than 10% */
       if (cur_percent % 10 == 0 || (cur_percent - last_percent) > 10) {
@@ -477,7 +383,7 @@ static int send_frames(struct flash_context *fw)
     }
   }
 
-  fclose(fw->fpc.fp);
+  fclose(fw->fp);
 
   return MXT_SUCCESS;
 }
@@ -640,59 +546,6 @@ static int mxt_enter_bootloader_mode(struct flash_context *fw)
   return MXT_SUCCESS;
 }
 
-//******************************************************************************
-/// \brief  Load firmware from .enc or binary file and save to new file in
-//          .enc or binary format (automatically detect formats)
-/// \return #mxt_rc
-int mxt_convert_firmware_file(struct libmaxtouch_ctx *ctx,
-                              const char *in_filename,
-                              const char *out_filename)
-{
-  int ret;
-  long file_size;
-  struct file_context in_fpc;
-  struct file_context out_fpc;
-  unsigned char val;
-
-  mxt_info(ctx, "Opening input firmware file %s", in_filename);
-
-  ret = open_file(&in_fpc, in_filename, "r");
-  if (ret) {
-    mxt_err(ctx, "Error %d opening %s for input", ret, in_filename);
-    ret = mxt_errno_to_rc(ret);
-    goto fail_in;
-  }
-
-  mxt_info(ctx, "Opening output firmware file %s", out_filename);
-
-  ret = open_file(&out_fpc, out_filename, "w");
-  if (ret) {
-    mxt_err(ctx, "Error %d opening %s for output", ret, out_filename);
-    ret = mxt_errno_to_rc(ret);
-    goto fail_out;
-  }
-
-  while (1) {
-    if (in_fpc.get(&in_fpc, &val) == EOF) {
-      break;
-    }
-    ret = out_fpc.put(&out_fpc, val);
-    if (ret) {
-      mxt_err(ctx, "Error %d writing to output", ret);
-      ret = mxt_errno_to_rc(ret);
-      break;
-    }
-  }
-
-  fclose(out_fpc.fp);
-
-fail_out:
-  fclose(in_fpc.fp);
-
-fail_in:
-  return ret;
-}
-
 //******************************************************************************
 /// \brief  Flash firmware to chip
 int mxt_flash_firmware(struct libmaxtouch_ctx *ctx,
@@ -709,14 +562,14 @@ int mxt_flash_firmware(struct libmaxtouch_ctx *ctx,
 
   mxt_info(fw.ctx, "Opening firmware file %s", filename);
 
-  ret = open_file(&fw.fpc, filename, "r");
-  if (ret) {
+  fw.fp = fopen(filename, "r");
+  if (!fw.fp) {
     mxt_err(fw.ctx, "Cannot open firmware file %s!", filename);
-    return mxt_errno_to_rc(ret);
+    return mxt_errno_to_rc(errno);
   }
-  fseek(fw.fpc.fp, 0L, SEEK_END);
-  fw.file_size = ftell(fw.fpc.fp);
-  rewind(fw.fpc.fp);
+  fseek(fw.fp, 0L, SEEK_END);
+  fw.file_size = ftell(fw.fp);
+  rewind(fw.fp);
 
   ret = mxt_bootloader_init_chip(&fw);
   if (ret && (ret != MXT_DEVICE_IN_BOOTLOADER))