/*
 * Copyright (c) 2011-2015, Emulex
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * 3. Neither the name of the copyright holder nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 */

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <ctype.h>
#include <unistd.h>
#include <memory.h>
#include <errno.h>
#include <sys/times.h>
#include <sys/ioctl.h>
#include <time.h>

#include <elxu_sli4.h>
#include <elxu_device.h>
#include <elxu_sky.h>
#include <elxu_ufi.h>
#include <elxu_dwnld.h>
#include <elxu_common.h>
#include <elxu_mgmt.h>

#include <ocs_ioctl.h>

#define FW_UPDATE_RESTRICTED -14
#define UNSUPPORTED_FW_IMAGE -13

static uint16_t get_op_type(uint8_t entry_type);
static off_t find_ufi_dir(int fd);

/**
 * @brief Returns the file type.
 *
 * This function returns the type of the file - Skyhawk UFI or Lancer object file.
 *
 * @param buf_p pointer to the memory holding an initial file data
 * @param len the data length
 */

static fFormat_t retrieve_file_format (uint8_t *buf_p, int len)
{
	fFormat_t result = UNKNOWN;
	uint32_t dw2;

	/*
	 * Skyhawk UFI files always starts with 'S' character .
	 * It is the first letter of a "ServerEngines" string.
	 */
	if (buf_p [0] == 'S' ) {
		ufi_file_header_t *file_hdr;

		file_hdr = (ufi_file_header_t *)buf_p;

		/*
		 * In the Skyhawk format the first byte of the build_version field
		 * gives us the device family.  4=Skyhawk
		 */
		if (file_hdr->build_version[0] == '4') {
			result = SKYHAWK_UFI;
		}
	} else {
		dw2 = *(uint32_t *) &buf_p[4];

		/*
		 * Verify if the file is an Lancer Object file.
		 * 0xFEAA is a magic number,  0001 (normal) and 0002 (compressed) is a file types
		 * 0003 seems to be a new valure for Lancer G6 files, 0005 is for Prism.
		 */
		if ((dw2 == 0xFEAA0001) || (SWAP_4BYTES(dw2) == 0xFEAA0001) ||
		    (dw2 == 0xFEAA0002) || (SWAP_4BYTES(dw2) == 0xFEAA0002) ||
		    (dw2 == 0xFEAA0003) || (SWAP_4BYTES(dw2) == 0xFEAA0003)  )
		{
			result = LANCER;
		} else if ((dw2 == 0xFEAA0005) || (SWAP_4BYTES(dw2) == 0xFEAA0005)) {
			result = PRISM;
		}
	}

	return result;
}


/**
 * @brief Initializes files descriptor structure.
 *
 * Initializes the file descriptor structure.
 *
 * @param file_name_p filename information
 * @param fdsc_p a file descriptor pointer
 */

