image_set_hcrc(hdr, checksum);
 }
 
-static int image_extract_datafile(void *ptr, struct image_tool_params *params)
+static int image_extract_subimage(void *ptr, struct image_tool_params *params)
 {
        const image_header_t *hdr = (const image_header_t *)ptr;
        ulong file_data;
        }
 
        /* save the "data file" into the file system */
-       return imagetool_save_datafile(params->outfile, file_data, file_len);
+       return imagetool_save_subimage(params->outfile, file_data, file_len);
 }
 
 /*
        image_verify_header,
        image_print_contents,
        image_set_header,
-       image_extract_datafile,
+       image_extract_subimage,
        image_check_image_types,
        NULL,
        NULL
 
 };
 
 /*
- * dumpimage_extract_datafile -
+ * dumpimage_extract_subimage -
  *
  * It scans all registered image types,
  * verifies image_header for each supported image type
  * returns negative if input image format does not match with any of
  * supported image types
  */
-static int dumpimage_extract_datafile(struct image_type_params *tparams,
+static int dumpimage_extract_subimage(struct image_type_params *tparams,
                void *ptr, struct stat *sbuf)
 {
        int retval = -1;
                 * Extract the file from the image
                 * if verify is successful
                 */
-               if (tparams->extract_datafile) {
-                       retval = tparams->extract_datafile(ptr, ¶ms);
+               if (tparams->extract_subimage) {
+                       retval = tparams->extract_subimage(ptr, ¶ms);
                } else {
                        fprintf(stderr,
-                               "%s: extract_datafile undefined for %s\n",
+                               "%s: extract_subimage undefined for %s\n",
                                params.cmdname, tparams->name);
                        return -2;
                }
                         * Extract the data files from within the matched
                         * image type. Returns the error code if not matched
                         */
-                       retval = dumpimage_extract_datafile(tparams, ptr,
+                       retval = dumpimage_extract_subimage(tparams, ptr,
                                        &sbuf);
                } else {
                        /*
 
        return retval;
 }
 
-int imagetool_save_datafile(
+int imagetool_save_subimage(
        const char *file_name,
        ulong file_data,
        ulong file_len)
 
        void (*set_header) (void *, struct stat *, int,
                                        struct image_tool_params *);
        /*
-        * This function is used by the command to retrieve a data file from
-        * the image (i.e. dumpimage -i <image> -p <position> <data_file>).
+        * This function is used by the command to retrieve a component
+        * (sub-image) from the image (i.e. dumpimage -i <image> -p <position>
+        * <sub-image-name>).
         * Thus the code to extract a file from an image must be put here.
         *
         * Returns 0 if the file was successfully retrieved from the image,
         * or a negative value on error.
         */
-       int (*extract_datafile) (void *, struct image_tool_params *);
+       int (*extract_subimage)(void *, struct image_tool_params *);
        /*
         * Some image generation support for ex (default image type) supports
         * more than one type_ids, this callback function is used to check
        struct image_tool_params *params);
 
 /**
- * imagetool_save_datafile - store data into a file
+ * imagetool_save_subimage - store data into a file
  * @file_name: name of the destination file
  * @file_data: data to be written
  * @file_len: the amount of data to store
  *
- * imagetool_save_datafile() store file_len bytes of data pointed by file_data
+ * imagetool_save_subimage() store file_len bytes of data pointed by file_data
  * into the file name by file_name.
  *
  * returns:
  *     zero in case of success or a negative value if fail.
  */
-int imagetool_save_datafile(
+int imagetool_save_subimage(
        const char *file_name,
        ulong file_data,
        ulong file_len);
                _verify_header, \
                _print_header, \
                _set_header, \
-               _extract_datafile, \
+               _extract_subimage, \
                _check_image_type, \
                _fflag_handle, \
                _vrec_header \
                .verify_header = _verify_header, \
                .print_header = _print_header, \
                .set_header = _set_header, \
-               .extract_datafile = _extract_datafile, \
+               .extract_subimage = _extract_subimage, \
                .check_image_type = _check_image_type, \
                .fflag_handle = _fflag_handle, \
                .vrec_header = _vrec_header \