/*---------------------------------------------------------------------------
   FT1000 driver for Flarion Flash OFDM NIC Device

   Copyright (C) 2002 Flarion Technologies, All rights reserved.

   This program is free software; you can redistribute it and/or modify it
   under the terms of the GNU General Public License as published by the Free
   Software Foundation; either version 2 of the License, or (at your option) any
   later version. This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
   more details. You should have received a copy of the GNU General Public
   License along with this program; if not, write to the
   Free Software Foundation, Inc., 59 Temple Place -
   Suite 330, Boston, MA 02111-1307, USA.
  --------------------------------------------------------------------------

   Description:  This module will handshake with the DSP bootloader to
                 download the DSP runtime image.

---------------------------------------------------------------------------*/

#define __KERNEL_SYSCALLS__

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/mm.h>
#include <linux/slab.h>
#include <linux/unistd.h>
#include <linux/netdevice.h>
#include <linux/timer.h>
#include <linux/delay.h>
#include <linux/slab.h>
#include <asm/io.h>
#include <asm/uaccess.h>
#include <linux/vmalloc.h>

#include "ft1000_dev.h"
#include "ft1000.h"
#include "boot.h"

#ifdef FT_DEBUG
#define DEBUG(n, args...) printk(KERN_DEBUG args);
#else
#define DEBUG(n, args...)
#endif

#define  MAX_DSP_WAIT_LOOPS      100
#define  DSP_WAIT_SLEEP_TIME     1	/* 1 millisecond */

#define  MAX_LENGTH              0x7f0

#define  DWNLD_MAG_HANDSHAKE_LOC 0x00
#define  DWNLD_MAG_TYPE_LOC      0x01
#define  DWNLD_MAG_SIZE_LOC      0x02
#define  DWNLD_MAG_PS_HDR_LOC    0x03

#define  DWNLD_HANDSHAKE_LOC     0x02
#define  DWNLD_TYPE_LOC          0x04
#define  DWNLD_SIZE_MSW_LOC      0x06
#define  DWNLD_SIZE_LSW_LOC      0x08
#define  DWNLD_PS_HDR_LOC        0x0A

#define  HANDSHAKE_TIMEOUT_VALUE 0xF1F1
#define  HANDSHAKE_RESET_VALUE   0xFEFE	/* When DSP requests startover */
#define  HANDSHAKE_DSP_BL_READY  0xFEFE	/* At start DSP writes this when bootloader ready */
#define  HANDSHAKE_DRIVER_READY  0xFFFF	/* Driver writes after receiving 0xFEFE */
#define  HANDSHAKE_SEND_DATA     0x0000	/* DSP writes this when ready for more data */

#define  HANDSHAKE_REQUEST       0x0001	/* Request from DSP */
#define  HANDSHAKE_RESPONSE      0x0000	/* Satisfied DSP request */

#define  REQUEST_CODE_LENGTH     0x0000
#define  REQUEST_RUN_ADDRESS     0x0001
#define  REQUEST_CODE_SEGMENT    0x0002	/* In WORD count */
#define  REQUEST_DONE_BL         0x0003
#define  REQUEST_DONE_CL         0x0004
#define  REQUEST_VERSION_INFO    0x0005
#define  REQUEST_CODE_BY_VERSION 0x0006
#define  REQUEST_MAILBOX_DATA    0x0007
#define  REQUEST_FILE_CHECKSUM   0x0008

#define  STATE_START_DWNLD       0x01
#define  STATE_BOOT_DWNLD        0x02
#define  STATE_CODE_DWNLD        0x03
#define  STATE_DONE_DWNLD        0x04
#define  STATE_SECTION_PROV      0x05
#define  STATE_DONE_PROV         0x06
#define  STATE_DONE_FILE         0x07

USHORT get_handshake(struct net_device *dev, USHORT expected_value);
void put_handshake(struct net_device *dev, USHORT handshake_value);
USHORT get_request_type(struct net_device *dev);
long get_request_value(struct net_device *dev);
void put_request_value(struct net_device *dev, long lvalue);
USHORT hdr_checksum(PPSEUDO_HDR pHdr);