static int file_handler_init (const char *filename_p, dwnld_file_desc_t *fdesc_p)
{
    uint8_t *buf_p;
    int rd;
    const char *str_p;
    off_t ufi_dir_offset;
    int rc;

    /*
    * Get a file statistic information (file length and ...)
    */
    rc = stat(filename_p, &(fdesc_p->st));
    if (rc < 0)
    {
	if (errno == ENOENT) {
		printf("File %s not found\n", filename_p);
	} else {
		printf("File %s stat returns %s\n", filename_p, strerror(errno));
	}
        return -1;
    }

    str_p = strrchr (filename_p, '/');

    if (str_p == NULL)
    {
        str_p = filename_p;
    }
    else
    {
        str_p++;
    }

    if(strlen(str_p) < 127 ) {
	strncpy (fdesc_p->file_name, str_p, strlen(str_p));
    }else {
        printf ("file name more than 128 chars\n");
	return -1;
    }

    /*
    * Open the file ..
    */
    if ((fdesc_p->fd = open(filename_p, O_RDONLY)) < 0)
    {
        printf ("open file failure, (%s)\n", strerror(errno));
        return -1;
    }

    /*
    * Allocate a space the file header information.
    * This includes both the UFI File Header and the Image Header for a UFI file
    *
    * UFI header is bigger than Lancer file object header.
    * Allocate the space to fit UFI header.
    *
    */
    if ((buf_p = zmalloc(UFI_FILE_HEADER_LENGTH)) == NULL)
    {
        close(fdesc_p->fd);
        printf("Malloc failure - (%s)\n", strerror(errno));
        return MALLOC_FAILED;
    }

    /*
    * Copy data into the memory
    */
    if ((rd = read(fdesc_p->fd, buf_p, UFI_FILE_HEADER_LENGTH)) != UFI_FILE_HEADER_LENGTH)
    {
        printf("Read failure %d, (%s)\n", rd, strerror(errno));
        zfree(buf_p);
        close(fdesc_p->fd);
        return -1;
    }

    /*
    * Get the file type and update file descriptor fields.
    */
    switch (retrieve_file_format (buf_p, UFI_FILE_HEADER_LENGTH))
    {

	case SKYHAWK_UFI:
            fdesc_p->file_type = FILE_TYPE_UFI;
            fdesc_p->hba_file_type = HBA_FILE_SKYHAWK;
	    fdesc_p->ufi_flash_hdr = zmalloc(sizeof(flash_directory_t));
	    ufi_dir_offset = find_ufi_dir(fdesc_p->fd);
	    if (ufi_dir_offset < 0) {
		    printf("Unable to find UFI directory in UFI file.\n");
		    zfree(buf_p);
		    close(fdesc_p->fd);
		    return -1;
	    }
            if(lseek(fdesc_p->fd, ufi_dir_offset, SEEK_SET)) {
		/* copy in our UFI flash directory header */
            	read(fdesc_p->fd, fdesc_p->ufi_flash_hdr, sizeof(flash_directory_t));
	    }

	    /* First 128 bytes are the UFI header */
            memcpy((uint8_t *)&(fdesc_p->ufi_hdr), buf_p, sizeof(ufi_file_header_t));
	    /* Next 48 bytes are the Image Header */
            memcpy((uint8_t *)&(fdesc_p->img_hdr), (buf_p + sizeof(ufi_file_header_t)), sizeof(ufi_image_header_t));

            break;

        case LANCER:
            fdesc_p->hba_file_type = HBA_FILE_LANCER;
            break;
        case PRISM:
            fdesc_p->hba_file_type = HBA_FILE_PRISM;
            break;

        case UNKNOWN:
            printf ("Unsupported file type.\n");
            zfree(buf_p);
            close(fdesc_p->fd);
            return -1;
    }

    /*
    * Reset the file reader location.
    */
    lseek(fdesc_p->fd, 0, SEEK_SET);
    zfree(buf_p);
    return 0;
} /* end of download_ufi_file_int */



/**
 * @brief Displays content of UFI file header structure.
 *
 * The function parses and displays the content of the UFI file header structure.
 *
 * @param ufi_hdr_p  UFI header structure pointer.
 */

static void display_ufi_header(ufi_file_header_t *ufi_hdr_p)
{
    int i;

    printf("\nUFI File Header:\n");
    printf("Signature:\n");
    for (i = 0; i < 52; i++)
    {
	if (isprint(ufi_hdr_p->signature[i])) {
		printf("%c", ufi_hdr_p->signature[i]);
	}
    }

    printf("\nUFI Version: %08x\n", ufi_hdr_p->ufi_version);
    printf("FileLen: %d (%08X)\n", ufi_hdr_p->file_len, ufi_hdr_p->file_len);
    printf("Checksum : %08X\n", ufi_hdr_p->checksum);
    printf("Antidote: %08X\n", ufi_hdr_p->antidote);
    printf("Number of Images: %d\n", ufi_hdr_p->numOfImgs);
    printf("Build: %s\n", trimmed_string(ufi_hdr_p->build_version));
    printf("Target platform: ");
    switch(ufi_hdr_p->build_version[0]) {
    case '4':
	    printf("Skyhawk\n");
	    break;
    default:
	    printf("Unknown\n");
    }
    printf("ASIC Support: 0x%x", ufi_hdr_p->asic_support);
    if (ufi_hdr_p->build_version[0] == '4') {
	    if (ufi_hdr_p->asic_support == 0x10) {
		    printf(" (Skyhawk B0 only)\n");
	    } else if (ufi_hdr_p->asic_support == 0x11) {
		    printf(" (Skyhawk B0 or B1 only)\n");
	    }
    } else {
	    printf("\n");
    }
    printf("End of UFI File Header dump\n");
}

