Commit 6f953fbb authored by Marek Belisko's avatar Marek Belisko Committed by Greg Kroah-Hartman

staging: ft1000: Fix indentation in scram_dnldr() function.

Signed-off-by: default avatarMarek Belisko <marek.belisko@open-nandra.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@suse.de>
parent 857af455
...@@ -694,455 +694,542 @@ static u32 write_blk_fifo(struct ft1000_device *ft1000dev, u16 **pUsFile, ...@@ -694,455 +694,542 @@ static u32 write_blk_fifo(struct ft1000_device *ft1000dev, u16 **pUsFile,
// Returns: status - return code // Returns: status - return code
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
u16 scram_dnldr(struct ft1000_device *ft1000dev, void *pFileStart, u32 FileLength) u16 scram_dnldr(struct ft1000_device *ft1000dev, void *pFileStart,
u32 FileLength)
{ {
u16 status = STATUS_SUCCESS; u16 status = STATUS_SUCCESS;
u32 state; u32 state;
u16 handshake; u16 handshake;
struct pseudo_hdr *pseudo_header; struct pseudo_hdr *pseudo_header;
u16 pseudo_header_len; u16 pseudo_header_len;
long word_length; long word_length;
u16 request; u16 request;
u16 temp; u16 temp;
u16 tempword; u16 tempword;
struct dsp_file_hdr *file_hdr; struct dsp_file_hdr *file_hdr;
struct dsp_image_info *dsp_img_info = NULL; struct dsp_image_info *dsp_img_info = NULL;
long requested_version; long requested_version;
bool correct_version; bool correct_version;
struct drv_msg *mailbox_data; struct drv_msg *mailbox_data;
u16 *data = NULL; u16 *data = NULL;
u16 *s_file = NULL; u16 *s_file = NULL;
u8 *c_file = NULL; u8 *c_file = NULL;
u8 *boot_end = NULL, *code_end= NULL; u8 *boot_end = NULL, *code_end = NULL;
int image; int image;
long loader_code_address, loader_code_size = 0; long loader_code_address, loader_code_size = 0;
long run_address = 0, run_size = 0; long run_address = 0, run_size = 0;
u32 templong; u32 templong;
u32 image_chksum = 0; u32 image_chksum = 0;
u16 dpram = 0; u16 dpram = 0;
u8 *pbuffer; u8 *pbuffer;
struct prov_record *pprov_record; struct prov_record *pprov_record;
struct ft1000_info *pft1000info = netdev_priv(ft1000dev->net); struct ft1000_info *pft1000info = netdev_priv(ft1000dev->net);
DEBUG("Entered scram_dnldr...\n"); DEBUG("Entered scram_dnldr...\n");
pft1000info->fcodeldr = 0;
pft1000info->usbboot = 0;
pft1000info->dspalive = 0xffff;
pft1000info->fcodeldr = 0; //
pft1000info->usbboot = 0; // Get version id of file, at first 4 bytes of file, for newer files.
pft1000info->dspalive = 0xffff; //
state = STATE_START_DWNLD;
// file_hdr = (struct dsp_file_hdr *)pFileStart;
// Get version id of file, at first 4 bytes of file, for newer files.
//
state = STATE_START_DWNLD; ft1000_write_register(ft1000dev, 0x800, FT1000_REG_MAG_WATERMARK);
file_hdr = (struct dsp_file_hdr *)pFileStart; s_file = (u16 *) (pFileStart + file_hdr->loader_offset);
c_file = (u8 *) (pFileStart + file_hdr->loader_offset);
ft1000_write_register (ft1000dev, 0x800, FT1000_REG_MAG_WATERMARK); boot_end = (u8 *) (pFileStart + file_hdr->loader_code_end);
s_file = (u16 *)(pFileStart + file_hdr->loader_offset); loader_code_address = file_hdr->loader_code_address;
c_file = (u8 *)(pFileStart + file_hdr->loader_offset); loader_code_size = file_hdr->loader_code_size;
correct_version = FALSE;
while ((status == STATUS_SUCCESS) && (state != STATE_DONE_FILE)) {
switch (state) {
case STATE_START_DWNLD:
DEBUG("FT1000:STATE_START_DWNLD\n");
if (pft1000info->usbboot)
handshake =
get_handshake_usb(ft1000dev,
HANDSHAKE_DSP_BL_READY);
else
handshake =
get_handshake(ft1000dev,
HANDSHAKE_DSP_BL_READY);
if (handshake == HANDSHAKE_DSP_BL_READY) {
DEBUG
("scram_dnldr: handshake is HANDSHAKE_DSP_BL_READY, call put_handshake(HANDSHAKE_DRIVER_READY)\n");
put_handshake(ft1000dev,
HANDSHAKE_DRIVER_READY);
} else {
DEBUG
("FT1000:download:Download error: Handshake failed\n");
status = STATUS_FAILURE;
}
boot_end = (u8 *)(pFileStart + file_hdr->loader_code_end); state = STATE_BOOT_DWNLD;
loader_code_address = file_hdr->loader_code_address; break;
loader_code_size = file_hdr->loader_code_size;
correct_version = FALSE;
while ((status == STATUS_SUCCESS) && (state != STATE_DONE_FILE)) case STATE_BOOT_DWNLD:
{ DEBUG("FT1000:STATE_BOOT_DWNLD\n");
switch (state) pft1000info->bootmode = 1;
{ handshake = get_handshake(ft1000dev, HANDSHAKE_REQUEST);
case STATE_START_DWNLD: if (handshake == HANDSHAKE_REQUEST) {
DEBUG("FT1000:STATE_START_DWNLD\n"); /*
if (pft1000info->usbboot) * Get type associated with the request.
handshake = get_handshake_usb(ft1000dev, HANDSHAKE_DSP_BL_READY); */
else request = get_request_type(ft1000dev);
handshake = get_handshake(ft1000dev, HANDSHAKE_DSP_BL_READY); switch (request) {
case REQUEST_RUN_ADDRESS:
if (handshake == HANDSHAKE_DSP_BL_READY) DEBUG("FT1000:REQUEST_RUN_ADDRESS\n");
{ put_request_value(ft1000dev,
DEBUG("scram_dnldr: handshake is HANDSHAKE_DSP_BL_READY, call put_handshake(HANDSHAKE_DRIVER_READY)\n"); loader_code_address);
put_handshake(ft1000dev, HANDSHAKE_DRIVER_READY); break;
} case REQUEST_CODE_LENGTH:
else DEBUG("FT1000:REQUEST_CODE_LENGTH\n");
{ put_request_value(ft1000dev,
DEBUG("FT1000:download:Download error: Handshake failed\n"); loader_code_size);
status = STATUS_FAILURE; break;
} case REQUEST_DONE_BL:
DEBUG("FT1000:REQUEST_DONE_BL\n");
state = STATE_BOOT_DWNLD; /* Reposition ptrs to beginning of code section */
s_file = (u16 *) (boot_end);
break; c_file = (u8 *) (boot_end);
//DEBUG("FT1000:download:s_file = 0x%8x\n", (int)s_file);
case STATE_BOOT_DWNLD: //DEBUG("FT1000:download:c_file = 0x%8x\n", (int)c_file);
DEBUG("FT1000:STATE_BOOT_DWNLD\n"); state = STATE_CODE_DWNLD;
pft1000info->bootmode = 1; pft1000info->fcodeldr = 1;
handshake = get_handshake(ft1000dev, HANDSHAKE_REQUEST); break;
if (handshake == HANDSHAKE_REQUEST) case REQUEST_CODE_SEGMENT:
{ //DEBUG("FT1000:REQUEST_CODE_SEGMENT\n");
/* word_length =
* Get type associated with the request. get_request_value(ft1000dev);
*/ //DEBUG("FT1000:word_length = 0x%x\n", (int)word_length);
request = get_request_type(ft1000dev); //NdisMSleep (100);
switch (request) if (word_length > MAX_LENGTH) {
{ DEBUG
case REQUEST_RUN_ADDRESS: ("FT1000:download:Download error: Max length exceeded\n");
DEBUG("FT1000:REQUEST_RUN_ADDRESS\n"); status = STATUS_FAILURE;
put_request_value(ft1000dev, loader_code_address); break;
break; }
case REQUEST_CODE_LENGTH: if ((word_length * 2 + c_file) >
DEBUG("FT1000:REQUEST_CODE_LENGTH\n"); boot_end) {
put_request_value(ft1000dev, loader_code_size); /*
break; * Error, beyond boot code range.
case REQUEST_DONE_BL: */
DEBUG("FT1000:REQUEST_DONE_BL\n"); DEBUG
/* Reposition ptrs to beginning of code section */ ("FT1000:download:Download error: Requested len=%d exceeds BOOT code boundry.\n",
s_file = (u16 *)(boot_end); (int)word_length);
c_file = (u8 *)(boot_end); status = STATUS_FAILURE;
//DEBUG("FT1000:download:s_file = 0x%8x\n", (int)s_file); break;
//DEBUG("FT1000:download:c_file = 0x%8x\n", (int)c_file); }
state = STATE_CODE_DWNLD; /*
pft1000info->fcodeldr = 1; * Position ASIC DPRAM auto-increment pointer.
break; */
case REQUEST_CODE_SEGMENT: dpram = (u16) DWNLD_MAG1_PS_HDR_LOC;
//DEBUG("FT1000:REQUEST_CODE_SEGMENT\n");
word_length = get_request_value(ft1000dev);
//DEBUG("FT1000:word_length = 0x%x\n", (int)word_length);
//NdisMSleep (100);
if (word_length > MAX_LENGTH)
{
DEBUG("FT1000:download:Download error: Max length exceeded\n");
status = STATUS_FAILURE;
break;
}
if ( (word_length*2 + c_file) > boot_end)
{
/*
* Error, beyond boot code range.
*/
DEBUG("FT1000:download:Download error: Requested len=%d exceeds BOOT code boundry.\n",
(int)word_length);
status = STATUS_FAILURE;
break;
}
/*
* Position ASIC DPRAM auto-increment pointer.
*/
dpram = (u16)DWNLD_MAG1_PS_HDR_LOC;
if (word_length & 0x1) if (word_length & 0x1)
word_length++; word_length++;
word_length = word_length / 2; word_length = word_length / 2;
status = write_blk(ft1000dev, &s_file, &c_file, word_length); status =
//DEBUG("write_blk returned %d\n", status); write_blk(ft1000dev, &s_file,
break; &c_file, word_length);
default: //DEBUG("write_blk returned %d\n", status);
DEBUG("FT1000:download:Download error: Bad request type=%d in BOOT download state.\n",request); break;
status = STATUS_FAILURE; default:
break; DEBUG
} ("FT1000:download:Download error: Bad request type=%d in BOOT download state.\n",
if (pft1000info->usbboot) request);
put_handshake_usb(ft1000dev, HANDSHAKE_RESPONSE); status = STATUS_FAILURE;
else break;
put_handshake(ft1000dev, HANDSHAKE_RESPONSE); }
} if (pft1000info->usbboot)
else put_handshake_usb(ft1000dev,
{ HANDSHAKE_RESPONSE);
DEBUG("FT1000:download:Download error: Handshake failed\n"); else
status = STATUS_FAILURE; put_handshake(ft1000dev,
} HANDSHAKE_RESPONSE);
} else {
break; DEBUG
("FT1000:download:Download error: Handshake failed\n");
case STATE_CODE_DWNLD: status = STATUS_FAILURE;
//DEBUG("FT1000:STATE_CODE_DWNLD\n"); }
pft1000info->bootmode = 0;
if (pft1000info->usbboot) break;
handshake = get_handshake_usb(ft1000dev, HANDSHAKE_REQUEST);
else case STATE_CODE_DWNLD:
handshake = get_handshake(ft1000dev, HANDSHAKE_REQUEST); //DEBUG("FT1000:STATE_CODE_DWNLD\n");
if (handshake == HANDSHAKE_REQUEST) pft1000info->bootmode = 0;
{ if (pft1000info->usbboot)
/* handshake =
* Get type associated with the request. get_handshake_usb(ft1000dev,
*/ HANDSHAKE_REQUEST);
if (pft1000info->usbboot) else
request = get_request_type_usb(ft1000dev); handshake =
else get_handshake(ft1000dev, HANDSHAKE_REQUEST);
request = get_request_type(ft1000dev); if (handshake == HANDSHAKE_REQUEST) {
switch (request) /*
{ * Get type associated with the request.
case REQUEST_FILE_CHECKSUM: */
DEBUG("FT1000:download:image_chksum = 0x%8x\n", image_chksum); if (pft1000info->usbboot)
put_request_value(ft1000dev, image_chksum); request =
break; get_request_type_usb(ft1000dev);
case REQUEST_RUN_ADDRESS: else
DEBUG("FT1000:download: REQUEST_RUN_ADDRESS\n"); request = get_request_type(ft1000dev);
if (correct_version) switch (request) {
{ case REQUEST_FILE_CHECKSUM:
DEBUG("FT1000:download:run_address = 0x%8x\n", (int)run_address); DEBUG
put_request_value(ft1000dev, run_address); ("FT1000:download:image_chksum = 0x%8x\n",
} image_chksum);
else put_request_value(ft1000dev,
{ image_chksum);
DEBUG("FT1000:download:Download error: Got Run address request before image offset request.\n"); break;
status = STATUS_FAILURE; case REQUEST_RUN_ADDRESS:
break; DEBUG
} ("FT1000:download: REQUEST_RUN_ADDRESS\n");
break; if (correct_version) {
case REQUEST_CODE_LENGTH: DEBUG
DEBUG("FT1000:download:REQUEST_CODE_LENGTH\n"); ("FT1000:download:run_address = 0x%8x\n",
if (correct_version) (int)run_address);
{ put_request_value(ft1000dev,
DEBUG("FT1000:download:run_size = 0x%8x\n", (int)run_size); run_address);
put_request_value(ft1000dev, run_size); } else {
} DEBUG
else ("FT1000:download:Download error: Got Run address request before image offset request.\n");
{ status = STATUS_FAILURE;
DEBUG("FT1000:download:Download error: Got Size request before image offset request.\n"); break;
status = STATUS_FAILURE; }
break; break;
} case REQUEST_CODE_LENGTH:
break; DEBUG
case REQUEST_DONE_CL: ("FT1000:download:REQUEST_CODE_LENGTH\n");
pft1000info->usbboot = 3; if (correct_version) {
/* Reposition ptrs to beginning of provisioning section */ DEBUG
s_file = (u16 *)(pFileStart + file_hdr->commands_offset); ("FT1000:download:run_size = 0x%8x\n",
c_file = (u8 *)(pFileStart + file_hdr->commands_offset); (int)run_size);
state = STATE_DONE_DWNLD; put_request_value(ft1000dev,
break; run_size);
case REQUEST_CODE_SEGMENT: } else {
//DEBUG("FT1000:download: REQUEST_CODE_SEGMENT - CODELOADER\n"); DEBUG
if (!correct_version) ("FT1000:download:Download error: Got Size request before image offset request.\n");
{ status = STATUS_FAILURE;
DEBUG("FT1000:download:Download error: Got Code Segment request before image offset request.\n"); break;
status = STATUS_FAILURE; }
break; break;
} case REQUEST_DONE_CL:
pft1000info->usbboot = 3;
word_length = get_request_value(ft1000dev); /* Reposition ptrs to beginning of provisioning section */
//DEBUG("FT1000:download:word_length = %d\n", (int)word_length); s_file =
if (word_length > MAX_LENGTH) (u16 *) (pFileStart +
{ file_hdr->commands_offset);
DEBUG("FT1000:download:Download error: Max length exceeded\n"); c_file =
status = STATUS_FAILURE; (u8 *) (pFileStart +
break; file_hdr->commands_offset);
} state = STATE_DONE_DWNLD;
if ( (word_length*2 + c_file) > code_end) break;
{ case REQUEST_CODE_SEGMENT:
/* //DEBUG("FT1000:download: REQUEST_CODE_SEGMENT - CODELOADER\n");
* Error, beyond boot code range. if (!correct_version) {
*/ DEBUG
DEBUG("FT1000:download:Download error: Requested len=%d exceeds DSP code boundry.\n", ("FT1000:download:Download error: Got Code Segment request before image offset request.\n");
(int)word_length); status = STATUS_FAILURE;
status = STATUS_FAILURE; break;
break; }
}
/* word_length =
* Position ASIC DPRAM auto-increment pointer. get_request_value(ft1000dev);
*/ //DEBUG("FT1000:download:word_length = %d\n", (int)word_length);
dpram = (u16)DWNLD_MAG1_PS_HDR_LOC; if (word_length > MAX_LENGTH) {
if (word_length & 0x1) DEBUG
word_length++; ("FT1000:download:Download error: Max length exceeded\n");
word_length = word_length / 2; status = STATUS_FAILURE;
break;
write_blk_fifo (ft1000dev, &s_file, &c_file, word_length); }
if (pft1000info->usbboot == 0) if ((word_length * 2 + c_file) >
pft1000info->usbboot++; code_end) {
if (pft1000info->usbboot == 1) { /*
tempword = 0; * Error, beyond boot code range.
ft1000_write_dpram16 (ft1000dev, DWNLD_MAG1_PS_HDR_LOC, tempword, 0); */
} DEBUG
("FT1000:download:Download error: Requested len=%d exceeds DSP code boundry.\n",
break; (int)word_length);
status = STATUS_FAILURE;
case REQUEST_MAILBOX_DATA: break;
DEBUG("FT1000:download: REQUEST_MAILBOX_DATA\n"); }
// Convert length from byte count to word count. Make sure we round up. /*
word_length = (long)(pft1000info->DSPInfoBlklen + 1)/2; * Position ASIC DPRAM auto-increment pointer.
put_request_value(ft1000dev, word_length); */
mailbox_data = (struct drv_msg *)&(pft1000info->DSPInfoBlk[0]); dpram = (u16) DWNLD_MAG1_PS_HDR_LOC;
/* if (word_length & 0x1)
* Position ASIC DPRAM auto-increment pointer. word_length++;
*/ word_length = word_length / 2;
write_blk_fifo(ft1000dev, &s_file,
data = (u16 *)&mailbox_data->data[0]; &c_file, word_length);
dpram = (u16)DWNLD_MAG1_PS_HDR_LOC; if (pft1000info->usbboot == 0)
if (word_length & 0x1) pft1000info->usbboot++;
word_length++; if (pft1000info->usbboot == 1) {
tempword = 0;
word_length = (word_length / 2); ft1000_write_dpram16(ft1000dev,
DWNLD_MAG1_PS_HDR_LOC,
tempword,
for (; word_length > 0; word_length--) /* In words */ 0);
{ }
templong = *data++; break;
templong |= (*data++ << 16);
status = fix_ft1000_write_dpram32 (ft1000dev, dpram++, (u8 *)&templong); case REQUEST_MAILBOX_DATA:
DEBUG
} ("FT1000:download: REQUEST_MAILBOX_DATA\n");
break; // Convert length from byte count to word count. Make sure we round up.
word_length =
case REQUEST_VERSION_INFO: (long)(pft1000info->DSPInfoBlklen +
DEBUG("FT1000:download:REQUEST_VERSION_INFO\n"); 1) / 2;
word_length = file_hdr->version_data_size; put_request_value(ft1000dev,
put_request_value(ft1000dev, word_length); word_length);
/* mailbox_data =
* Position ASIC DPRAM auto-increment pointer. (struct drv_msg *)&(pft1000info->
*/ DSPInfoBlk[0]);
/*
s_file = (u16 *)(pFileStart + file_hdr->version_data_offset); * Position ASIC DPRAM auto-increment pointer.
*/
dpram = (u16)DWNLD_MAG1_PS_HDR_LOC; data = (u16 *) & mailbox_data->data[0];
if (word_length & 0x1) dpram = (u16) DWNLD_MAG1_PS_HDR_LOC;
word_length++; if (word_length & 0x1)
word_length++;
word_length = (word_length / 2);
word_length = (word_length / 2);
for (; word_length > 0; word_length--) /* In words */ for (; word_length > 0; word_length--) { /* In words */
{
templong = *data++;
templong = ntohs(*s_file++); templong |= (*data++ << 16);
temp = ntohs(*s_file++); status =
templong |= (temp << 16); fix_ft1000_write_dpram32
status = fix_ft1000_write_dpram32 (ft1000dev, dpram++, (u8 *)&templong); (ft1000dev, dpram++,
(u8 *) & templong);
}
break; }
break;
case REQUEST_CODE_BY_VERSION:
DEBUG("FT1000:download:REQUEST_CODE_BY_VERSION\n"); case REQUEST_VERSION_INFO:
correct_version = FALSE; DEBUG
requested_version = get_request_value(ft1000dev); ("FT1000:download:REQUEST_VERSION_INFO\n");
word_length =
dsp_img_info = (struct dsp_image_info *)(pFileStart + sizeof(struct dsp_file_hdr )); file_hdr->version_data_size;
put_request_value(ft1000dev,
for (image = 0; image < file_hdr->nDspImages; image++) word_length);
{ /*
* Position ASIC DPRAM auto-increment pointer.
temp = (u16)(dsp_img_info->version); */
templong = temp;
temp = (u16)(dsp_img_info->version >> 16); s_file =
templong |= (temp << 16); (u16 *) (pFileStart +
if (templong == (u32)requested_version) file_hdr->
{ version_data_offset);
correct_version = TRUE;
DEBUG("FT1000:download: correct_version is TRUE\n"); dpram = (u16) DWNLD_MAG1_PS_HDR_LOC;
s_file = (u16 *)(pFileStart + dsp_img_info->begin_offset); if (word_length & 0x1)
c_file = (u8 *)(pFileStart + dsp_img_info->begin_offset); word_length++;
code_end = (u8 *)(pFileStart + dsp_img_info->end_offset);
run_address = dsp_img_info->run_address; word_length = (word_length / 2);
run_size = dsp_img_info->image_size;
image_chksum = (u32)dsp_img_info->checksum; for (; word_length > 0; word_length--) { /* In words */
break;
} templong = ntohs(*s_file++);
dsp_img_info++; temp = ntohs(*s_file++);
templong |= (temp << 16);
status =
} //end of for fix_ft1000_write_dpram32
(ft1000dev, dpram++,
if (!correct_version) (u8 *) & templong);
{
/* }
* Error, beyond boot code range. break;
*/
DEBUG("FT1000:download:Download error: Bad Version Request = 0x%x.\n",(int)requested_version); case REQUEST_CODE_BY_VERSION:
status = STATUS_FAILURE; DEBUG
break; ("FT1000:download:REQUEST_CODE_BY_VERSION\n");
} correct_version = FALSE;
break; requested_version =
get_request_value(ft1000dev);
default:
DEBUG("FT1000:download:Download error: Bad request type=%d in CODE download state.\n",request); dsp_img_info =
status = STATUS_FAILURE; (struct dsp_image_info *)(pFileStart
break; +
} sizeof
if (pft1000info->usbboot) (struct
put_handshake_usb(ft1000dev, HANDSHAKE_RESPONSE); dsp_file_hdr));
else
put_handshake(ft1000dev, HANDSHAKE_RESPONSE); for (image = 0;
} image < file_hdr->nDspImages;
else image++) {
{
DEBUG("FT1000:download:Download error: Handshake failed\n"); temp =
status = STATUS_FAILURE; (u16) (dsp_img_info->
} version);
templong = temp;
break; temp =
(u16) (dsp_img_info->
case STATE_DONE_DWNLD: version >> 16);
DEBUG("FT1000:download:Code loader is done...\n"); templong |= (temp << 16);
state = STATE_SECTION_PROV; if (templong ==
break; (u32) requested_version) {
correct_version = TRUE;
case STATE_SECTION_PROV: DEBUG
DEBUG("FT1000:download:STATE_SECTION_PROV\n"); ("FT1000:download: correct_version is TRUE\n");
pseudo_header = (struct pseudo_hdr *)c_file; s_file =
(u16 *) (pFileStart
if (pseudo_header->checksum == hdr_checksum(pseudo_header)) +
{ dsp_img_info->
if (pseudo_header->portdest != 0x80 /* Dsp OAM */) begin_offset);
{ c_file =
state = STATE_DONE_PROV; (u8 *) (pFileStart +
break; dsp_img_info->
} begin_offset);
pseudo_header_len = ntohs(pseudo_header->length); /* Byte length for PROV records */ code_end =
(u8 *) (pFileStart +
// Get buffer for provisioning data dsp_img_info->
pbuffer = kmalloc((pseudo_header_len + sizeof(struct pseudo_hdr)), GFP_ATOMIC); end_offset);
if (pbuffer) { run_address =
memcpy(pbuffer, (void *)c_file, (u32)(pseudo_header_len + sizeof(struct pseudo_hdr))); dsp_img_info->
// link provisioning data run_address;
pprov_record = kmalloc(sizeof(struct prov_record), GFP_ATOMIC); run_size =
if (pprov_record) { dsp_img_info->
pprov_record->pprov_data = pbuffer; image_size;
list_add_tail (&pprov_record->list, &pft1000info->prov_list); image_chksum =
// Move to next entry if available (u32) dsp_img_info->
c_file = (u8 *)((unsigned long)c_file + (u32)((pseudo_header_len + 1) & 0xFFFFFFFE) + sizeof(struct pseudo_hdr)); checksum;
if ( (unsigned long)(c_file) - (unsigned long)(pFileStart) >= (unsigned long)FileLength) { break;
state = STATE_DONE_FILE; }
} dsp_img_info++;
}
else { } //end of for
kfree(pbuffer);
status = STATUS_FAILURE; if (!correct_version) {
} /*
} * Error, beyond boot code range.
else { */
status = STATUS_FAILURE; DEBUG
} ("FT1000:download:Download error: Bad Version Request = 0x%x.\n",
} (int)requested_version);
else status = STATUS_FAILURE;
{ break;
/* Checksum did not compute */ }
status = STATUS_FAILURE; break;
}
DEBUG("ft1000:download: after STATE_SECTION_PROV, state = %d, status= %d\n", state, status); default:
break; DEBUG
("FT1000:download:Download error: Bad request type=%d in CODE download state.\n",
case STATE_DONE_PROV: request);
DEBUG("FT1000:download:STATE_DONE_PROV\n"); status = STATUS_FAILURE;
state = STATE_DONE_FILE; break;
break; }
if (pft1000info->usbboot)
put_handshake_usb(ft1000dev,
default: HANDSHAKE_RESPONSE);
status = STATUS_FAILURE; else
break; put_handshake(ft1000dev,
} /* End Switch */ HANDSHAKE_RESPONSE);
} else {
if (status != STATUS_SUCCESS) { DEBUG
break; ("FT1000:download:Download error: Handshake failed\n");
} status = STATUS_FAILURE;
}
break;
case STATE_DONE_DWNLD:
DEBUG("FT1000:download:Code loader is done...\n");
state = STATE_SECTION_PROV;
break;
case STATE_SECTION_PROV:
DEBUG("FT1000:download:STATE_SECTION_PROV\n");
pseudo_header = (struct pseudo_hdr *)c_file;
if (pseudo_header->checksum ==
hdr_checksum(pseudo_header)) {
if (pseudo_header->portdest !=
0x80 /* Dsp OAM */ ) {
state = STATE_DONE_PROV;
break;
}
pseudo_header_len = ntohs(pseudo_header->length); /* Byte length for PROV records */
// Get buffer for provisioning data
pbuffer =
kmalloc((pseudo_header_len +
sizeof(struct pseudo_hdr)),
GFP_ATOMIC);
if (pbuffer) {
memcpy(pbuffer, (void *)c_file,
(u32) (pseudo_header_len +
sizeof(struct
pseudo_hdr)));
// link provisioning data
pprov_record =
kmalloc(sizeof(struct prov_record),
GFP_ATOMIC);
if (pprov_record) {
pprov_record->pprov_data =
pbuffer;
list_add_tail(&pprov_record->
list,
&pft1000info->
prov_list);
// Move to next entry if available
c_file =
(u8 *) ((unsigned long)
c_file +
(u32) ((pseudo_header_len + 1) & 0xFFFFFFFE) + sizeof(struct pseudo_hdr));
if ((unsigned long)(c_file) -
(unsigned long)(pFileStart)
>=
(unsigned long)FileLength) {
state = STATE_DONE_FILE;
}
} else {
kfree(pbuffer);
status = STATUS_FAILURE;
}
} else {
status = STATUS_FAILURE;
}
} else {
/* Checksum did not compute */
status = STATUS_FAILURE;
}
DEBUG
("ft1000:download: after STATE_SECTION_PROV, state = %d, status= %d\n",
state, status);
break;
case STATE_DONE_PROV:
DEBUG("FT1000:download:STATE_DONE_PROV\n");
state = STATE_DONE_FILE;
break;
default:
status = STATUS_FAILURE;
break;
} /* End Switch */
if (status != STATUS_SUCCESS) {
break;
}
/**** /****
// Check if Card is present // Check if Card is present
...@@ -1157,11 +1244,12 @@ u16 scram_dnldr(struct ft1000_device *ft1000dev, void *pFileStart, u32 FileLeng ...@@ -1157,11 +1244,12 @@ u16 scram_dnldr(struct ft1000_device *ft1000dev, void *pFileStart, u32 FileLeng
} }
****/ ****/
} /* End while */ } /* End while */
DEBUG("Download exiting with status = 0x%8x\n", status); DEBUG("Download exiting with status = 0x%8x\n", status);
ft1000_write_register(ft1000dev, FT1000_DB_DNLD_TX, FT1000_REG_DOORBELL); ft1000_write_register(ft1000dev, FT1000_DB_DNLD_TX,
FT1000_REG_DOORBELL);
return status; return status;
} }
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment