drivers/staging/rtl8192su/r8192S_firmware.c

   1 /**************************************************************************************************
   2  * Procedure:    Init boot code/firmware code/data session
   3  *
   4  * Description: This routine will intialize firmware. If any error occurs during the initialization
   5  *              process, the routine shall terminate immediately and return fail.
   6  *              NIC driver should call NdisOpenFile only from MiniportInitialize.
   7  *
   8  * Arguments:   The pointer of the adapter
   9
  10  * Returns:
  11  *        NDIS_STATUS_FAILURE - the following initialization process should be terminated
  12  *        NDIS_STATUS_SUCCESS - if firmware initialization process success
  13 **************************************************************************************************/
  14 #include "r8192U.h"
  15 #include "r8192S_firmware.h"
  16 #include <linux/unistd.h>
  17
  18 #include "r8192S_hw.h"
  19 #include "r8192SU_HWImg.h"
  20
  21 #include <linux/firmware.h>
  22
  23 #define   byte(x,n)  ( (x >> (8 * n)) & 0xff  )
  24
  25 //
  26 // Description:   This routine will intialize firmware. If any error occurs during the initialization
  27 //                              process, the routine shall terminate immediately and return fail.
  28 //
  29 // Arguments:   The pointer of the adapter
  30 //                         Code address (Virtual address, should fill descriptor with physical address)
  31 //                         Code size
  32 // Created by Roger, 2008.04.10.
  33 //
  34 bool FirmwareDownloadCode(struct net_device *dev, u8 *  code_virtual_address,u32 buffer_len)
  35 {
  36         struct r8192_priv   *priv = ieee80211_priv(dev);
  37         bool                rt_status = true;
  38         u16                 frag_threshold = MAX_FIRMWARE_CODE_SIZE; //Fragmentation might be required in 90/92 but not in 92S
  39         u16                 frag_length, frag_offset = 0;
  40         struct sk_buff      *skb;
  41         unsigned char       *seg_ptr;
  42         cb_desc             *tcb_desc;
  43         u8                          bLastIniPkt = 0;
  44         u16                         ExtraDescOffset = 0;
  45
  46
  47         RT_TRACE(COMP_FIRMWARE, "--->FirmwareDownloadCode()\n" );
  48
  49         //MAX_TRANSMIT_BUFFER_SIZE
  50         if(buffer_len >= MAX_FIRMWARE_CODE_SIZE-USB_HWDESC_HEADER_LEN)
  51         {
  52                 RT_TRACE(COMP_ERR, "Size over MAX_FIRMWARE_CODE_SIZE! \n");
  53                 goto cmdsend_downloadcode_fail;
  54         }
  55
  56         ExtraDescOffset = USB_HWDESC_HEADER_LEN;
  57
  58         do {
  59                 if((buffer_len-frag_offset) > frag_threshold)
  60                 {
  61                         frag_length = frag_threshold + ExtraDescOffset;
  62                 }
  63                 else
  64                 {
  65                         frag_length = (u16)(buffer_len - frag_offset + ExtraDescOffset);
  66                 bLastIniPkt = 1;
  67                 }
  68
  69                 /* Allocate skb buffer to contain firmware info and tx descriptor info. */
  70                 skb  = dev_alloc_skb(frag_length);
  71                 if (skb == NULL) {
  72                         RT_TRACE(COMP_ERR, "(%s): unable to alloc skb buffer\n",
  73                                                                 __func__);
  74                         goto cmdsend_downloadcode_fail;
  75                 }
  76                 memcpy((unsigned char *)(skb->cb),&dev,sizeof(dev));
  77
  78                 tcb_desc = (cb_desc*)(skb->cb + MAX_DEV_ADDR_SIZE);
  79                 tcb_desc->queue_index = TXCMD_QUEUE;
  80                 tcb_desc->bCmdOrInit = DESC_PACKET_TYPE_INIT;
  81                 tcb_desc->bLastIniPkt = bLastIniPkt;
  82
  83                 skb_reserve(skb, ExtraDescOffset);
  84                 seg_ptr = (u8 *)skb_put(skb, (u32)(frag_length-ExtraDescOffset));
  85                 memcpy(seg_ptr, code_virtual_address+frag_offset, (u32)(frag_length-ExtraDescOffset));
  86
  87                 tcb_desc->txbuf_size= frag_length;
  88
  89                 if(!priv->ieee80211->check_nic_enough_desc(dev,tcb_desc->queue_index)||
  90                         (!skb_queue_empty(&priv->ieee80211->skb_waitQ[tcb_desc->queue_index]))||\
  91                         (priv->ieee80211->queue_stop) )
  92                 {
  93                         RT_TRACE(COMP_FIRMWARE,"=====================================================> tx full!\n");
  94                         skb_queue_tail(&priv->ieee80211->skb_waitQ[tcb_desc->queue_index], skb);
  95                 }
  96                 else
  97                 {
  98                         priv->ieee80211->softmac_hard_start_xmit(skb,dev);
  99                 }
 100
 101                 frag_offset += (frag_length - ExtraDescOffset);
 102
 103         }while(frag_offset < buffer_len);
 104
 105         return rt_status ;
 106
 107
 108 cmdsend_downloadcode_fail:
 109         rt_status = false;
 110         RT_TRACE(COMP_ERR, "CmdSendDownloadCode fail !!\n");
 111         return rt_status;
 112
 113 }
 114
 115
 116 RT_STATUS
 117 FirmwareEnableCPU(struct net_device *dev)
 118 {
 119
 120         RT_STATUS       rtStatus = RT_STATUS_SUCCESS;
 121         u8              tmpU1b, CPUStatus = 0;
 122         u16             tmpU2b;
 123         u32             iCheckTime = 200;
 124
 125         RT_TRACE(COMP_FIRMWARE, "-->FirmwareEnableCPU()\n" );
 126         // Enable CPU.
 127         tmpU1b = read_nic_byte(dev, SYS_CLKR);
 128         write_nic_byte(dev,  SYS_CLKR, (tmpU1b|SYS_CPU_CLKSEL)); //AFE source
 129
 130         tmpU2b = read_nic_word(dev, SYS_FUNC_EN);
 131         write_nic_word(dev, SYS_FUNC_EN, (tmpU2b|FEN_CPUEN));
 132
 133         //Polling IMEM Ready after CPU has refilled.
 134         do
 135         {
 136                 CPUStatus = read_nic_byte(dev, TCR);
 137                 if(CPUStatus& IMEM_RDY)
 138                 {
 139                         RT_TRACE(COMP_FIRMWARE, "IMEM Ready after CPU has refilled.\n");
 140                         break;
 141                 }
 142
 143                 //usleep(100);
 144                 udelay(100);
 145         }while(iCheckTime--);
 146
 147         if(!(CPUStatus & IMEM_RDY))
 148                 return RT_STATUS_FAILURE;
 149
 150         RT_TRACE(COMP_FIRMWARE, "<--FirmwareEnableCPU(): rtStatus(%#x)\n", rtStatus);
 151         return rtStatus;
 152 }
 153
 154 FIRMWARE_8192S_STATUS
 155 FirmwareGetNextStatus(FIRMWARE_8192S_STATUS FWCurrentStatus)
 156 {
 157         FIRMWARE_8192S_STATUS   NextFWStatus = 0;
 158
 159         switch(FWCurrentStatus)
 160         {
 161                 case FW_STATUS_INIT:
 162                         NextFWStatus = FW_STATUS_LOAD_IMEM;
 163                         break;
 164
 165                 case FW_STATUS_LOAD_IMEM:
 166                         NextFWStatus = FW_STATUS_LOAD_EMEM;
 167                         break;
 168
 169                 case FW_STATUS_LOAD_EMEM:
 170                         NextFWStatus = FW_STATUS_LOAD_DMEM;
 171                         break;
 172
 173                 case FW_STATUS_LOAD_DMEM:
 174                         NextFWStatus = FW_STATUS_READY;
 175                         break;
 176
 177                 default:
 178                         RT_TRACE(COMP_ERR,"Invalid FW Status(%#x)!!\n", FWCurrentStatus);
 179                         break;
 180         }
 181         return  NextFWStatus;
 182 }
 183
 184 bool
 185 FirmwareCheckReady(struct net_device *dev,      u8 LoadFWStatus)
 186 {
 187         struct r8192_priv       *priv = ieee80211_priv(dev);
 188         RT_STATUS       rtStatus = RT_STATUS_SUCCESS;
 189         rt_firmware     *pFirmware = priv->pFirmware;
 190         int                     PollingCnt = 1000;
 191         //u8            tmpU1b, CPUStatus = 0;
 192         u8              CPUStatus = 0;
 193         u32             tmpU4b;
 194         //bool          bOrgIMREnable;
 195
 196         RT_TRACE(COMP_FIRMWARE, "--->FirmwareCheckReady(): LoadStaus(%d),", LoadFWStatus);
 197
 198         pFirmware->FWStatus = (FIRMWARE_8192S_STATUS)LoadFWStatus;
 199         if( LoadFWStatus == FW_STATUS_LOAD_IMEM)
 200         {
 201                 do
 202                 {//Polling IMEM code done.
 203                         CPUStatus = read_nic_byte(dev, TCR);
 204                         if(CPUStatus& IMEM_CODE_DONE)
 205                                 break;
 206
 207                         udelay(5);
 208                 }while(PollingCnt--);
 209                 if(!(CPUStatus & IMEM_CHK_RPT) || PollingCnt <= 0)
 210                 {
 211                         RT_TRACE(COMP_ERR, "FW_STATUS_LOAD_IMEM FAIL CPU, Status=%x\r\n", CPUStatus);
 212                         return false;
 213                 }
 214         }
 215         else if( LoadFWStatus == FW_STATUS_LOAD_EMEM)
 216         {//Check Put Code OK and Turn On CPU
 217                 do
 218                 {//Polling EMEM code done.
 219                         CPUStatus = read_nic_byte(dev, TCR);
 220                         if(CPUStatus& EMEM_CODE_DONE)
 221                                 break;
 222
 223                         udelay(5);
 224                 }while(PollingCnt--);
 225                 if(!(CPUStatus & EMEM_CHK_RPT))
 226                 {
 227                         RT_TRACE(COMP_ERR, "FW_STATUS_LOAD_EMEM FAIL CPU, Status=%x\r\n", CPUStatus);
 228                         return false;
 229                 }
 230
 231                 // Turn On CPU
 232                 rtStatus = FirmwareEnableCPU(dev);
 233                 if(rtStatus != RT_STATUS_SUCCESS)
 234                 {
 235                         RT_TRACE(COMP_ERR, "Enable CPU fail ! \n" );
 236                         return false;
 237                 }
 238         }
 239         else if( LoadFWStatus == FW_STATUS_LOAD_DMEM)
 240         {
 241                 do
 242                 {//Polling DMEM code done
 243                         CPUStatus = read_nic_byte(dev, TCR);
 244                         if(CPUStatus& DMEM_CODE_DONE)
 245                                 break;
 246
 247                         udelay(5);
 248                 }while(PollingCnt--);
 249
 250                 if(!(CPUStatus & DMEM_CODE_DONE))
 251                 {
 252                         RT_TRACE(COMP_ERR, "Polling  DMEM code done fail ! CPUStatus(%#x)\n", CPUStatus);
 253                         return false;
 254                 }
 255
 256                 RT_TRACE(COMP_FIRMWARE, "DMEM code download success, CPUStatus(%#x)\n", CPUStatus);
 257
 258 //              PollingCnt = 100; // Set polling cycle to 10ms.
 259               PollingCnt = 10000; // Set polling cycle to 10ms.
 260
 261                 do
 262                 {//Polling Load Firmware ready
 263                         CPUStatus = read_nic_byte(dev, TCR);
 264                         if(CPUStatus & FWRDY)
 265                                 break;
 266
 267                         udelay(100);
 268                 }while(PollingCnt--);
 269
 270                 RT_TRACE(COMP_FIRMWARE, "Polling Load Firmware ready, CPUStatus(%x)\n", CPUStatus);
 271
 272                 //if(!(CPUStatus & LOAD_FW_READY))
 273                 //if((CPUStatus & LOAD_FW_READY) != 0xff)
 274                 if((CPUStatus & LOAD_FW_READY) != LOAD_FW_READY)
 275                 {
 276                         RT_TRACE(COMP_ERR, "Polling Load Firmware ready fail ! CPUStatus(%x)\n", CPUStatus);
 277                         return false;
 278                 }
 279
 280                //
 281               // <Roger_Notes> USB interface will update reserved followings parameters later!!
 282               // 2008.08.28.
 283               //
 284
 285                //
 286               // <Roger_Notes> If right here, we can set TCR/RCR to desired value
 287               // and config MAC lookback mode to normal mode. 2008.08.28.
 288               //
 289               tmpU4b = read_nic_dword(dev,TCR);
 290                 write_nic_dword(dev, TCR, (tmpU4b&(~TCR_ICV)));
 291
 292                 tmpU4b = read_nic_dword(dev, RCR);
 293                 write_nic_dword(dev, RCR,
 294                         (tmpU4b|RCR_APPFCS|RCR_APP_ICV|RCR_APP_MIC));
 295
 296                 RT_TRACE(COMP_FIRMWARE, "FirmwareCheckReady(): Current RCR settings(%#x)\n", tmpU4b);
 297
 298
 299                 // Set to normal mode.
 300                 write_nic_byte(dev, LBKMD_SEL, LBK_NORMAL);
 301
 302         }
 303
 304         RT_TRACE(COMP_FIRMWARE, "<---FirmwareCheckReady(): LoadFWStatus(%d), rtStatus(%x)\n", LoadFWStatus, rtStatus);
 305         return (rtStatus == RT_STATUS_SUCCESS) ? true:false;
 306 }
 307
 308 //
 309 // Description:   This routine is to update the RF types in FW header partially.
 310 //
 311 // Created by Roger, 2008.12.24.
 312 //
 313 u8 FirmwareHeaderMapRfType(struct net_device *dev)
 314 {
 315         struct r8192_priv       *priv = ieee80211_priv(dev);
 316         switch(priv->rf_type)
 317         {
 318                 case RF_1T1R:   return 0x11;
 319                 case RF_1T2R:   return 0x12;
 320                 case RF_2T2R:   return 0x22;
 321                 case RF_2T2R_GREEN:     return 0x92;
 322                 default:
 323                         RT_TRACE(COMP_INIT, "Unknown RF type(%x)\n",priv->rf_type);
 324                         break;
 325         }
 326         return 0x22;
 327 }
 328
 329
 330 //
 331 // Description:   This routine is to update the private parts in FW header partially.
 332 //
 333 // Created by Roger, 2008.12.18.
 334 //
 335 void FirmwareHeaderPriveUpdate(struct net_device *dev, PRT_8192S_FIRMWARE_PRIV  pFwPriv)
 336 {
 337         struct r8192_priv       *priv = ieee80211_priv(dev);
 338         // Update USB endpoint number for RQPN settings.
 339         pFwPriv->usb_ep_num = priv->EEPROMUsbEndPointNumber; // endpoint number: 4, 6 and 11.
 340         RT_TRACE(COMP_INIT, "FirmwarePriveUpdate(): usb_ep_num(%#x)\n", pFwPriv->usb_ep_num);
 341
 342         // Update RF types for RATR settings.
 343         pFwPriv->rf_config = FirmwareHeaderMapRfType(dev);
 344 }
 345
 346
 347
 348 bool FirmwareDownload92S(struct net_device *dev)
 349 {
 350         struct r8192_priv       *priv = ieee80211_priv(dev);
 351         bool                            rtStatus = true;
 352         const char              *pFwImageFileName[1] = {"RTL8192SU/rtl8192sfw.bin"};
 353         u8                              *pucMappedFile = NULL;
 354         u32                             ulFileLength, ulInitStep = 0;
 355         u8                              FwHdrSize = RT_8192S_FIRMWARE_HDR_SIZE;
 356         rt_firmware             *pFirmware = priv->pFirmware;
 357         u8                              FwStatus = FW_STATUS_INIT;
 358         PRT_8192S_FIRMWARE_HDR          pFwHdr = NULL;
 359         PRT_8192S_FIRMWARE_PRIV         pFwPriv = NULL;
 360         int                             rc;
 361         const struct firmware   *fw_entry;
 362         u32                             file_length = 0;
 363
 364         pFirmware->FWStatus = FW_STATUS_INIT;
 365
 366         RT_TRACE(COMP_FIRMWARE, " --->FirmwareDownload92S()\n");
 367
 368         //3//
 369         //3 //<1> Open Image file, and map file to contineous memory if open file success.
 370         //3  //        or read image file from array. Default load from BIN file
 371         //3//
 372         priv->firmware_source = FW_SOURCE_IMG_FILE;// We should decided by Reg.
 373
 374         switch( priv->firmware_source )
 375         {
 376                 case FW_SOURCE_IMG_FILE:
 377                         if(pFirmware->szFwTmpBufferLen == 0)
 378                         {
 379
 380                                 rc = request_firmware(&fw_entry, pFwImageFileName[ulInitStep],&priv->udev->dev);//===>1
 381                                 if(rc < 0 ) {
 382                                         RT_TRACE(COMP_ERR, "request firmware fail!\n");
 383                                         goto DownloadFirmware_Fail;
 384                                 }
 385
 386                                 if(fw_entry->size > sizeof(pFirmware->szFwTmpBuffer))
 387                                 {
 388                                         RT_TRACE(COMP_ERR, "img file size exceed the container buffer fail!\n");
 389                                         release_firmware(fw_entry);
 390                                         goto DownloadFirmware_Fail;
 391                                 }
 392
 393                                 memcpy(pFirmware->szFwTmpBuffer,fw_entry->data,fw_entry->size);
 394                                 pFirmware->szFwTmpBufferLen = fw_entry->size;
 395                                 release_firmware(fw_entry);
 396
 397                                 pucMappedFile = pFirmware->szFwTmpBuffer;
 398                                 file_length = pFirmware->szFwTmpBufferLen;
 399
 400                                 //Retrieve FW header.
 401                                 pFirmware->pFwHeader = (PRT_8192S_FIRMWARE_HDR) pucMappedFile;
 402                                 pFwHdr = pFirmware->pFwHeader;
 403                                 RT_TRACE(COMP_FIRMWARE,"signature:%x, version:%x, size:%x, imemsize:%x, sram size:%x\n", \
 404                                                 pFwHdr->Signature, pFwHdr->Version, pFwHdr->DMEMSize, \
 405                                                 pFwHdr->IMG_IMEM_SIZE, pFwHdr->IMG_SRAM_SIZE);
 406                                 pFirmware->FirmwareVersion =  byte(pFwHdr->Version ,0);
 407                                 if ((pFwHdr->IMG_IMEM_SIZE==0) || (pFwHdr->IMG_IMEM_SIZE > sizeof(pFirmware->FwIMEM)))
 408                                 {
 409                                         RT_TRACE(COMP_ERR, "%s: memory for data image is less than IMEM required\n",\
 410                                                         __FUNCTION__);
 411                                         goto DownloadFirmware_Fail;
 412                                 } else {
 413                                         pucMappedFile+=FwHdrSize;
 414
 415                                         //Retrieve IMEM image.
 416                                         memcpy(pFirmware->FwIMEM, pucMappedFile, pFwHdr->IMG_IMEM_SIZE);
 417                                         pFirmware->FwIMEMLen = pFwHdr->IMG_IMEM_SIZE;
 418                                 }
 419
 420                                 if (pFwHdr->IMG_SRAM_SIZE > sizeof(pFirmware->FwEMEM))
 421                                 {
 422                                         RT_TRACE(COMP_ERR, "%s: memory for data image is less than EMEM required\n",\
 423                                                         __FUNCTION__);
 424                                         goto DownloadFirmware_Fail;
 425                                 } else {
 426                                         pucMappedFile += pFirmware->FwIMEMLen;
 427
 428                                         /* Retriecve EMEM image */
 429                                         memcpy(pFirmware->FwEMEM, pucMappedFile, pFwHdr->IMG_SRAM_SIZE);//===>6
 430                                         pFirmware->FwEMEMLen = pFwHdr->IMG_SRAM_SIZE;
 431                                 }
 432
 433
 434                         }
 435                         break;
 436
 437                 case FW_SOURCE_HEADER_FILE:
 438 #if 1
 439 #define Rtl819XFwImageArray Rtl8192SUFwImgArray
 440                         //2008.11.10 Add by tynli.
 441                         pucMappedFile = Rtl819XFwImageArray;
 442                         ulFileLength = ImgArrayLength;
 443
 444                         RT_TRACE(COMP_INIT,"Fw download from header.\n");
 445                         /* Retrieve FW header*/
 446                         pFirmware->pFwHeader = (PRT_8192S_FIRMWARE_HDR) pucMappedFile;
 447                         pFwHdr = pFirmware->pFwHeader;
 448                         RT_TRACE(COMP_FIRMWARE,"signature:%x, version:%x, size:%x, imemsize:%x, sram size:%x\n", \
 449                                         pFwHdr->Signature, pFwHdr->Version, pFwHdr->DMEMSize, \
 450                                         pFwHdr->IMG_IMEM_SIZE, pFwHdr->IMG_SRAM_SIZE);
 451                         pFirmware->FirmwareVersion =  byte(pFwHdr->Version ,0);
 452
 453                         if ((pFwHdr->IMG_IMEM_SIZE==0) || (pFwHdr->IMG_IMEM_SIZE > sizeof(pFirmware->FwIMEM)))
 454                         {
 455                                 printk("FirmwareDownload92S(): memory for data image is less than IMEM required\n");
 456                                 goto DownloadFirmware_Fail;
 457                         } else {
 458                                 pucMappedFile+=FwHdrSize;
 459                                 //Retrieve IMEM image.
 460                                 memcpy(pFirmware->FwIMEM, pucMappedFile, pFwHdr->IMG_IMEM_SIZE);
 461                                 pFirmware->FwIMEMLen = pFwHdr->IMG_IMEM_SIZE;
 462                         }
 463
 464                         if (pFwHdr->IMG_SRAM_SIZE > sizeof(pFirmware->FwEMEM))
 465                         {
 466                                 printk(" FirmwareDownload92S(): memory for data image is less than EMEM required\n");
 467                                 goto DownloadFirmware_Fail;
 468                         } else {
 469                                 pucMappedFile+= pFirmware->FwIMEMLen;
 470
 471                                 //Retriecve EMEM image.
 472                                 memcpy(pFirmware->FwEMEM, pucMappedFile, pFwHdr->IMG_SRAM_SIZE);
 473                                 pFirmware->FwEMEMLen = pFwHdr->IMG_SRAM_SIZE;
 474                         }
 475 #endif
 476                         break;
 477                 default:
 478                         break;
 479         }
 480
 481         FwStatus = FirmwareGetNextStatus(pFirmware->FWStatus);
 482         while(FwStatus!= FW_STATUS_READY)
 483         {
 484                 // Image buffer redirection.
 485                 switch(FwStatus)
 486                 {
 487                         case FW_STATUS_LOAD_IMEM:
 488                                 pucMappedFile = pFirmware->FwIMEM;
 489                                 ulFileLength = pFirmware->FwIMEMLen;
 490                                 break;
 491
 492                         case FW_STATUS_LOAD_EMEM:
 493                                 pucMappedFile = pFirmware->FwEMEM;
 494                                 ulFileLength = pFirmware->FwEMEMLen;
 495                                 break;
 496
 497                         case FW_STATUS_LOAD_DMEM:
 498                                 /* <Roger_Notes> Partial update the content of header private. 2008.12.18 */
 499                                 pFwHdr = pFirmware->pFwHeader;
 500                                 pFwPriv = (PRT_8192S_FIRMWARE_PRIV)&pFwHdr->FWPriv;
 501                                 FirmwareHeaderPriveUpdate(dev, pFwPriv);
 502                                 pucMappedFile = (u8*)(pFirmware->pFwHeader)+RT_8192S_FIRMWARE_HDR_EXCLUDE_PRI_SIZE;
 503                                 ulFileLength = FwHdrSize-RT_8192S_FIRMWARE_HDR_EXCLUDE_PRI_SIZE;
 504                                 break;
 505
 506                         default:
 507                                 RT_TRACE(COMP_ERR, "Unexpected Download step!!\n");
 508                                 goto DownloadFirmware_Fail;
 509                                 break;
 510                 }
 511
 512                 //3//
 513                 //3// <2> Download image file
 514         //3     //
 515                 rtStatus = FirmwareDownloadCode(dev, pucMappedFile, ulFileLength);
 516
 517                 if(rtStatus != true)
 518                 {
 519                         RT_TRACE(COMP_ERR, "FirmwareDownloadCode() fail ! \n" );
 520                         goto DownloadFirmware_Fail;
 521                 }
 522
 523                 //3//
 524                 //3// <3> Check whether load FW process is ready
 525         //3     //
 526                 rtStatus = FirmwareCheckReady(dev, FwStatus);
 527
 528                 if(rtStatus != true)
 529                 {
 530                         RT_TRACE(COMP_ERR, "FirmwareDownloadCode() fail ! \n");
 531                         goto DownloadFirmware_Fail;
 532                 }
 533
 534                 FwStatus = FirmwareGetNextStatus(pFirmware->FWStatus);
 535         }
 536
 537         RT_TRACE(COMP_FIRMWARE, "Firmware Download Success!!\n");
 538         return rtStatus;
 539
 540         DownloadFirmware_Fail:
 541         RT_TRACE(COMP_ERR, "Firmware Download Fail!!%x\n",read_nic_word(dev, TCR));
 542         rtStatus = false;
 543         return rtStatus;
 544 }
 545