/**
 * @brief Displays content of UFI flash directory header.
 *
 * This function is in part used for debugging and determining what sections exist
 * in a given UFI file
 *
 * @param flash_dir  UFI flash directory structure pointer.
 */
void display_ufi_flash_directory(dwnld_file_desc_t *fdesc)
{
    int i;
    flash_directory_t *flash_dir = fdesc->ufi_flash_hdr;
    flash_directory_entry_t *entry;
    uint32_t crc;
    off_t offset;

    printf("\nFlash Directory Header:\n");
    printf("Flash Directory Format: %d\n", flash_dir->formatRevNumber);
    printf("Number of Directory Entries: %d\n", flash_dir->numImages);

    printf("Flash Directory Entries:\n");
    for (i=0; i<flash_dir->numImages; i++) {
		entry = &(flash_dir->entries[i]);
		
		printf("  Version: %s\n", trimmed_string(entry->version));
		printf("    Entry Type: 0x%02x (%s)\n", entry->entryType, decode_entry_type(entry->entryType));
		if (entry->opType == 0xffff) {
		    printf("    Op Type: 0x%04x (based on Entry Type)\n", get_op_type(entry->entryType));
		} else {
		    printf("    Op Type: 0x%04x\n", entry->opType);
		}
		printf("    Offset: 0x%08x\n", entry->offset);
		printf("    Image Size: 0x%08x\n", entry->imageSize);
		printf("    Max Image Size:  0x%08x\n", entry->maxSize);
		printf("    Checksum: 0x%08x\n", entry->checkSum);

	    	/* Get CRC from the end of the actual component */
	    	offset = (long)(entry->offset + entry->maxSize + UFI_FILE_HEADER_LENGTH - 4);
		if (lseek(fdesc->fd, offset , SEEK_SET) != offset) {
			fprintf(stderr, "couldn't seek to %ld\n", offset);
			return;
		}

		if (read(fdesc->fd, &crc, 4) != 4) {
			fprintf(stderr, "Didn't get %d bytes on read\n", 4);
			return;
		}
	    printf("    CRC: 0x%08x\n", crc);
    }

    printf("\nEnd of Flash Directory Listing dump\n");
}

/**
 * @brief Displays content of UFI image header structure.
 *
 * The function displays the content of the UFI image header structure.
 *
 * @param ufi_hdr_p  UFI image header structure pointer.
 */

static void display_ufi_image_hdr(ufi_image_header_t *img_hdr_p)
{

    printf("\nFirmware Image Header:\n");
    printf("Image ID: %08X\n", img_hdr_p->imageId);
    printf("Image Offset: %08X\n", img_hdr_p->imageOffset);
    printf("Image Length: %08X\n", img_hdr_p->imageLength);
    printf("Image Checksum: %08X\n", img_hdr_p->imageChecksum);
    printf("Image Version: %s\n", trimmed_string(img_hdr_p->imageVer));
    printf("End of Firmware Image Header dump\n");

}

/**
 * @brief Skyhawk firmware download.
 *
 * Skyhawk UFI file is read into memory and it is forwarded to the HBA in segments.
 *
 * @param device_p A pointer to HBA structure descriptor.
 * @param fdsc_p A pointer to a file descriptor structure.
 */