typedef struct _DSP_FILE_HDR {
	long build_date;
	long dsp_coff_date;
	long loader_code_address;
	long loader_code_size;
	long loader_code_end;
	long dsp_code_address;
	long dsp_code_size;
	long dsp_code_end;
	long reserved[8];
} __attribute__ ((packed)) DSP_FILE_HDR, *PDSP_FILE_HDR;

typedef struct _DSP_FILE_HDR_5 {
	long version_id;	// Version ID of this image format.
	long package_id;	// Package ID of code release.
	long build_date;	// Date/time stamp when file was built.
	long commands_offset;	// Offset to attached commands in Pseudo Hdr format.
	long loader_offset;	// Offset to bootloader code.
	long loader_code_address;	// Start address of bootloader.
	long loader_code_end;	// Where bootloader code ends.
	long loader_code_size;
	long version_data_offset;	// Offset were scrambled version data begins.
	long version_data_size;	// Size, in words, of scrambled version data.
	long nDspImages;	// Number of DSP images in file.
} __attribute__ ((packed)) DSP_FILE_HDR_5, *PDSP_FILE_HDR_5;

typedef struct _DSP_IMAGE_INFO {
	long coff_date;		// Date/time when DSP Coff image was built.
	long begin_offset;	// Offset in file where image begins.
	long end_offset;	// Offset in file where image begins.
	long run_address;	// On chip Start address of DSP code.
	long image_size;	// Size of image.
	long version;		// Embedded version # of DSP code.
} __attribute__ ((packed)) DSP_IMAGE_INFO, *PDSP_IMAGE_INFO;

typedef struct _DSP_IMAGE_INFO_V6 {
	long coff_date;		// Date/time when DSP Coff image was built.
	long begin_offset;	// Offset in file where image begins.
	long end_offset;	// Offset in file where image begins.
	long run_address;	// On chip Start address of DSP code.
	long image_size;	// Size of image.
	long version;		// Embedded version # of DSP code.
	unsigned short checksum;	// Dsp File checksum
	unsigned short pad1;
} __attribute__ ((packed)) DSP_IMAGE_INFO_V6, *PDSP_IMAGE_INFO_V6;

void card_bootload(struct net_device *dev)
{
	FT1000_INFO *info = (PFT1000_INFO) netdev_priv(dev);
	unsigned long flags;
	PULONG pdata;
	UINT size;
	UINT i;
	ULONG templong;

	DEBUG(0, "card_bootload is called\n");

	pdata = (PULONG) bootimage;
	size = sizeof(bootimage);

	// check for odd word
	if (size & 0x0003) {
		size += 4;
	}
	// Provide mutual exclusive access while reading ASIC registers.
	spin_lock_irqsave(&info->dpram_lock, flags);

	// need to set i/o base address initially and hardware will autoincrement
	ft1000_write_reg(dev, FT1000_REG_DPRAM_ADDR, FT1000_DPRAM_BASE);
	// write bytes
	for (i = 0; i < (size >> 2); i++) {
		templong = *pdata++;
		outl(templong, dev->base_addr + FT1000_REG_MAG_DPDATA);
	}

	spin_unlock_irqrestore(&info->dpram_lock, flags);
}

USHORT get_handshake(struct net_device *dev, USHORT expected_value)
{
	FT1000_INFO *info = (PFT1000_INFO) netdev_priv(dev);
	USHORT handshake;
	ULONG tempx;
	int loopcnt;

	loopcnt = 0;
	while (loopcnt < MAX_DSP_WAIT_LOOPS) {
		if (info->AsicID == ELECTRABUZZ_ID) {
			ft1000_write_reg(dev, FT1000_REG_DPRAM_ADDR,
					 DWNLD_HANDSHAKE_LOC);

			handshake = ft1000_read_reg(dev, FT1000_REG_DPRAM_DATA);
		} else {
			tempx =
				ntohl(ft1000_read_dpram_mag_32
				  (dev, DWNLD_MAG_HANDSHAKE_LOC));
			handshake = (USHORT) tempx;
		}

		if ((handshake == expected_value)
			|| (handshake == HANDSHAKE_RESET_VALUE)) {
			return handshake;
		} else {
			loopcnt++;
			mdelay(DSP_WAIT_SLEEP_TIME);
		}

	}

	return HANDSHAKE_TIMEOUT_VALUE;

}

