static int do_esbc_validate(cmd_tbl_t *cmdtp, int flag, int argc,
                                char * const argv[])
 {
+       char *hash_str = NULL;
+       ulong haddr;
+       int ret;
+
        if (argc < 2)
                return cmd_usage(cmdtp);
+       else if (argc > 2)
+               /* Second arg - Optional - Hash Str*/
+               hash_str = argv[2];
+
+       /* First argument - header address -32/64bit */
+       haddr = simple_strtoul(argv[1], NULL, 16);
 
-       return fsl_secboot_validate(cmdtp, flag, argc, argv);
+       ret = fsl_secboot_validate(haddr, hash_str);
+       if (ret)
+               return 1;
+
+       printf("esbc_validate command successful\n");
+       return 0;
 }
 
 /***************************************************/
 
        return *p != '\0' && *endptr == '\0';
 }
 
-int fsl_secboot_validate(cmd_tbl_t *cmdtp, int flag, int argc,
-               char * const argv[])
+int fsl_secboot_validate(ulong haddr, char *arg_hash_str)
 {
        struct ccsr_sfp_regs *sfp_regs = (void *)(CONFIG_SYS_SFP_ADDR);
        ulong hash[SHA256_BYTES/sizeof(ulong)];
        char hash_str[NUM_HEX_CHARS + 1];
-       ulong addr = simple_strtoul(argv[1], NULL, 16);
        struct fsl_secboot_img_priv *img;
        struct fsl_secboot_img_hdr *hdr;
        void *esbc;
        struct udevice *mod_exp_dev;
 #endif
 
-       if (argc == 3) {
-               char *cp = argv[2];
+       if (arg_hash_str != NULL) {
+               const char *cp = arg_hash_str;
                int i = 0;
 
                if (*cp == '0' && *(cp + 1) == 'x')
                 */
                if (strlen(cp) != SHA256_NIBBLES) {
                        printf("%s is not a 256 bits hex string as expected\n",
-                              argv[2]);
+                              arg_hash_str);
                        return -1;
                }
 
                        hash_str[NUM_HEX_CHARS] = '\0';
                        if (!str2longbe(hash_str, &hash[i])) {
                                printf("%s is not a 256 bits hex string ",
-                                      argv[2]);
+                                      arg_hash_str);
                                return -1;
                        }
                }
        memset(img, 0, sizeof(struct fsl_secboot_img_priv));
 
        hdr = &img->hdr;
-       img->ehdrloc = addr;
+       img->ehdrloc = haddr;
        esbc = (u8 *)(uintptr_t)img->ehdrloc;
 
        memcpy(hdr, esbc, sizeof(struct fsl_secboot_img_hdr));
                goto exit;
        }
 
-       printf("esbc_validate command successful\n");
-
 exit:
-       return 0;
+       return ret;
 }
 
                                                 */
 
        struct fsl_secboot_sg_table sgtbl[MAX_SG_ENTRIES];      /* SG table */
-       u32 ehdrloc;            /* ESBC client location */
+       ulong ehdrloc;          /* ESBC client location */
 };
 
-int fsl_secboot_validate(cmd_tbl_t *cmdtp, int flag, int argc,
-               char * const argv[]);
+int fsl_secboot_validate(ulong haddr, char *arg_hash_str);
 int fsl_secboot_blob_encap(cmd_tbl_t *cmdtp, int flag, int argc,
        char * const argv[]);
 int fsl_secboot_blob_decap(cmd_tbl_t *cmdtp, int flag, int argc,