static int download_skyhawk_image (elxu_device_t *device_p, dwnld_file_desc_t *fdsc_p)
{
	flash_directory_t *ufi_dir;
	int entry_index;
	int largest_entry;
	uint8_t *buffer;
	int rval;
	long lval;
	int asic_support_ok;

	ufi_dir = fdsc_p->ufi_flash_hdr;

	/*
	 * Check the ASIC_Support field in the UFI header and see if this firmware
	 * is supported on the target ASIC.
	 */

	asic_support_ok = 0;
	switch(fdsc_p->ufi_hdr.asic_support) {
	case 0x10:
		/* B0 Firmware, supported only on B0 chips */
		if (device_p->asic_id == 0x0410) {
			asic_support_ok = 1;
		}
		break;
	case 0x11:
		/* B1 Firmware, supported on B0 and B1 chips */
		if ((device_p->asic_id == 0x0410) ||
		    (device_p->asic_id == 0x0411)) {
			asic_support_ok = 1;
		}
		break;
	default:
		/* Undefined asic_support value */
		break;
	}


	if (asic_support_ok == 0) {
		printf("Provided UFI is not supported on this device.\n");
		printf("UFI version is 0x%02x, device version is 0x%04x\n",
		       fdsc_p->ufi_hdr.asic_support,
		       device_p->asic_id);
		close(fdsc_p->fd);
		return -1;
	}

	display_ufi_header(&fdsc_p->ufi_hdr);
	display_ufi_image_hdr(&fdsc_p->img_hdr);
	display_ufi_flash_directory(fdsc_p);

	/*
	 * Allocate a buffer big enough to hold the largest FW section.
	 */
	largest_entry = 0;
	for (entry_index=0; entry_index < ufi_dir->numImages; entry_index++) {
		if (ufi_dir->entries[entry_index].maxSize > largest_entry) {
			largest_entry = ufi_dir->entries[entry_index].maxSize;
		}
	}
	buffer = malloc(largest_entry);
	if (buffer == NULL) {
		printf("Unable to allocate memory to hold FW image\n");
		return -1;
	}

	for (entry_index=0; entry_index < ufi_dir->numImages; entry_index++) {
		flash_directory_entry_t *entry;
		uint32_t op_type;
		uint32_t entry_type;
		uint32_t offset;
		uint32_t file_crc;
		uint32_t chip_crc;
		off_t seek_offset;

		entry = &(ufi_dir->entries[entry_index]);
		op_type = entry->opType;
		entry_type = entry->entryType;
		if (op_type == 0xffff) {
			op_type = get_op_type(entry_type);
		}
		offset = entry->offset;

		if (op_type == 0xffff) {
			printf("Invalid op_type for section %d\n", entry_index);
			free(buffer);
			return -1;
		}

		/* Read the CRC of the current segment on the device */
		rval = mbox_read_flashrom(device_p, MGMT_FLASHROM_OPCODE_IMAGE_CRC, op_type, offset, buffer, 4);
		/* If reading the CRC failed then we'll just assume the CRCs are different */
		if (rval == 0) {
			chip_crc = (buffer[3] << 24) | (buffer[2] << 16) | (buffer[1] << 8) | buffer[0];

			/* Read the CRC from the firmware file */
			seek_offset = entry->offset + entry->maxSize + UFI_FILE_HEADER_LENGTH - 4;
			if (lseek(fdsc_p->fd, seek_offset , SEEK_SET) != seek_offset) {
				fprintf(stderr, "couldn't seek to %ld\n", seek_offset);
			}
			if (read(fdsc_p->fd, &file_crc, 4) != 4) {
				fprintf(stderr, "Didn't get %d bytes on read\n", 4);
			}

			/*
			 * Compare the CRC from the running FW with the CRC in the file
			 * If they match we can skip this section.
			 */

			if (chip_crc == file_crc) {
				printf("%08x: [%s] Unchanged, skipping\n", entry->offset, trimmed_string(entry->version));
				continue;
			}
		}

		printf("%08x: [%s] (%d bytes)\n", entry->offset, trimmed_string(entry->version), entry->maxSize);

		lval = lseek(fdsc_p->fd, entry->offset+UFI_FILE_HEADER_LENGTH, SEEK_SET);
		if (lval != entry->offset+UFI_FILE_HEADER_LENGTH) {
			printf("Seek failed to offset 0x%x\n", entry->offset);
			free(buffer);
			return -1;
		}

		lval = read(fdsc_p->fd, buffer, entry->maxSize);
		if (lval != entry->maxSize) {
			printf("Read failed in segment %d\n", entry_index);
			printf("Expected %d bytes, got %ld\n", entry->maxSize, lval);
			free(buffer);
			return -1;
		}

		rval = ufi_image_download(device_p, op_type, buffer, entry->maxSize);
		if (rval != 0) {
			/* This section of code is temporary (as of March 2014) for the transition between
			   old and new Skyhawk firmware */
			if (entry->opType == 0xffff) {
				if ((entry_type == 0x30) ||
				    (entry_type == 0xc0) ||
				    (entry_type == 0xd0) ||
				    (entry_type == 0xd1) ||
				    (entry_type == 0xd2)) {
					if ((rval == -2) || (rval == -3)) {
						/* It's OK to ignore this error */
						continue;
					}
				}
			}

			/* At this point we have an error, and it's not one of the cases we're supposed to ignore */
			if ((rval == -2) || (rval == -3)) {
				/*
				 * These two errors indicate a case where we're moving from old style
				 * firmware to new style.  This requires a reboot and a second download of
				 * the same firmware.
				 */
				printf("This special firmware release requires the firmware download process\n");
				printf("to be performed twice.  You must reboot the system and download the same\n");
				printf("firmware file again to complete the download process.\n");
				free(buffer);
				return -1;
			} else {
				/*
				 * Some other unexpected error has occurred.
				 */
				printf("Firmware download failed, status is 0x%02x\n", -rval);
				free(buffer);
				return -1;
			}

		}

	}

	printf("Firmware download successful.\n");
	printf("Reboot the system to activate the new firmware.\n");

	free(buffer);
	return 0;

}