void put_handshake(struct net_device *dev, USHORT handshake_value)
{
	FT1000_INFO *info = (PFT1000_INFO) netdev_priv(dev);
	ULONG tempx;

	if (info->AsicID == ELECTRABUZZ_ID) {
		ft1000_write_reg(dev, FT1000_REG_DPRAM_ADDR,
				 DWNLD_HANDSHAKE_LOC);
		ft1000_write_reg(dev, FT1000_REG_DPRAM_DATA, handshake_value);	/* Handshake */
	} else {
		tempx = (ULONG) handshake_value;
		tempx = ntohl(tempx);
		ft1000_write_dpram_mag_32(dev, DWNLD_MAG_HANDSHAKE_LOC, tempx);	/* Handshake */
	}
}

USHORT get_request_type(struct net_device *dev)
{
	FT1000_INFO *info = (PFT1000_INFO) netdev_priv(dev);
	USHORT request_type;
	ULONG tempx;

	if (info->AsicID == ELECTRABUZZ_ID) {
		ft1000_write_reg(dev, FT1000_REG_DPRAM_ADDR, DWNLD_TYPE_LOC);
		request_type = ft1000_read_reg(dev, FT1000_REG_DPRAM_DATA);
	} else {
		tempx = ft1000_read_dpram_mag_32(dev, DWNLD_MAG_TYPE_LOC);
		tempx = ntohl(tempx);
		request_type = (USHORT) tempx;
	}

	return request_type;

}

long get_request_value(struct net_device *dev)
{
	FT1000_INFO *info = (PFT1000_INFO) netdev_priv(dev);
	long value;
	USHORT w_val;

	if (info->AsicID == ELECTRABUZZ_ID) {
		ft1000_write_reg(dev, FT1000_REG_DPRAM_ADDR,
				 DWNLD_SIZE_MSW_LOC);

		w_val = ft1000_read_reg(dev, FT1000_REG_DPRAM_DATA);

		value = (long)(w_val << 16);

		ft1000_write_reg(dev, FT1000_REG_DPRAM_ADDR,
				 DWNLD_SIZE_LSW_LOC);

		w_val = ft1000_read_reg(dev, FT1000_REG_DPRAM_DATA);

		value = (long)(value | w_val);
	} else {
		value = ft1000_read_dpram_mag_32(dev, DWNLD_MAG_SIZE_LOC);
		value = ntohl(value);
	}

	return value;

}

void put_request_value(struct net_device *dev, long lvalue)
{
	FT1000_INFO *info = (PFT1000_INFO) netdev_priv(dev);
	USHORT size;
	ULONG tempx;

	if (info->AsicID == ELECTRABUZZ_ID) {
		size = (USHORT) (lvalue >> 16);

		ft1000_write_reg(dev, FT1000_REG_DPRAM_ADDR,
				 DWNLD_SIZE_MSW_LOC);

		ft1000_write_reg(dev, FT1000_REG_DPRAM_DATA, size);

		size = (USHORT) (lvalue);

		ft1000_write_reg(dev, FT1000_REG_DPRAM_ADDR,
				 DWNLD_SIZE_LSW_LOC);

		ft1000_write_reg(dev, FT1000_REG_DPRAM_DATA, size);
	} else {
		tempx = ntohl(lvalue);
		ft1000_write_dpram_mag_32(dev, DWNLD_MAG_SIZE_LOC, tempx);	/* Handshake */
	}

}

USHORT hdr_checksum(PPSEUDO_HDR pHdr)
{
	USHORT *usPtr = (USHORT *) pHdr;
	USHORT chksum;

	chksum = ((((((usPtr[0] ^ usPtr[1]) ^ usPtr[2]) ^ usPtr[3]) ^
			usPtr[4]) ^ usPtr[5]) ^ usPtr[6]);

	return chksum;
}

