| //===================================================== |
| // CopyRight (C) 2007 Qualcomm Inc. All Rights Reserved. |
| // |
| // |
| // This file is part of Express Card USB Driver |
| // |
| // $Id: |
| //==================================================== |
| // 20090926; aelias; removed compiler warnings; ubuntu 9.04; 2.6.28-15-generic |
| |
| #include <linux/init.h> |
| #include <linux/kernel.h> |
| #include <linux/module.h> |
| #include <linux/netdevice.h> |
| #include <linux/etherdevice.h> |
| #include <linux/usb.h> |
| #include <linux/vmalloc.h> |
| #include "ft1000_usb.h" |
| |
| |
| #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 MAX_DSP_WAIT_LOOPS 40 |
| #define DSP_WAIT_SLEEP_TIME 1000 /* 1 millisecond */ |
| #define DSP_WAIT_DISPATCH_LVL 50 /* 50 usec */ |
| |
| #define HANDSHAKE_TIMEOUT_VALUE 0xF1F1 |
| #define HANDSHAKE_RESET_VALUE 0xFEFE /* When DSP requests startover */ |
| #define HANDSHAKE_RESET_VALUE_USB 0xFE7E /* When DSP requests startover */ |
| #define HANDSHAKE_DSP_BL_READY 0xFEFE /* At start DSP writes this when bootloader ready */ |
| #define HANDSHAKE_DSP_BL_READY_USB 0xFE7E /* 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 |
| |
| #define MAX_LENGTH 0x7f0 |
| |
| // Temporary download mechanism for Magnemite |
| #define DWNLD_MAG_TYPE_LOC 0x00 |
| #define DWNLD_MAG_LEN_LOC 0x01 |
| #define DWNLD_MAG_ADDR_LOC 0x02 |
| #define DWNLD_MAG_CHKSUM_LOC 0x03 |
| #define DWNLD_MAG_VAL_LOC 0x04 |
| |
| #define HANDSHAKE_MAG_DSP_BL_READY 0xFEFE0000 /* At start DSP writes this when bootloader ready */ |
| #define HANDSHAKE_MAG_DSP_ENTRY 0x01000000 /* Dsp writes this to request for entry address */ |
| #define HANDSHAKE_MAG_DSP_DATA 0x02000000 /* Dsp writes this to request for data block */ |
| #define HANDSHAKE_MAG_DSP_DONE 0x03000000 /* Dsp writes this to indicate download done */ |
| |
| #define HANDSHAKE_MAG_DRV_READY 0xFFFF0000 /* Driver writes this to indicate ready to download */ |
| #define HANDSHAKE_MAG_DRV_DATA 0x02FECDAB /* Driver writes this to indicate data available to DSP */ |
| #define HANDSHAKE_MAG_DRV_ENTRY 0x01FECDAB /* Driver writes this to indicate entry point to DSP */ |
| |
| #define HANDSHAKE_MAG_TIMEOUT_VALUE 0xF1F1 |
| |
| |
| // New Magnemite downloader |
| #define DWNLD_MAG1_HANDSHAKE_LOC 0x00 |
| #define DWNLD_MAG1_TYPE_LOC 0x01 |
| #define DWNLD_MAG1_SIZE_LOC 0x02 |
| #define DWNLD_MAG1_PS_HDR_LOC 0x03 |
| |
| struct dsp_file_hdr { |
| 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. |
| }; |
| |
| #pragma pack(1) |
| 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. |
| unsigned short checksum; // DSP File checksum |
| unsigned short pad1; |
| }; |
| |
| |
| //--------------------------------------------------------------------------- |
| // Function: check_usb_db |
| // |
| // Parameters: struct ft1000_device - device structure |
| // |
| // Returns: 0 - success |
| // |
| // Description: This function checks if the doorbell register is cleared |
| // |
| // Notes: |
| // |
| //--------------------------------------------------------------------------- |
| static ULONG check_usb_db (struct ft1000_device *ft1000dev) |
| { |
| int loopcnt; |
| USHORT temp; |
| ULONG status; |
| |
| loopcnt = 0; |
| while (loopcnt < 10) |
| { |
| |
| status = ft1000_read_register (ft1000dev, &temp, FT1000_REG_DOORBELL); |
| DEBUG("check_usb_db: read FT1000_REG_DOORBELL value is %x\n", temp); |
| if (temp & 0x0080) |
| { |
| DEBUG("FT1000:Got checkusb doorbell\n"); |
| status = ft1000_write_register (ft1000dev, 0x0080, FT1000_REG_DOORBELL); |
| status = ft1000_write_register (ft1000dev, 0x0100, FT1000_REG_DOORBELL); |
| status = ft1000_write_register (ft1000dev, 0x8000, FT1000_REG_DOORBELL); |
| break; |
| } |
| else |
| { |
| loopcnt++; |
| msleep (10); |
| } |
| |
| } //end of while |
| |
| |
| loopcnt = 0; |
| while (loopcnt < 20) |
| { |
| |
| status = ft1000_read_register (ft1000dev, &temp, FT1000_REG_DOORBELL); |
| DEBUG("FT1000:check_usb_db:Doorbell = 0x%x\n", temp); |
| if (temp & 0x8000) |
| { |
| loopcnt++; |
| msleep (10); |
| } |
| else |
| { |
| DEBUG("check_usb_db: door bell is cleared, return 0\n"); |
| return 0; |
| } |
| #if 0 |
| // Check if Card is present |
| status = ft1000_read_register (ft1000dev, &temp, FT1000_REG_SUP_IMASK); |
| if (temp == 0x0000) { |
| break; |
| } |
| |
| status = ft1000_read_register (ft1000dev, &temp, FT1000_REG_ASIC_ID); |
| if (temp == 0xffff) { |
| break; |
| } |
| #endif |
| } |
| |
| return HANDSHAKE_MAG_TIMEOUT_VALUE; |
| |
| } |
| |
| //--------------------------------------------------------------------------- |
| // Function: get_handshake |
| // |
| // Parameters: struct ft1000_device - device structure |
| // USHORT expected_value - the handshake value expected |
| // |
| // Returns: handshakevalue - success |
| // HANDSHAKE_TIMEOUT_VALUE - failure |
| // |
| // Description: This function gets the handshake and compare with the expected value |
| // |
| // Notes: |
| // |
| //--------------------------------------------------------------------------- |
| static USHORT get_handshake(struct ft1000_device *ft1000dev, USHORT expected_value) |
| { |
| USHORT handshake; |
| int loopcnt; |
| ULONG status=0; |
| struct ft1000_info *pft1000info = netdev_priv(ft1000dev->net); |
| |
| loopcnt = 0; |
| while (loopcnt < 100) |
| { |
| |
| // Need to clear downloader doorbell if Hartley ASIC |
| status = ft1000_write_register (ft1000dev, FT1000_DB_DNLD_RX, FT1000_REG_DOORBELL); |
| //DEBUG("FT1000:get_handshake:doorbell = 0x%x\n", temp); |
| if (pft1000info->fcodeldr) |
| { |
| DEBUG(" get_handshake: fcodeldr is %d\n", pft1000info->fcodeldr); |
| pft1000info->fcodeldr = 0; |
| status = check_usb_db(ft1000dev); |
| if (status != STATUS_SUCCESS) |
| { |
| DEBUG("get_handshake: check_usb_db failed\n"); |
| status = STATUS_FAILURE; |
| break; |
| } |
| status = ft1000_write_register (ft1000dev, FT1000_DB_DNLD_RX, FT1000_REG_DOORBELL); |
| } |
| |
| status = ft1000_read_dpram16 (ft1000dev, DWNLD_MAG1_HANDSHAKE_LOC, (PUCHAR)&handshake, 1); |
| //DEBUG("get_handshake: handshake is %x\n", tempx); |
| handshake = ntohs(handshake); |
| //DEBUG("get_handshake: after swap, handshake is %x\n", handshake); |
| |
| if (status) |
| return HANDSHAKE_TIMEOUT_VALUE; |
| |
| //DEBUG("get_handshake: handshake= %x\n", handshake); |
| if ((handshake == expected_value) || (handshake == HANDSHAKE_RESET_VALUE_USB)) |
| { |
| //DEBUG("get_handshake: return handshake %x\n", handshake); |
| return handshake; |
| } |
| else |
| { |
| loopcnt++; |
| msleep (10); |
| } |
| //DEBUG("HANDSHKE LOOP: %d\n", loopcnt); |
| |
| } |
| |
| //DEBUG("get_handshake: return handshake time out\n"); |
| return HANDSHAKE_TIMEOUT_VALUE; |
| } |
| |
| //--------------------------------------------------------------------------- |
| // Function: put_handshake |
| // |
| // Parameters: struct ft1000_device - device structure |
| // USHORT handshake_value - handshake to be written |
| // |
| // Returns: none |
| // |
| // Description: This function write the handshake value to the handshake location |
| // in DPRAM |
| // |
| // Notes: |
| // |
| //--------------------------------------------------------------------------- |
| static void put_handshake(struct ft1000_device *ft1000dev,USHORT handshake_value) |
| { |
| ULONG tempx; |
| USHORT tempword; |
| ULONG status; |
| |
| |
| |
| tempx = (ULONG)handshake_value; |
| tempx = ntohl(tempx); |
| |
| tempword = (USHORT)(tempx & 0xffff); |
| status = ft1000_write_dpram16 (ft1000dev, DWNLD_MAG1_HANDSHAKE_LOC, tempword, 0); |
| tempword = (USHORT)(tempx >> 16); |
| status = ft1000_write_dpram16 (ft1000dev, DWNLD_MAG1_HANDSHAKE_LOC, tempword, 1); |
| status = ft1000_write_register(ft1000dev, FT1000_DB_DNLD_TX, FT1000_REG_DOORBELL); |
| } |
| |
| static USHORT get_handshake_usb(struct ft1000_device *ft1000dev, USHORT expected_value) |
| { |
| USHORT handshake; |
| int loopcnt; |
| USHORT temp; |
| ULONG status=0; |
| |
| struct ft1000_info *pft1000info = netdev_priv(ft1000dev->net); |
| loopcnt = 0; |
| handshake = 0; |
| while (loopcnt < 100) |
| { |
| if (pft1000info->usbboot == 2) { |
| status = ft1000_read_dpram32 (ft1000dev, 0, (PUCHAR)&(pft1000info->tempbuf[0]), 64); |
| for (temp=0; temp<16; temp++) |
| DEBUG("tempbuf %d = 0x%x\n", temp, pft1000info->tempbuf[temp]); |
| status = ft1000_read_dpram16 (ft1000dev, DWNLD_MAG1_HANDSHAKE_LOC, (PUCHAR)&handshake, 1); |
| DEBUG("handshake from read_dpram16 = 0x%x\n", handshake); |
| if (pft1000info->dspalive == pft1000info->tempbuf[6]) |
| handshake = 0; |
| else { |
| handshake = pft1000info->tempbuf[1]; |
| pft1000info->dspalive = pft1000info->tempbuf[6]; |
| } |
| } |
| else { |
| status = ft1000_read_dpram16 (ft1000dev, DWNLD_MAG1_HANDSHAKE_LOC, (PUCHAR)&handshake, 1); |
| } |
| loopcnt++; |
| msleep(10); |
| handshake = ntohs(handshake); |
| if ((handshake == expected_value) || (handshake == HANDSHAKE_RESET_VALUE_USB)) |
| { |
| return handshake; |
| } |
| } |
| |
| return HANDSHAKE_TIMEOUT_VALUE; |
| } |
| |
| static void put_handshake_usb(struct ft1000_device *ft1000dev,USHORT handshake_value) |
| { |
| int i; |
| |
| for (i=0; i<1000; i++); |
| } |
| |
| //--------------------------------------------------------------------------- |
| // Function: get_request_type |
| // |
| // Parameters: struct ft1000_device - device structure |
| // |
| // Returns: request type - success |
| // |
| // Description: This function returns the request type |
| // |
| // Notes: |
| // |
| //--------------------------------------------------------------------------- |
| static USHORT get_request_type(struct ft1000_device *ft1000dev) |
| { |
| USHORT request_type; |
| ULONG status; |
| USHORT tempword; |
| ULONG tempx; |
| struct ft1000_info *pft1000info = netdev_priv(ft1000dev->net); |
| |
| if ( pft1000info->bootmode == 1) |
| { |
| status = fix_ft1000_read_dpram32 (ft1000dev, DWNLD_MAG1_TYPE_LOC, (PUCHAR)&tempx); |
| tempx = ntohl(tempx); |
| } |
| else |
| { |
| tempx = 0; |
| |
| status = ft1000_read_dpram16 (ft1000dev, DWNLD_MAG1_TYPE_LOC, (PUCHAR)&tempword, 1); |
| tempx |= (tempword << 16); |
| tempx = ntohl(tempx); |
| } |
| request_type = (USHORT)tempx; |
| |
| //DEBUG("get_request_type: request_type is %x\n", request_type); |
| return request_type; |
| |
| } |
| |
| static USHORT get_request_type_usb(struct ft1000_device *ft1000dev) |
| { |
| USHORT request_type; |
| ULONG status; |
| USHORT tempword; |
| ULONG tempx; |
| struct ft1000_info *pft1000info = netdev_priv(ft1000dev->net); |
| if ( pft1000info->bootmode == 1) |
| { |
| status = fix_ft1000_read_dpram32 (ft1000dev, DWNLD_MAG1_TYPE_LOC, (PUCHAR)&tempx); |
| tempx = ntohl(tempx); |
| } |
| else |
| { |
| if (pft1000info->usbboot == 2) { |
| tempx = pft1000info->tempbuf[2]; |
| tempword = pft1000info->tempbuf[3]; |
| } |
| else { |
| tempx = 0; |
| status = ft1000_read_dpram16 (ft1000dev, DWNLD_MAG1_TYPE_LOC, (PUCHAR)&tempword, 1); |
| } |
| tempx |= (tempword << 16); |
| tempx = ntohl(tempx); |
| } |
| request_type = (USHORT)tempx; |
| |
| //DEBUG("get_request_type: request_type is %x\n", request_type); |
| return request_type; |
| |
| } |
| |
| //--------------------------------------------------------------------------- |
| // Function: get_request_value |
| // |
| // Parameters: struct ft1000_device - device structure |
| // |
| // Returns: request value - success |
| // |
| // Description: This function returns the request value |
| // |
| // Notes: |
| // |
| //--------------------------------------------------------------------------- |
| static long get_request_value(struct ft1000_device *ft1000dev) |
| { |
| ULONG value; |
| USHORT tempword; |
| ULONG status; |
| struct ft1000_info *pft1000info = netdev_priv(ft1000dev->net); |
| |
| |
| if ( pft1000info->bootmode == 1) |
| { |
| status = fix_ft1000_read_dpram32(ft1000dev, DWNLD_MAG1_SIZE_LOC, (PUCHAR)&value); |
| value = ntohl(value); |
| } |
| else |
| { |
| status = ft1000_read_dpram16(ft1000dev, DWNLD_MAG1_SIZE_LOC, (PUCHAR)&tempword, 0); |
| value = tempword; |
| status = ft1000_read_dpram16(ft1000dev, DWNLD_MAG1_SIZE_LOC, (PUCHAR)&tempword, 1); |
| value |= (tempword << 16); |
| value = ntohl(value); |
| } |
| |
| |
| //DEBUG("get_request_value: value is %x\n", value); |
| return value; |
| |
| } |
| |
| #if 0 |
| static long get_request_value_usb(struct ft1000_device *ft1000dev) |
| { |
| ULONG value; |
| USHORT tempword; |
| ULONG status; |
| struct ft1000_info * pft1000info = netdev_priv(ft1000dev->net); |
| |
| if (pft1000info->usbboot == 2) { |
| value = pft1000info->tempbuf[4]; |
| tempword = pft1000info->tempbuf[5]; |
| } |
| else { |
| value = 0; |
| status = ft1000_read_dpram16(ft1000dev, DWNLD_MAG1_SIZE_LOC, (PUCHAR)&tempword, 1); |
| } |
| |
| value |= (tempword << 16); |
| value = ntohl(value); |
| |
| if (pft1000info->usbboot == 1) |
| pft1000info->usbboot = 2; |
| |
| //DEBUG("get_request_value_usb: value is %x\n", value); |
| return value; |
| |
| } |
| #endif |
| |
| //--------------------------------------------------------------------------- |
| // Function: put_request_value |
| // |
| // Parameters: struct ft1000_device - device structure |
| // long lvalue - value to be put into DPRAM location DWNLD_MAG1_SIZE_LOC |
| // |
| // Returns: none |
| // |
| // Description: This function writes a value to DWNLD_MAG1_SIZE_LOC |
| // |
| // Notes: |
| // |
| //--------------------------------------------------------------------------- |
| static void put_request_value(struct ft1000_device *ft1000dev, long lvalue) |
| { |
| ULONG tempx; |
| ULONG status; |
| |
| tempx = ntohl(lvalue); |
| status = fix_ft1000_write_dpram32(ft1000dev, DWNLD_MAG1_SIZE_LOC, (PUCHAR)&tempx); |
| |
| |
| |
| //DEBUG("put_request_value: value is %x\n", lvalue); |
| |
| } |
| |
| |
| |
| //--------------------------------------------------------------------------- |
| // Function: hdr_checksum |
| // |
| // Parameters: struct pseudo_hdr *pHdr - Pseudo header pointer |
| // |
| // Returns: checksum - success |
| // |
| // Description: This function returns the checksum of the pseudo header |
| // |
| // Notes: |
| // |
| //--------------------------------------------------------------------------- |
| static USHORT hdr_checksum(struct pseudo_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; |
| } |
| |
| |
| //--------------------------------------------------------------------------- |
| // Function: write_blk |
| // |
| // Parameters: struct ft1000_device - device structure |
| // USHORT **pUsFile - DSP image file pointer in USHORT |
| // UCHAR **pUcFile - DSP image file pointer in UCHAR |
| // long word_length - lenght of the buffer to be written |
| // to DPRAM |
| // |
| // Returns: STATUS_SUCCESS - success |
| // STATUS_FAILURE - failure |
| // |
| // Description: This function writes a block of DSP image to DPRAM |
| // |
| // Notes: |
| // |
| //--------------------------------------------------------------------------- |
| static ULONG write_blk (struct ft1000_device *ft1000dev, USHORT **pUsFile, UCHAR **pUcFile, long word_length) |
| { |
| ULONG Status = STATUS_SUCCESS; |
| USHORT dpram; |
| long temp_word_length; |
| int loopcnt, i, j; |
| USHORT *pTempFile; |
| USHORT tempword; |
| USHORT tempbuffer[64]; |
| USHORT resultbuffer[64]; |
| struct ft1000_info *pft1000info = netdev_priv(ft1000dev->net); |
| |
| //DEBUG("FT1000:download:start word_length = %d\n",(int)word_length); |
| dpram = (USHORT)DWNLD_MAG1_PS_HDR_LOC; |
| tempword = *(*pUsFile); |
| (*pUsFile)++; |
| Status = ft1000_write_dpram16(ft1000dev, dpram, tempword, 0); |
| tempword = *(*pUsFile); |
| (*pUsFile)++; |
| Status = ft1000_write_dpram16(ft1000dev, dpram++, tempword, 1); |
| |
| *pUcFile = *pUcFile + 4; |
| word_length--; |
| tempword = (USHORT)word_length; |
| word_length = (word_length / 16) + 1; |
| pTempFile = *pUsFile; |
| temp_word_length = word_length; |
| for (; word_length > 0; word_length--) /* In words */ |
| { |
| loopcnt = 0; |
| |
| for (i=0; i<32; i++) |
| { |
| if (tempword != 0) |
| { |
| tempbuffer[i++] = *(*pUsFile); |
| (*pUsFile)++; |
| tempbuffer[i] = *(*pUsFile); |
| (*pUsFile)++; |
| *pUcFile = *pUcFile + 4; |
| loopcnt++; |
| tempword--; |
| } |
| else |
| { |
| tempbuffer[i++] = 0; |
| tempbuffer[i] = 0; |
| } |
| } |
| |
| //DEBUG("write_blk: loopcnt is %d\n", loopcnt); |
| //DEBUG("write_blk: bootmode = %d\n", bootmode); |
| //DEBUG("write_blk: dpram = %x\n", dpram); |
| if (pft1000info->bootmode == 0) |
| { |
| if (dpram >= 0x3F4) |
| Status = ft1000_write_dpram32 (ft1000dev, dpram, (PUCHAR)&tempbuffer[0], 8); |
| else |
| Status = ft1000_write_dpram32 (ft1000dev, dpram, (PUCHAR)&tempbuffer[0], 64); |
| } |
| else |
| { |
| for (j=0; j<10; j++) |
| { |
| Status = ft1000_write_dpram32 (ft1000dev, dpram, (PUCHAR)&tempbuffer[0], 64); |
| if (Status == STATUS_SUCCESS) |
| { |
| // Work around for ASIC bit stuffing problem. |
| if ( (tempbuffer[31] & 0xfe00) == 0xfe00) |
| { |
| Status = ft1000_write_dpram32(ft1000dev, dpram+12, (PUCHAR)&tempbuffer[24], 64); |
| } |
| // Let's check the data written |
| Status = ft1000_read_dpram32 (ft1000dev, dpram, (PUCHAR)&resultbuffer[0], 64); |
| if ( (tempbuffer[31] & 0xfe00) == 0xfe00) |
| { |
| for (i=0; i<28; i++) |
| { |
| if (resultbuffer[i] != tempbuffer[i]) |
| { |
| //NdisMSleep (100); |
| DEBUG("FT1000:download:DPRAM write failed 1 during bootloading\n"); |
| msleep(10); |
| Status = STATUS_FAILURE; |
| break; |
| } |
| } |
| Status = ft1000_read_dpram32 (ft1000dev, dpram+12, (PUCHAR)&resultbuffer[0], 64); |
| for (i=0; i<16; i++) |
| { |
| if (resultbuffer[i] != tempbuffer[i+24]) |
| { |
| //NdisMSleep (100); |
| DEBUG("FT1000:download:DPRAM write failed 2 during bootloading\n"); |
| msleep(10); |
| Status = STATUS_FAILURE; |
| break; |
| } |
| } |
| } |
| else |
| { |
| for (i=0; i<32; i++) |
| { |
| if (resultbuffer[i] != tempbuffer[i]) |
| { |
| //NdisMSleep (100); |
| DEBUG("FT1000:download:DPRAM write failed 3 during bootloading\n"); |
| msleep(10); |
| Status = STATUS_FAILURE; |
| break; |
| } |
| } |
| } |
| |
| if (Status == STATUS_SUCCESS) |
| break; |
| |
| } |
| } |
| |
| if (Status != STATUS_SUCCESS) |
| { |
| DEBUG("FT1000:download:Write failed tempbuffer[31] = 0x%x\n", tempbuffer[31]); |
| break; |
| } |
| |
| } |
| dpram = dpram + loopcnt; |
| } |
| |
| return Status; |
| } |
| |
| static void usb_dnld_complete (struct urb *urb) |
| { |
| //DEBUG("****** usb_dnld_complete\n"); |
| } |
| |
| //--------------------------------------------------------------------------- |
| // Function: write_blk_fifo |
| // |
| // Parameters: struct ft1000_device - device structure |
| // USHORT **pUsFile - DSP image file pointer in USHORT |
| // UCHAR **pUcFile - DSP image file pointer in UCHAR |
| // long word_length - lenght of the buffer to be written |
| // to DPRAM |
| // |
| // Returns: STATUS_SUCCESS - success |
| // STATUS_FAILURE - failure |
| // |
| // Description: This function writes a block of DSP image to DPRAM |
| // |
| // Notes: |
| // |
| //--------------------------------------------------------------------------- |
| static ULONG write_blk_fifo (struct ft1000_device *ft1000dev, USHORT **pUsFile, UCHAR **pUcFile, long word_length) |
| { |
| ULONG Status = STATUS_SUCCESS; |
| int byte_length; |
| long aligncnt; |
| |
| byte_length = word_length * 4; |
| |
| if (byte_length % 4) |
| aligncnt = 4 - (byte_length % 4); |
| else |
| aligncnt = 0; |
| byte_length += aligncnt; |
| |
| if (byte_length && ((byte_length % 64) == 0)) { |
| byte_length += 4; |
| } |
| |
| if (byte_length < 64) |
| byte_length = 68; |
| |
| #if 0 |
| pblk = kzalloc(byte_length, GFP_KERNEL); |
| memcpy (pblk, *pUcFile, byte_length); |
| |
| pipe = usb_sndbulkpipe (ft1000dev->dev, ft1000dev->bulk_out_endpointAddr); |
| |
| Status = usb_bulk_msg (ft1000dev->dev, |
| pipe, |
| pblk, |
| byte_length, |
| &cnt, |
| 10); |
| DEBUG("write_blk_fifo Status = 0x%8x Bytes Transfer = %d Data = 0x%x\n", Status, cnt, *pblk); |
| |
| kfree(pblk); |
| #else |
| usb_init_urb(ft1000dev->tx_urb); |
| memcpy (ft1000dev->tx_buf, *pUcFile, byte_length); |
| usb_fill_bulk_urb(ft1000dev->tx_urb, |
| ft1000dev->dev, |
| usb_sndbulkpipe(ft1000dev->dev, ft1000dev->bulk_out_endpointAddr), |
| ft1000dev->tx_buf, |
| byte_length, |
| usb_dnld_complete, |
| (void*)ft1000dev); |
| |
| usb_submit_urb(ft1000dev->tx_urb, GFP_ATOMIC); |
| #endif |
| |
| *pUsFile = *pUsFile + (word_length << 1); |
| *pUcFile = *pUcFile + (word_length << 2); |
| |
| return Status; |
| } |
| |
| //--------------------------------------------------------------------------- |
| // |
| // Function: scram_dnldr |
| // |
| // Synopsis: Scramble downloader for Harley based ASIC via USB interface |
| // |
| // Arguments: pFileStart - pointer to start of file |
| // FileLength - file length |
| // |
| // Returns: status - return code |
| //--------------------------------------------------------------------------- |
| |
| u16 scram_dnldr(struct ft1000_device *ft1000dev, void *pFileStart, ULONG FileLength) |
| { |
| u16 Status = STATUS_SUCCESS; |
| UINT uiState; |
| USHORT handshake; |
| struct pseudo_hdr *pHdr; |
| USHORT usHdrLength; |
| long word_length; |
| USHORT request; |
| USHORT temp; |
| USHORT tempword; |
| |
| struct dsp_file_hdr *pFileHdr5; |
| struct dsp_image_info *pDspImageInfoV6 = NULL; |
| long requested_version; |
| BOOLEAN bGoodVersion; |
| struct drv_msg *pMailBoxData; |
| USHORT *pUsData = NULL; |
| USHORT *pUsFile = NULL; |
| UCHAR *pUcFile = NULL; |
| UCHAR *pBootEnd = NULL, *pCodeEnd= NULL; |
| int imageN; |
| long loader_code_address, loader_code_size = 0; |
| long run_address = 0, run_size = 0; |
| |
| ULONG templong; |
| ULONG image_chksum = 0; |
| |
| USHORT dpram = 0; |
| PUCHAR pbuffer; |
| struct prov_record *pprov_record; |
| struct ft1000_info *pft1000info = netdev_priv(ft1000dev->net); |
| |
| DEBUG("Entered scram_dnldr...\n"); |
| |
| pft1000info->fcodeldr = 0; |
| pft1000info->usbboot = 0; |
| pft1000info->dspalive = 0xffff; |
| |
| |
| // |
| // Get version id of file, at first 4 bytes of file, for newer files. |
| // |
| |
| uiState = STATE_START_DWNLD; |
| |
| pFileHdr5 = (struct dsp_file_hdr *)pFileStart; |
| |
| ft1000_write_register (ft1000dev, 0x800, FT1000_REG_MAG_WATERMARK); |
| |
| pUsFile = (USHORT *)(pFileStart + pFileHdr5->loader_offset); |
| pUcFile = (UCHAR *)(pFileStart + pFileHdr5->loader_offset); |
| |
| pBootEnd = (UCHAR *)(pFileStart + pFileHdr5->loader_code_end); |
| |
| loader_code_address = pFileHdr5->loader_code_address; |
| loader_code_size = pFileHdr5->loader_code_size; |
| bGoodVersion = FALSE; |
| |
| while ((Status == STATUS_SUCCESS) && (uiState != STATE_DONE_FILE)) |
| { |
| switch (uiState) |
| { |
| 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; |
| } |
| |
| uiState = STATE_BOOT_DWNLD; |
| |
| break; |
| |
| case STATE_BOOT_DWNLD: |
| DEBUG("FT1000:STATE_BOOT_DWNLD\n"); |
| pft1000info->bootmode = 1; |
| handshake = get_handshake(ft1000dev, HANDSHAKE_REQUEST); |
| if (handshake == HANDSHAKE_REQUEST) |
| { |
| /* |
| * Get type associated with the request. |
| */ |
| request = get_request_type(ft1000dev); |
| switch (request) |
| { |
| case REQUEST_RUN_ADDRESS: |
| DEBUG("FT1000:REQUEST_RUN_ADDRESS\n"); |
| put_request_value(ft1000dev, loader_code_address); |
| break; |
| case REQUEST_CODE_LENGTH: |
| DEBUG("FT1000:REQUEST_CODE_LENGTH\n"); |
| put_request_value(ft1000dev, loader_code_size); |
| break; |
| case REQUEST_DONE_BL: |
| DEBUG("FT1000:REQUEST_DONE_BL\n"); |
| /* Reposition ptrs to beginning of code section */ |
| pUsFile = (USHORT *)(pBootEnd); |
| pUcFile = (UCHAR *)(pBootEnd); |
| //DEBUG("FT1000:download:pUsFile = 0x%8x\n", (int)pUsFile); |
| //DEBUG("FT1000:download:pUcFile = 0x%8x\n", (int)pUcFile); |
| uiState = STATE_CODE_DWNLD; |
| pft1000info->fcodeldr = 1; |
| break; |
| case REQUEST_CODE_SEGMENT: |
| //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 + pUcFile) > pBootEnd) |
| { |
| /* |
| * 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 = (USHORT)DWNLD_MAG1_PS_HDR_LOC; |
| if (word_length & 0x1) |
| word_length++; |
| word_length = word_length / 2; |
| |
| Status = write_blk(ft1000dev, &pUsFile, &pUcFile, word_length); |
| //DEBUG("write_blk returned %d\n", Status); |
| break; |
| default: |
| DEBUG("FT1000:download:Download error: Bad request type=%d in BOOT download state.\n",request); |
| Status = STATUS_FAILURE; |
| break; |
| } |
| if (pft1000info->usbboot) |
| put_handshake_usb(ft1000dev, HANDSHAKE_RESPONSE); |
| else |
| put_handshake(ft1000dev, HANDSHAKE_RESPONSE); |
| } |
| else |
| { |
| DEBUG("FT1000:download:Download error: Handshake failed\n"); |
| Status = STATUS_FAILURE; |
| } |
| |
| break; |
| |
| case STATE_CODE_DWNLD: |
| //DEBUG("FT1000:STATE_CODE_DWNLD\n"); |
| pft1000info->bootmode = 0; |
| if (pft1000info->usbboot) |
| handshake = get_handshake_usb(ft1000dev, HANDSHAKE_REQUEST); |
| else |
| handshake = get_handshake(ft1000dev, HANDSHAKE_REQUEST); |
| if (handshake == HANDSHAKE_REQUEST) |
| { |
| /* |
| * Get type associated with the request. |
| */ |
| if (pft1000info->usbboot) |
| request = get_request_type_usb(ft1000dev); |
| else |
| request = get_request_type(ft1000dev); |
| switch (request) |
| { |
| case REQUEST_FILE_CHECKSUM: |
| DEBUG("FT1000:download:image_chksum = 0x%8x\n", image_chksum); |
| put_request_value(ft1000dev, image_chksum); |
| break; |
| case REQUEST_RUN_ADDRESS: |
| DEBUG("FT1000:download: REQUEST_RUN_ADDRESS\n"); |
| if (bGoodVersion) |
| { |
| DEBUG("FT1000:download:run_address = 0x%8x\n", (int)run_address); |
| put_request_value(ft1000dev, run_address); |
| } |
| else |
| { |
| DEBUG("FT1000:download:Download error: Got Run address request before image offset request.\n"); |
| Status = STATUS_FAILURE; |
| break; |
| } |
| break; |
| case REQUEST_CODE_LENGTH: |
| DEBUG("FT1000:download:REQUEST_CODE_LENGTH\n"); |
| if (bGoodVersion) |
| { |
| DEBUG("FT1000:download:run_size = 0x%8x\n", (int)run_size); |
| put_request_value(ft1000dev, run_size); |
| } |
| else |
| { |
| DEBUG("FT1000:download:Download error: Got Size request before image offset request.\n"); |
| Status = STATUS_FAILURE; |
| break; |
| } |
| break; |
| case REQUEST_DONE_CL: |
| pft1000info->usbboot = 3; |
| /* Reposition ptrs to beginning of provisioning section */ |
| pUsFile = (USHORT *)(pFileStart + pFileHdr5->commands_offset); |
| pUcFile = (UCHAR *)(pFileStart + pFileHdr5->commands_offset); |
| uiState = STATE_DONE_DWNLD; |
| break; |
| case REQUEST_CODE_SEGMENT: |
| //DEBUG("FT1000:download: REQUEST_CODE_SEGMENT - CODELOADER\n"); |
| if (!bGoodVersion) |
| { |
| DEBUG("FT1000:download:Download error: Got Code Segment request before image offset request.\n"); |
| Status = STATUS_FAILURE; |
| break; |
| } |
| #if 0 |
| word_length = get_request_value_usb(ft1000dev); |
| //DEBUG("FT1000:download:word_length = %d\n", (int)word_length); |
| if (word_length > MAX_LENGTH/2) |
| #else |
| word_length = get_request_value(ft1000dev); |
| //DEBUG("FT1000:download:word_length = %d\n", (int)word_length); |
| if (word_length > MAX_LENGTH) |
| #endif |
| { |
| DEBUG("FT1000:download:Download error: Max length exceeded\n"); |
| Status = STATUS_FAILURE; |
| break; |
| } |
| if ( (word_length*2 + pUcFile) > pCodeEnd) |
| { |
| /* |
| * Error, beyond boot code range. |
| */ |
| DEBUG("FT1000:download:Download error: Requested len=%d exceeds DSP code boundry.\n", |
| (int)word_length); |
| Status = STATUS_FAILURE; |
| break; |
| } |
| /* |
| * Position ASIC DPRAM auto-increment pointer. |
| */ |
| dpram = (USHORT)DWNLD_MAG1_PS_HDR_LOC; |
| if (word_length & 0x1) |
| word_length++; |
| word_length = word_length / 2; |
| |
| write_blk_fifo (ft1000dev, &pUsFile, &pUcFile, word_length); |
| if (pft1000info->usbboot == 0) |
| pft1000info->usbboot++; |
| if (pft1000info->usbboot == 1) { |
| tempword = 0; |
| ft1000_write_dpram16 (ft1000dev, DWNLD_MAG1_PS_HDR_LOC, tempword, 0); |
| } |
| |
| break; |
| |
| case REQUEST_MAILBOX_DATA: |
| 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; |
| put_request_value(ft1000dev, word_length); |
| pMailBoxData = (struct drv_msg *)&(pft1000info->DSPInfoBlk[0]); |
| /* |
| * Position ASIC DPRAM auto-increment pointer. |
| */ |
| |
| |
| pUsData = (USHORT *)&pMailBoxData->data[0]; |
| dpram = (USHORT)DWNLD_MAG1_PS_HDR_LOC; |
| if (word_length & 0x1) |
| word_length++; |
| |
| word_length = (word_length / 2); |
| |
| |
| for (; word_length > 0; word_length--) /* In words */ |
| { |
| |
| templong = *pUsData++; |
| templong |= (*pUsData++ << 16); |
| Status = fix_ft1000_write_dpram32 (ft1000dev, dpram++, (PUCHAR)&templong); |
| |
| } |
| break; |
| |
| case REQUEST_VERSION_INFO: |
| DEBUG("FT1000:download:REQUEST_VERSION_INFO\n"); |
| word_length = pFileHdr5->version_data_size; |
| put_request_value(ft1000dev, word_length); |
| /* |
| * Position ASIC DPRAM auto-increment pointer. |
| */ |
| |
| pUsFile = (USHORT *)(pFileStart + pFileHdr5->version_data_offset); |
| |
| |
| dpram = (USHORT)DWNLD_MAG1_PS_HDR_LOC; |
| if (word_length & 0x1) |
| word_length++; |
| |
| word_length = (word_length / 2); |
| |
| |
| for (; word_length > 0; word_length--) /* In words */ |
| { |
| |
| templong = ntohs(*pUsFile++); |
| temp = ntohs(*pUsFile++); |
| templong |= (temp << 16); |
| Status = fix_ft1000_write_dpram32 (ft1000dev, dpram++, (PUCHAR)&templong); |
| |
| } |
| break; |
| |
| case REQUEST_CODE_BY_VERSION: |
| DEBUG("FT1000:download:REQUEST_CODE_BY_VERSION\n"); |
| bGoodVersion = FALSE; |
| requested_version = get_request_value(ft1000dev); |
| |
| pDspImageInfoV6 = (struct dsp_image_info *)(pFileStart + sizeof(struct dsp_file_hdr )); |
| |
| for (imageN = 0; imageN < pFileHdr5->nDspImages; imageN++) |
| { |
| |
| temp = (USHORT)(pDspImageInfoV6->version); |
| templong = temp; |
| temp = (USHORT)(pDspImageInfoV6->version >> 16); |
| templong |= (temp << 16); |
| if (templong == (ULONG)requested_version) |
| { |
| bGoodVersion = TRUE; |
| DEBUG("FT1000:download: bGoodVersion is TRUE\n"); |
| pUsFile = (USHORT *)(pFileStart + pDspImageInfoV6->begin_offset); |
| pUcFile = (UCHAR *)(pFileStart + pDspImageInfoV6->begin_offset); |
| pCodeEnd = (UCHAR *)(pFileStart + pDspImageInfoV6->end_offset); |
| run_address = pDspImageInfoV6->run_address; |
| run_size = pDspImageInfoV6->image_size; |
| image_chksum = (ULONG)pDspImageInfoV6->checksum; |
| break; |
| } |
| pDspImageInfoV6++; |
| |
| |
| } //end of for |
| |
| if (!bGoodVersion) |
| { |
| /* |
| * Error, beyond boot code range. |
| */ |
| DEBUG("FT1000:download:Download error: Bad Version Request = 0x%x.\n",(int)requested_version); |
| Status = STATUS_FAILURE; |
| break; |
| } |
| break; |
| |
| default: |
| DEBUG("FT1000:download:Download error: Bad request type=%d in CODE download state.\n",request); |
| Status = STATUS_FAILURE; |
| break; |
| } |
| if (pft1000info->usbboot) |
| put_handshake_usb(ft1000dev, HANDSHAKE_RESPONSE); |
| else |
| put_handshake(ft1000dev, HANDSHAKE_RESPONSE); |
| } |
| else |
| { |
| DEBUG("FT1000:download:Download error: Handshake failed\n"); |
| Status = STATUS_FAILURE; |
| } |
| |
| break; |
| |
| case STATE_DONE_DWNLD: |
| DEBUG("FT1000:download:Code loader is done...\n"); |
| uiState = STATE_SECTION_PROV; |
| break; |
| |
| case STATE_SECTION_PROV: |
| DEBUG("FT1000:download:STATE_SECTION_PROV\n"); |
| pHdr = (struct pseudo_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(struct pseudo_hdr)), GFP_ATOMIC); |
| if (pbuffer) { |
| memcpy(pbuffer, (void *)pUcFile, (UINT)(usHdrLength + 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 |
| pUcFile = (UCHAR *)((unsigned long)pUcFile + (UINT)((usHdrLength + 1) & 0xFFFFFFFE) + sizeof(struct pseudo_hdr)); |
| if ( (unsigned long)(pUcFile) - (unsigned long)(pFileStart) >= (unsigned long)FileLength) { |
| uiState = 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, uiState = %d, Status= %d\n", uiState, Status); |
| break; |
| |
| case STATE_DONE_PROV: |
| DEBUG("FT1000:download:STATE_DONE_PROV\n"); |
| uiState = STATE_DONE_FILE; |
| break; |
| |
| |
| default: |
| Status = STATUS_FAILURE; |
| break; |
| } /* End Switch */ |
| |
| if (Status != STATUS_SUCCESS) { |
| break; |
| } |
| |
| /**** |
| // Check if Card is present |
| Status = Harley_Read_Register(&temp, FT1000_REG_SUP_IMASK); |
| if ( (Status != NDIS_STATUS_SUCCESS) || (temp == 0x0000) ) { |
| break; |
| } |
| |
| Status = Harley_Read_Register(&temp, FT1000_REG_ASIC_ID); |
| if ( (Status != NDIS_STATUS_SUCCESS) || (temp == 0xffff) ) { |
| break; |
| } |
| ****/ |
| |
| } /* End while */ |
| |
| DEBUG("Download exiting with status = 0x%8x\n", Status); |
| ft1000_write_register(ft1000dev, FT1000_DB_DNLD_TX, FT1000_REG_DOORBELL); |
| |
| return Status; |
| } |
| |