/**
 * @brief Lancer file object.
 *
 * Downloads the Lancer file object into specified HBA object directory (object).
 *
 * @param device_p A pointer to HBA structure descriptor.
 * @param object_p An lancer object type
 * @param fdsc_p A pointer to a file descriptor structure.
 */

static int download_lancer_object_file (elxu_device_t *device_p, const char *object_p, dwnld_file_desc_t *fdsc_p)
{
	struct stat stat_buf;
	unsigned char *buf;
	off_t filesize;
	int rval;
	char change_status_text[20];
	int change_status;

	if (fstat(fdsc_p->fd, &stat_buf) == -1) {
		perror("fstat");
		return -1;
	}

	filesize = stat_buf.st_size;

	buf = malloc(filesize);
	if (buf == NULL) {
		perror("malloc");
		return -1;
	}

	if (read(fdsc_p->fd, buf, filesize) != filesize) {
		fprintf(stderr, "Didn't get %ld bytes on read\n", filesize);
		free(buf);
		return -1;
	}

	rval = elxu_device_exec(device_p, "/ocs/firmware_write", buf, filesize, change_status_text, 20);
	if (rval == 0) {
		printf("Firmware download successful.\n");
		change_status = strtoul(change_status_text, NULL, 0);
		switch (change_status) {
		case 0x00:
			printf("No reset needed, new firmware is active.\n");
			break;
		case 0x01:
			printf("A physical device reset (host reboot) is needed to activate the new firmware\n");
			break;
		case 0x02:
		case 0x03:
			printf("Use the firmware-reset option to activate the new firmware.\n");
			break;
		case 0x04:
			printf("Use port-migration or firmware-reset option to activate new firmware.\n");
			printf("Note: With port-migration option, Only particular port will run with new FW\n");
			break;
		default:
			printf("Unexected value for change_status: %d\n", change_status);
			break;
		}
	} else if (rval == FW_UPDATE_RESTRICTED) {
		printf("This firmware version is not supported on this HBA model.\n");
	} else if (rval == UNSUPPORTED_FW_IMAGE) {
		printf("Download failed. Firmware does not meet minimum version requirement.\n");
	} else {
		perror("ioctl");
	}
	
	free(buf);
	return rval;

}


/**
 * @brief Lancer firmware download.
 *
 * Donwloads the grp file into HBA.
 *
 * @param device_p A pointer to HBA structure descriptor.
 * @param fdsc_p A pointer to a file descriptor structure.
 */

static int download_lancer_image (elxu_device_t *device_p, dwnld_file_desc_t *fdsc_p)
{
    int retval = -1;

    /*
     * Validate the file type using the file extention.
     */
    if (strstr (fdsc_p->file_name, ".grp") != NULL)
    {
        /*
         * When .grp file, use only the object name - clear file name
         */
        fdsc_p->file_name[0] = '\0';
        retval = download_lancer_object_file (device_p, "/prg/", fdsc_p);
    }
    else
    {
        printf ("The file %s has to be a .grp file type \n", fdsc_p->file_name);
    }
    return retval;
}