int card_download(struct net_device *dev, void *pFileStart, UINT FileLength)
{
	FT1000_INFO *info = (PFT1000_INFO) netdev_priv(dev);
	int Status = SUCCESS;
	USHORT DspWordCnt = 0;
	UINT uiState;
	USHORT handshake;
	PPSEUDO_HDR pHdr;
	USHORT usHdrLength;
	PDSP_FILE_HDR pFileHdr;
	long word_length;
	USHORT request;
	USHORT temp;
	PPROV_RECORD pprov_record;
	PUCHAR pbuffer;
	PDSP_FILE_HDR_5 pFileHdr5;
	PDSP_IMAGE_INFO pDspImageInfo = NULL;
	PDSP_IMAGE_INFO_V6 pDspImageInfoV6 = NULL;
	long requested_version;
	BOOLEAN bGoodVersion = 0;
	PDRVMSG pMailBoxData;
	USHORT *pUsData = NULL;
	USHORT *pUsFile = NULL;
	UCHAR *pUcFile = NULL;
	UCHAR *pBootEnd = NULL;
	UCHAR *pCodeEnd = NULL;
	int imageN;
	long file_version;
	long loader_code_address = 0;
	long loader_code_size = 0;
	long run_address = 0;
	long run_size = 0;
	unsigned long flags;
	unsigned long templong;
	unsigned long image_chksum = 0;

	//
	// Get version id of file, at first 4 bytes of file, for newer files.
	//
	file_version = *(long *)pFileStart;

	uiState = STATE_START_DWNLD;

	pFileHdr = (PDSP_FILE_HDR) pFileStart;
	pFileHdr5 = (PDSP_FILE_HDR_5) pFileStart;

	switch (file_version) {
	case 5:
	case 6:
		pUsFile =
			(USHORT *) ((long)pFileStart + pFileHdr5->loader_offset);
		pUcFile =
			(UCHAR *) ((long)pFileStart + pFileHdr5->loader_offset);

		pBootEnd =
			(UCHAR *) ((long)pFileStart + pFileHdr5->loader_code_end);

		loader_code_address = pFileHdr5->loader_code_address;
		loader_code_size = pFileHdr5->loader_code_size;
		bGoodVersion = FALSE;
		break;

	default:
		Status = FAILURE;
		break;
	}

	while ((Status == SUCCESS) && (uiState != STATE_DONE_FILE)) {

		switch (uiState) {
		case STATE_START_DWNLD:

			handshake = get_handshake(dev, HANDSHAKE_DSP_BL_READY);

			if (handshake == HANDSHAKE_DSP_BL_READY) {
				put_handshake(dev, HANDSHAKE_DRIVER_READY);
			} else {
				Status = FAILURE;
			}

			uiState = STATE_BOOT_DWNLD;

			break;

		case STATE_BOOT_DWNLD:
			handshake = get_handshake(dev, HANDSHAKE_REQUEST);
			if (handshake == HANDSHAKE_REQUEST) {
				/*
				 * Get type associated with the request.
				 */
				request = get_request_type(dev);
				switch (request) {
				case REQUEST_RUN_ADDRESS:
					put_request_value(dev,
							  loader_code_address);
					break;
				case REQUEST_CODE_LENGTH:
					put_request_value(dev,
							  loader_code_size);
					break;
				case REQUEST_DONE_BL:
					/* Reposition ptrs to beginning of code section */
					pUsFile = (USHORT *) ((long)pBootEnd);
					pUcFile = (UCHAR *) ((long)pBootEnd);
					uiState = STATE_CODE_DWNLD;
					break;
				case REQUEST_CODE_SEGMENT:
					word_length = get_request_value(dev);
					if (word_length > MAX_LENGTH) {
						Status = FAILURE;
						break;
					}
					if ((word_length * 2 + (long)pUcFile) >
						(long)pBootEnd) {
						/*
						 * Error, beyond boot code range.
						 */
						Status = FAILURE;
						break;
					}
					// Provide mutual exclusive access while reading ASIC registers.
					spin_lock_irqsave(&info->dpram_lock,
							  flags);
					if (file_version == 5) {
						/*
						 * Position ASIC DPRAM auto-increment pointer.
						 */
						ft1000_write_reg(dev,
								 FT1000_REG_DPRAM_ADDR,
								 DWNLD_PS_HDR_LOC);

						for (; word_length > 0; word_length--) {	/* In words */
							//temp = *pUsFile;
							//temp = RtlUshortByteSwap(temp);
							ft1000_write_reg(dev,
									 FT1000_REG_DPRAM_DATA,
									 *pUsFile);
							pUsFile++;
							pUcFile += 2;
							DspWordCnt++;
						}
					} else {
						/*
						 * Position ASIC DPRAM auto-increment pointer.
						 */
						outw(DWNLD_MAG_PS_HDR_LOC,
							 dev->base_addr +
							 FT1000_REG_DPRAM_ADDR);
						if (word_length & 0x01) {
							word_length++;
						}
						word_length = word_length / 2;

						for (; word_length > 0; word_length--) {	/* In words */
							templong = *pUsFile++;
							templong |=
								(*pUsFile++ << 16);
							pUcFile += 4;
							outl(templong,
								 dev->base_addr +
								 FT1000_REG_MAG_DPDATAL);
						}
					}
					spin_unlock_irqrestore(&info->
								   dpram_lock,
								   flags);
					break;
				default:
					Status = FAILURE;
					break;
				}
				put_handshake(dev, HANDSHAKE_RESPONSE);
			} else {
				Status = FAILURE;
			}

			break;

		case STATE_CODE_DWNLD:
			handshake = get_handshake(dev, HANDSHAKE_REQUEST);
			if (handshake == HANDSHAKE_REQUEST) {
				/*
				 * Get type associated with the request.
				 */
				request = get_request_type(dev);
				switch (request) {
				case REQUEST_FILE_CHECKSUM:
					DEBUG(0,
						  "ft1000_dnld: REQUEST_FOR_CHECKSUM\n");
					put_request_value(dev, image_chksum);
					break;
				case REQUEST_RUN_ADDRESS:
					if (bGoodVersion) {
						put_request_value(dev,
								  run_address);
					} else {
						Status = FAILURE;
						break;
					}
					break;
				case REQUEST_CODE_LENGTH:
					if (bGoodVersion) {
						put_request_value(dev,
								  run_size);
					} else {
						Status = FAILURE;
						break;
					}
					break;
				case REQUEST_DONE_CL:
					/* Reposition ptrs to beginning of provisioning section */
					switch (file_version) {
					case 5:
					case 6:
						pUsFile =
							(USHORT *) ((long)pFileStart
								+
								pFileHdr5->
								commands_offset);
						pUcFile =
							(UCHAR *) ((long)pFileStart
								   +
								   pFileHdr5->
								   commands_offset);
						break;
					default:
						Status = FAILURE;
						break;
					}
					uiState = STATE_DONE_DWNLD;
					break;
				case REQUEST_CODE_SEGMENT:
					if (!bGoodVersion) {
						Status = FAILURE;
						break;
					}
					word_length = get_request_value(dev);
					if (word_length > MAX_LENGTH) {
						Status = FAILURE;
						break;
					}
					if ((word_length * 2 + (long)pUcFile) >
						(long)pCodeEnd) {
						/*
						 * Error, beyond boot code range.
						 */
						Status = FAILURE;
						break;
					}
					if (file_version == 5) {
						/*
						 * Position ASIC DPRAM auto-increment pointer.
						 */
						ft1000_write_reg(dev,
								 FT1000_REG_DPRAM_ADDR,
								 DWNLD_PS_HDR_LOC);

						for (; word_length > 0; word_length--) {	/* In words */
							//temp = *pUsFile;
							//temp = RtlUshortByteSwap(temp);
							ft1000_write_reg(dev,
									 FT1000_REG_DPRAM_DATA,
									 *pUsFile);
							pUsFile++;
							pUcFile += 2;
							DspWordCnt++;
						}
					} else {
						/*
						 * Position ASIC DPRAM auto-increment pointer.
						 */
						outw(DWNLD_MAG_PS_HDR_LOC,
							 dev->base_addr +
							 FT1000_REG_DPRAM_ADDR);
						if (word_length & 0x01) {
							word_length++;
						}
						word_length = word_length / 2;

						for (; word_length > 0; word_length--) {	/* In words */
							templong = *pUsFile++;
							templong |=
								(*pUsFile++ << 16);
							pUcFile += 4;
							outl(templong,
								 dev->base_addr +
								 FT1000_REG_MAG_DPDATAL);
						}
					}
					break;

				case REQUEST_MAILBOX_DATA:
					// Convert length from byte count to word count. Make sure we round up.
					word_length =
						(long)(info->DSPInfoBlklen + 1) / 2;
					put_request_value(dev, word_length);
					pMailBoxData =
						(PDRVMSG) & info->DSPInfoBlk[0];
					pUsData =
						(USHORT *) & pMailBoxData->data[0];
					// Provide mutual exclusive access while reading ASIC registers.
					spin_lock_irqsave(&info->dpram_lock,
							  flags);
					if (file_version == 5) {
						/*
						 * Position ASIC DPRAM auto-increment pointer.
						 */
						ft1000_write_reg(dev,
								 FT1000_REG_DPRAM_ADDR,
								 DWNLD_PS_HDR_LOC);

						for (; word_length > 0; word_length--) {	/* In words */
							temp = ntohs(*pUsData);
							ft1000_write_reg(dev,
									 FT1000_REG_DPRAM_DATA,
									 temp);
							pUsData++;
						}
					} else {
						/*
						 * Position ASIC DPRAM auto-increment pointer.
						 */
						outw(DWNLD_MAG_PS_HDR_LOC,
							 dev->base_addr +
							 FT1000_REG_DPRAM_ADDR);
						if (word_length & 0x01) {
							word_length++;
						}
						word_length = word_length / 2;

						for (; word_length > 0; word_length--) {	/* In words */
							templong = *pUsData++;
							templong |=
								(*pUsData++ << 16);
							outl(templong,
								 dev->base_addr +
								 FT1000_REG_MAG_DPDATAL);
						}
					}
					spin_unlock_irqrestore(&info->
								   dpram_lock,
								   flags);
					break;

				case REQUEST_VERSION_INFO:
					word_length =
						pFileHdr5->version_data_size;
					put_request_value(dev, word_length);
					pUsFile =
						(USHORT *) ((long)pFileStart +
							pFileHdr5->
							version_data_offset);
					// Provide mutual exclusive access while reading ASIC registers.
					spin_lock_irqsave(&info->dpram_lock,
							  flags);
					if (file_version == 5) {
						/*
						 * Position ASIC DPRAM auto-increment pointer.
						 */
						ft1000_write_reg(dev,
								 FT1000_REG_DPRAM_ADDR,
								 DWNLD_PS_HDR_LOC);

						for (; word_length > 0; word_length--) {	/* In words */
							ft1000_write_reg(dev,
									 FT1000_REG_DPRAM_DATA,
									 *pUsFile
									 /*temp */
								);
							pUsFile++;
						}
					} else {
						/*
						 * Position ASIC DPRAM auto-increment pointer.
						 */
						outw(DWNLD_MAG_PS_HDR_LOC,
							 dev->base_addr +
							 FT1000_REG_DPRAM_ADDR);
						if (word_length & 0x01) {
							word_length++;
						}
						word_length = word_length / 2;

						for (; word_length > 0; word_length--) {	/* In words */
							templong =
								ntohs(*pUsFile++);
							temp =
								ntohs(*pUsFile++);
							templong |=
								(temp << 16);
							outl(templong,
								 dev->base_addr +
								 FT1000_REG_MAG_DPDATAL);
						}
					}
					spin_unlock_irqrestore(&info->
								   dpram_lock,
								   flags);
					break;

				case REQUEST_CODE_BY_VERSION:
					bGoodVersion = FALSE;
					requested_version =
						get_request_value(dev);
					if (file_version == 5) {
						pDspImageInfo =
							(PDSP_IMAGE_INFO) ((long)
									   pFileStart
									   +
									   sizeof
									   (DSP_FILE_HDR_5));
						for (imageN = 0;
							 imageN <
							 pFileHdr5->nDspImages;
							 imageN++) {
							if (pDspImageInfo->
								version ==
								requested_version) {
								bGoodVersion =
									TRUE;
								pUsFile =
									(USHORT
									 *) ((long)
									 pFileStart
									 +
									 pDspImageInfo->
									 begin_offset);
								pUcFile =
									(UCHAR
									 *) ((long)
									 pFileStart
									 +
									 pDspImageInfo->
									 begin_offset);
								pCodeEnd =
									(UCHAR
									 *) ((long)
									 pFileStart
									 +
									 pDspImageInfo->
									 end_offset);
								run_address =
									pDspImageInfo->
									run_address;
								run_size =
									pDspImageInfo->
									image_size;
								break;
							}
							pDspImageInfo++;
						}
					} else {
						pDspImageInfoV6 =
							(PDSP_IMAGE_INFO_V6) ((long)
									  pFileStart
									  +
									  sizeof
									  (DSP_FILE_HDR_5));
						for (imageN = 0;
							 imageN <
							 pFileHdr5->nDspImages;
							 imageN++) {
							temp = (USHORT)
								(pDspImageInfoV6->
								 version);
							templong = temp;
							temp = (USHORT)
								(pDspImageInfoV6->
								 version >> 16);
							templong |=
								(temp << 16);
							if (templong ==
								requested_version) {
								bGoodVersion =
									TRUE;
								pUsFile =
									(USHORT
									 *) ((long)
									 pFileStart
									 +
									 pDspImageInfoV6->
									 begin_offset);
								pUcFile =
									(UCHAR
									 *) ((long)
									 pFileStart
									 +
									 pDspImageInfoV6->
									 begin_offset);
								pCodeEnd =
									(UCHAR
									 *) ((long)
									 pFileStart
									 +
									 pDspImageInfoV6->
									 end_offset);
								run_address =
									pDspImageInfoV6->
									run_address;
								run_size =
									pDspImageInfoV6->
									image_size;
								image_chksum =
									(ULONG)
									pDspImageInfoV6->
									checksum;
								DEBUG(0,
									  "ft1000_dnld: image_chksum = 0x%8x\n",
									  (unsigned
									   int)
									  image_chksum);
								break;
							}
							pDspImageInfoV6++;
						}
					}
					if (!bGoodVersion) {
						/*
						 * Error, beyond boot code range.
						 */
						Status = FAILURE;
						break;
					}
					break;

				default:
					Status = FAILURE;
					break;
				}
				put_handshake(dev, HANDSHAKE_RESPONSE);
			} else {
				Status = FAILURE;
			}

			break;

		case STATE_DONE_DWNLD:
			if (((UINT) (pUcFile) - (UINT) pFileStart) >=
				(UINT) FileLength) {
				uiState = STATE_DONE_FILE;
				break;
			}

			pHdr = (PPSEUDO_HDR) pUsFile;

			if (pHdr->portdest == 0x80	/* DspOAM */
				&& (pHdr->portsrc == 0x00	/* Driver */
				|| pHdr->portsrc == 0x10 /* FMM */ )) {
				uiState = STATE_SECTION_PROV;
			} else {
				DEBUG(1,
					  "FT1000:download:Download error: Bad Port IDs in Pseudo Record\n");
				DEBUG(1, "\t Port Source = 0x%2.2x\n",
					  pHdr->portsrc);
				DEBUG(1, "\t Port Destination = 0x%2.2x\n",
					  pHdr->portdest);
				Status = FAILURE;
			}

			break;

		case STATE_SECTION_PROV:

			pHdr = (PPSEUDO_HDR) pUcFile;

			if (pHdr->checksum == hdr_checksum(pHdr)) {
				if (pHdr->portdest != 0x80 /* Dsp OAM */ ) {
					uiState = STATE_DONE_PROV;
					break;
				}
				usHdrLength = ntohs(pHdr->length);	/* Byte length for PROV records */

				// Get buffer for provisioning data
				pbuffer =
					kmalloc((usHdrLength + sizeof(PSEUDO_HDR)),
						GFP_ATOMIC);
				if (pbuffer) {
					memcpy(pbuffer, (void *)pUcFile,
						   (UINT) (usHdrLength +
							   sizeof(PSEUDO_HDR)));
					// link provisioning data
					pprov_record =
						kmalloc(sizeof(PROV_RECORD),
							GFP_ATOMIC);
					if (pprov_record) {
						pprov_record->pprov_data =
							pbuffer;
						list_add_tail(&pprov_record->
								  list,
								  &info->prov_list);
						// Move to next entry if available
						pUcFile =
							(UCHAR *) ((UINT) pUcFile +
								   (UINT) ((usHdrLength + 1) & 0xFFFFFFFE) + sizeof(PSEUDO_HDR));
						if ((UINT) (pUcFile) -
							(UINT) (pFileStart) >=
							(UINT) FileLength) {
							uiState =
								STATE_DONE_FILE;
						}
					} else {
						kfree(pbuffer);
						Status = FAILURE;
					}
				} else {
					Status = FAILURE;
				}
			} else {
				/* Checksum did not compute */
				Status = FAILURE;
			}

			break;

		case STATE_DONE_PROV:
			uiState = STATE_DONE_FILE;
			break;

		default:
			Status = FAILURE;
			break;
		}		/* End Switch */

	}			/* End while */

	return Status;

}