/**
 * @brief Firmware download.
 *
 * Based on the file type, download the firmware to an appropriate HBA.
 *
 * @param device_p A pointer to HBA structure descriptor.
 * @param fdsc_p A pointer to a file descriptor structure.
 *
 * @return Returns 0 on success, non-zero on failure.
 */

static int download_handler(elxu_device_t *device_p, dwnld_file_desc_t *fdsc_p)
{
	int retval;

	switch (fdsc_p->hba_file_type) {
	case HBA_FILE_SKYHAWK:
		if (is_skyhawk(device_p)) {
			printf("Download starting\n");
			retval = download_skyhawk_image (device_p, fdsc_p);
		} else {
			printf("Firmware is Skyhawk UFI but device is not Skyhawk\n");
			retval = -1;
		}
		break;
	case HBA_FILE_LANCER:
	case HBA_FILE_PRISM:
		if (is_lancer(device_p) || is_prism(device_p)) {
			printf("Download starting\n");
			retval = download_lancer_image (device_p, fdsc_p);
		} else {
			printf("Firmware is Lancer FW file but device is not Lancer\n");
			retval = -1;
		}
		break;
	default:
		printf ("Unknown HBA file type %d \n", fdsc_p->hba_file_type);
		retval = -1;
	}

	if (retval < 0) {
		printf ("Download Failed\n");
	} else
	{
		printf("Download Success\n");
		if (is_calypso(device_p)) {
			printf("NOTE:  The interface just updated is a dual controller interface.\n");
			printf("       You may need to update the firmware on the second controller\n");
			printf("       to prevent issues on next boot.\n");
		}
	}

	return retval;

}

/**
 * @brief flash and file data comparison functionality.
 *
 * Compare flash with the UFI or Bin file data.
 *
 * @param device_p The pointer to the HBA descriptor structure.
 * @param memFdsc_p The pointer to the memory file descriptor structure.
 */

static int hba_image_section_fw_verify(elxu_device_t *device_p, dwnld_file_desc_t *fdsc_p)
{
	int failure_detected = 0;
	uint8_t *file_sect_buf_p;
	uint8_t *flash_sect_buf_p;
	flash_directory_t *ufi_dir;
	int entry_index;
	int largest_entry;
	long lval;

	if (device_p == NULL || fdsc_p == NULL)
	{
		printf("Null pointer \n");
		return (-1);
	}

	ufi_dir = fdsc_p->ufi_flash_hdr;

	/*
	 * Validate the file type: UFI or Bin
	 */
	if (fdsc_p->file_type != FILE_TYPE_UFI)
	{
		printf("FW file is not a UFI file\n");
		return -1;
	}

	printf ("Verify firmware sections ... \n\n");

	/*
	 * Find the size of the largest UFI entry
	 */
	largest_entry = 0;
	for (entry_index=0; entry_index < ufi_dir->numImages; entry_index++) {
		if (ufi_dir->entries[entry_index].maxSize > largest_entry) {
			largest_entry = ufi_dir->entries[entry_index].maxSize;
		}
	}

	/*
	 * Allocate a buffer for FW sections from the file
	 */
	if ((file_sect_buf_p = malloc(largest_entry)) == NULL)
	{
		printf("Malloc failure (%s)\n", strerror(errno));
		close (fdsc_p->fd);
		return MALLOC_FAILED;
	}

	/*
	 * Allocate a buffer for FW sections from flash
	 */
	if ((flash_sect_buf_p = malloc(largest_entry)) == NULL)
	{
		printf("Malloc failure (%s)\n", strerror(errno));
		close (fdsc_p->fd);
		free(file_sect_buf_p);
		return MALLOC_FAILED;
	}

	/* Iterate over entries in the UFI dirctory */
	for (entry_index=0; entry_index < ufi_dir->numImages; entry_index++) {
		flash_directory_entry_t *entry;
		uint32_t op_type;
		uint32_t entry_type;

		printf("%d: ", entry_index);

		entry = &(ufi_dir->entries[entry_index]);
		op_type = entry->opType;
		entry_type = entry->entryType;
		if (op_type == 0xffff) {
			op_type = get_op_type(entry_type);
		}

		if (op_type == 0xffff) {
			printf("ERROR: Invalid op_type\n");
			++failure_detected;
			continue;
		}

		/* Read the section from the file */
		lval = lseek(fdsc_p->fd, entry->offset+UFI_FILE_HEADER_LENGTH, SEEK_SET);
		if (lval != entry->offset+UFI_FILE_HEADER_LENGTH) {
			printf("ERROR: File seek failed\n");
			++failure_detected;
			continue;
		}

		lval = read(fdsc_p->fd, file_sect_buf_p, entry->maxSize);
		if (lval != entry->maxSize) {
			printf("ERROR: File read failed\n");
			++failure_detected;
			continue;
		}

		/* Read the section from the firmware */
		if (ufi_image_upload(device_p, op_type, flash_sect_buf_p, entry->maxSize) != 0)
		{
			printf ("ERROR: Firmware read failed\n");;
			++failure_detected;
			continue;
		}

		/*
		 * Compare buffers
		 */
		if (memcmp(flash_sect_buf_p, file_sect_buf_p, entry->maxSize) != 0)
		{
			printf("MISMATCH: Sections do not match\n");
			failure_detected++;
			continue;
		} else {
			printf("Match\n");
		}

	}

	/*
	 * Mismatch detected
	 */
	if (failure_detected)
	{
		printf("Firmware verification failed - %d mismatched sections \n",
				failure_detected);
	}
	else
	{
		printf("Firmware verification was successful! \n");
	}
	zfree(file_sect_buf_p);
	zfree(flash_sect_buf_p);
	zfree(fdsc_p->ufi_flash_hdr);
	close(fdsc_p->fd);
	return 0;
}

/**
 * @brief  Determine mailbox op_type from UFI entry_type.
 *
 * @par Description
 * Each firmware section in a UFI directory has an entry type that
 * describes what type of entry it it.  Newer UFI files also have
 * an op_type field that specify which op_type argument should be
 * passed in the COMMON_WRITE_FLASHROM mailbox comman.  Older UFI
 * files don't have the op_type present in the directory and it must
 * be determined from the entry_type.  This function returns an
 * op_type based on the entry_type.
 *
 * @param entry_type The entry type to look up.
 *
 * @return Returns the op_type that corresponds to the given entry type,
 * 	or 0xffff if no match is found.
 */
static uint16_t get_op_type(uint8_t entry_type)
{
	static int table[][2] = {
		{0x10, 0x000d},
		{0xa0, 0x0000},
		{0xb0, 0x0009},
		{0x20, 0x0003},
		{0x21, 0x0008},
		{0x22, 0x0002},
		{0xe0, 0x0001},
		{0x30, 0x0016},
		{0xc0, 0x0015},
		{0xd0, 0x0012},
		{0xd1, 0x0013},
		{0xd2, 0x0017},
		{0xd3, 0x0014},
		{0x23, 0x0011},
	};
	int i;

	for (i=0; i<sizeof(table) / sizeof(table[0][0]) / 2; i++) {
		if (table[i][0] == entry_type) {
			return table[i][1];
		}
	}

	return 0xffff;
}

#define PATTERN_SIZE 16

static off_t find_ufi_dir(int fd)
{
	uint8_t buffer[PATTERN_SIZE];
	static uint8_t pattern1[PATTERN_SIZE] = {
		'*', '*', '*', ' ', 'S', 'E', ' ', 'F',
		'L', 'A', 'S', '\0', '\0', '\0', '\0', '\0'};
	static uint8_t pattern2[PATTERN_SIZE] = {
		'H', ' ', 'D', 'I', 'R', 'E', 'C', 'T',
		'O', 'R', 'Y', ' ', '*', '*', '*', ' '};
	off_t result;

	lseek(fd, 0, SEEK_SET);
	result = 0;
	while (read(fd, buffer, PATTERN_SIZE) == PATTERN_SIZE) {
		if (memcmp(buffer, pattern1, PATTERN_SIZE) == 0) {
			if (read(fd, buffer, PATTERN_SIZE) != PATTERN_SIZE) {
				fprintf(stderr , "couldn't read %d bytes" , PATTERN_SIZE);
			}
			if (memcmp(buffer, pattern2, PATTERN_SIZE) == 0) {
				return result;
			} else {
				return -1;
			}
		}
		result += PATTERN_SIZE;
	}

	return -1;

}

/**
 * @brief File manipulating functionality.
 *
 * This functionality is called by a CLI to request a particular file
 * manipulation operation.
 *
 * @param device_p The pointer to the HBA descriptor structure.
 * @param memFdsc_p The pointer to the memory file descriptor structure.
 * @param action  The requested action.
 */

int file_handler (elxu_device_t *device_p, char const *file_name_p, int action)
{
    dwnld_file_desc_t fileDesc;

    memset(&fileDesc, 0, sizeof(fileDesc));

    if (file_handler_init (file_name_p, &fileDesc) < 0)
    {
        return -1;
    }

    switch (action)
    {
        case FW_FILE_DOWNLOAD:
            if (download_handler(device_p, &fileDesc) != 0) {
                printf("Error Downloading FW\n");
                return (-1);
            }
            break;
        case FW_FILE_DISPLAY_INFO:
            if (fileDesc.file_type == FILE_TYPE_UFI)
            {
                display_ufi_header(&fileDesc.ufi_hdr);
                display_ufi_image_hdr(&fileDesc.img_hdr);
                display_ufi_flash_directory(&fileDesc);
            }
            else
            {
                printf ("file-format command is only supported for UFI files.\n");
            }
            close (fileDesc.fd);
	    zfree(fileDesc.ufi_flash_hdr);

            break;
        case FW_FILE_VERIFY:
        	if (is_lancer(device_p) || is_prism(device_p))
        	{
        		printf("Firmware compare is not supported for Lancer/Prism Family Products.\n");

		}
        	else if(fileDesc.file_type == FILE_TYPE_UFI)
        	{
        		if (hba_image_section_fw_verify(device_p, &fileDesc) < 0)
        		{
        			printf("Error Verifying Firmware\n");
        		}
    		}
        	else
       		{
       			printf("Firmware compare is only supported for UFI files.\n");
       		}
        	break;
        default:
            printf ("Invalid Action %d \n", action);
            return -1;
    }
    return (0);
}

/**
* @page flash_parsing Flash File Parsing (Using “file-info”)
*
* The elxsdkutil uses the File Information CLI command (@ref cmd_file_info "file-info")
* to parse a .ufi flash file
* to determine its contents, based on the header format and file layout. It is implemented
* by the file_handler() function in the elxu_dwnld.c module.
*
*
* @page flash_access Flash Access
*
* The elxsdkutil can download firmware and perform diagnostic dumps. The download
* and dump facilities are implemented in the functions described in the following table.
* <table class="dashboard">
* <tr><th>Function Name</th><th>Description</th></tr>
* <tr><td>download_ufi_image()</td><td>Download a .ufi firmware image to an OCe11102 adapter
* using the file handler in the elxu_dwnld.c module.</td></tr>
* <tr><td>download_lancer_image()</td><td>Download a .grp firmware image to an LPe16000/LPe16002
* adapter data using the file handler in the elxu_dwnld.c
* module.</td></tr>
* <tr><td>fat_upload()</td><td>Upload the OCe11102 FAT using the file handler in the
* elxu_dump.c module.</td></tr>
* <tr><td>ext_fat_capabilities_upld()</td><td>Upload the OCe11102 extended FAT capabilities data using
* the file handler in the elxu_dump.c module.</td></tr>
* <tr><td>ext_fat_snapshot_upload()</td><td>Upload the OCe11102 extended FAT snapshot using the file
* handler in the elxu_dump.c module.</td></tr>
* <tr><td>lancer_hba_dump_upload()</td><td>Upload the LPe16000/LPe16002 adapter data using the file
* handler in the elxu_dump.c module.</td></tr>
* </table>
*
*/