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 #if defined(RTL8192SE)||defined(RTL8192SU)
  15 #include "r8192U.h"
  16 #include "r8192S_firmware.h"
  17 #include <linux/unistd.h>
  18
  19 #ifdef RTL8192SU
  20 #include "r8192S_hw.h"
  21 #include "r8192SU_HWImg.h"
  22 //#include "r8192S_FwImgDTM.h"
  23 #else
  24 //#include "r8192U_hw.h"
  25 #include "r8192xU_firmware_img.h"
  26 #endif
  27
  28 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
  29 #include <linux/firmware.h>
  30 #endif
  31
  32 #define   byte(x,n)  ( (x >> (8 * n)) & 0xff  )
  33
  34 //
  35 // Description:   This routine will intialize firmware. If any error occurs during the initialization
  36 //                              process, the routine shall terminate immediately and return fail.
  37 //
  38 // Arguments:   The pointer of the adapter
  39 //                         Code address (Virtual address, should fill descriptor with physical address)
  40 //                         Code size
  41 // Created by Roger, 2008.04.10.
  42 //
  43 bool FirmwareDownloadCode(struct net_device *dev, u8 *  code_virtual_address,u32 buffer_len)
  44 {
  45         struct r8192_priv   *priv = ieee80211_priv(dev);
  46         bool                rt_status = true;
  47         u16                 frag_threshold = MAX_FIRMWARE_CODE_SIZE; //Fragmentation might be required in 90/92 but not in 92S
  48         u16                 frag_length, frag_offset = 0;
  49         struct sk_buff      *skb;
  50         unsigned char       *seg_ptr;
  51         cb_desc             *tcb_desc;
  52         u8                          bLastIniPkt = 0;
  53         u16                         ExtraDescOffset = 0;
  54
  55 #ifdef RTL8192SE
  56         fw_SetRQPN(dev);        // For 92SE only
  57 #endif
  58
  59         RT_TRACE(COMP_FIRMWARE, "--->FirmwareDownloadCode()\n" );
  60
  61         //MAX_TRANSMIT_BUFFER_SIZE
  62         if(buffer_len >= MAX_FIRMWARE_CODE_SIZE-USB_HWDESC_HEADER_LEN)
  63         {
  64                 RT_TRACE(COMP_ERR, "Size over MAX_FIRMWARE_CODE_SIZE! \n");
  65                 goto cmdsend_downloadcode_fail;
  66         }
  67
  68         ExtraDescOffset = USB_HWDESC_HEADER_LEN;
  69
  70         do {
  71                 if((buffer_len-frag_offset) > frag_threshold)
  72                 {
  73                         frag_length = frag_threshold + ExtraDescOffset;
  74                 }
  75                 else
  76                 {
  77                         frag_length = (u16)(buffer_len - frag_offset + ExtraDescOffset);
  78                 bLastIniPkt = 1;
  79                 }
  80
  81                 /* Allocate skb buffer to contain firmware info and tx descriptor info. */
  82                 skb  = dev_alloc_skb(frag_length);
  83                 memcpy((unsigned char *)(skb->cb),&dev,sizeof(dev));
  84
  85                 tcb_desc = (cb_desc*)(skb->cb + MAX_DEV_ADDR_SIZE);
  86                 tcb_desc->queue_index = TXCMD_QUEUE;
  87                 tcb_desc->bCmdOrInit = DESC_PACKET_TYPE_INIT;
  88                 tcb_desc->bLastIniPkt = bLastIniPkt;
  89
  90                 skb_reserve(skb, ExtraDescOffset);
  91                 seg_ptr = (u8 *)skb_put(skb, (u32)(frag_length-ExtraDescOffset));
  92                 memcpy(seg_ptr, code_virtual_address+frag_offset, (u32)(frag_length-ExtraDescOffset));
  93
  94                 tcb_desc->txbuf_size= frag_length;
  95
  96                 if(!priv->ieee80211->check_nic_enough_desc(dev,tcb_desc->queue_index)||
  97                         (!skb_queue_empty(&priv->ieee80211->skb_waitQ[tcb_desc->queue_index]))||\
  98                         (priv->ieee80211->queue_stop) )
  99                 {
 100                         RT_TRACE(COMP_FIRMWARE,"=====================================================> tx full!\n");
 101                         skb_queue_tail(&priv->ieee80211->skb_waitQ[tcb_desc->queue_index], skb);
 102                 }
 103                 else
 104                 {
 105                         priv->ieee80211->softmac_hard_start_xmit(skb,dev);
 106                 }
 107
 108                 frag_offset += (frag_length - ExtraDescOffset);
 109
 110         }while(frag_offset < buffer_len);
 111
 112         return rt_status ;
 113
 114
 115 cmdsend_downloadcode_fail:
 116         rt_status = false;
 117         RT_TRACE(COMP_ERR, "CmdSendDownloadCode fail !!\n");
 118         return rt_status;
 119
 120 }
 121
 122 #ifdef RTL8192SE
 123 static void fw_SetRQPN(struct net_device *dev)
 124 {
 125         // Only for 92SE HW bug, we have to set RAPN before every FW download
 126         // We can remove the code later.
 127         write_nic_dword(dev,  RQPN, 0xffffffff);
 128         write_nic_dword(dev,  RQPN+4, 0xffffffff);
 129         write_nic_byte(dev,  RQPN+8, 0xff);
 130         write_nic_byte(dev,  RQPN+0xB, 0x80);
 131         //#if ((HAL_CODE_BASE ==  RTL8192_S) && (PLATFORM != PLATFORM_WINDOWS_USB))
 132
 133 }       /* fw_SetRQPN */
 134 #endif
 135
 136 RT_STATUS
 137 FirmwareEnableCPU(struct net_device *dev)
 138 {
 139
 140         RT_STATUS       rtStatus = RT_STATUS_SUCCESS;
 141         u8              tmpU1b, CPUStatus = 0;
 142         u16             tmpU2b;
 143         u32             iCheckTime = 200;
 144
 145         RT_TRACE(COMP_FIRMWARE, "-->FirmwareEnableCPU()\n" );
 146 #ifdef RTL8192SE
 147         fw_SetRQPN(dev);        // For 92SE only
 148 #endif
 149         // Enable CPU.
 150         tmpU1b = read_nic_byte(dev, SYS_CLKR);
 151         write_nic_byte(dev,  SYS_CLKR, (tmpU1b|SYS_CPU_CLKSEL)); //AFE source
 152
 153         tmpU2b = read_nic_word(dev, SYS_FUNC_EN);
 154         write_nic_word(dev, SYS_FUNC_EN, (tmpU2b|FEN_CPUEN));
 155
 156         //Polling IMEM Ready after CPU has refilled.
 157         do
 158         {
 159                 CPUStatus = read_nic_byte(dev, TCR);
 160                 if(CPUStatus& IMEM_RDY)
 161                 {
 162                         RT_TRACE(COMP_FIRMWARE, "IMEM Ready after CPU has refilled.\n");
 163                         break;
 164                 }
 165
 166                 //usleep(100);
 167                 udelay(100);
 168         }while(iCheckTime--);
 169
 170         if(!(CPUStatus & IMEM_RDY))
 171                 return RT_STATUS_FAILURE;
 172
 173         RT_TRACE(COMP_FIRMWARE, "<--FirmwareEnableCPU(): rtStatus(%#x)\n", rtStatus);
 174         return rtStatus;
 175 }
 176
 177 FIRMWARE_8192S_STATUS
 178 FirmwareGetNextStatus(FIRMWARE_8192S_STATUS FWCurrentStatus)
 179 {
 180         FIRMWARE_8192S_STATUS   NextFWStatus = 0;
 181
 182         switch(FWCurrentStatus)
 183         {
 184                 case FW_STATUS_INIT:
 185                         NextFWStatus = FW_STATUS_LOAD_IMEM;
 186                         break;
 187
 188                 case FW_STATUS_LOAD_IMEM:
 189                         NextFWStatus = FW_STATUS_LOAD_EMEM;
 190                         break;
 191
 192                 case FW_STATUS_LOAD_EMEM:
 193                         NextFWStatus = FW_STATUS_LOAD_DMEM;
 194                         break;
 195
 196                 case FW_STATUS_LOAD_DMEM:
 197                         NextFWStatus = FW_STATUS_READY;
 198                         break;
 199
 200                 default:
 201                         RT_TRACE(COMP_ERR,"Invalid FW Status(%#x)!!\n", FWCurrentStatus);
 202                         break;
 203         }
 204         return  NextFWStatus;
 205 }
 206
 207 bool
 208 FirmwareCheckReady(struct net_device *dev,      u8 LoadFWStatus)
 209 {
 210         struct r8192_priv       *priv = ieee80211_priv(dev);
 211         RT_STATUS       rtStatus = RT_STATUS_SUCCESS;
 212         rt_firmware     *pFirmware = priv->pFirmware;
 213         int                     PollingCnt = 1000;
 214         //u8            tmpU1b, CPUStatus = 0;
 215         u8              CPUStatus = 0;
 216         u32             tmpU4b;
 217         //bool          bOrgIMREnable;
 218
 219         RT_TRACE(COMP_FIRMWARE, "--->FirmwareCheckReady(): LoadStaus(%d),", LoadFWStatus);
 220
 221         pFirmware->FWStatus = (FIRMWARE_8192S_STATUS)LoadFWStatus;
 222         if( LoadFWStatus == FW_STATUS_LOAD_IMEM)
 223         {
 224                 do
 225                 {//Polling IMEM code done.
 226                         CPUStatus = read_nic_byte(dev, TCR);
 227                         if(CPUStatus& IMEM_CODE_DONE)
 228                                 break;
 229
 230                         udelay(5);
 231                 }while(PollingCnt--);
 232                 if(!(CPUStatus & IMEM_CHK_RPT) || PollingCnt <= 0)
 233                 {
 234                         RT_TRACE(COMP_ERR, "FW_STATUS_LOAD_IMEM FAIL CPU, Status=%x\r\n", CPUStatus);
 235                         return false;
 236                 }
 237         }
 238         else if( LoadFWStatus == FW_STATUS_LOAD_EMEM)
 239         {//Check Put Code OK and Turn On CPU
 240                 do
 241                 {//Polling EMEM code done.
 242                         CPUStatus = read_nic_byte(dev, TCR);
 243                         if(CPUStatus& EMEM_CODE_DONE)
 244                                 break;
 245
 246                         udelay(5);
 247                 }while(PollingCnt--);
 248                 if(!(CPUStatus & EMEM_CHK_RPT))
 249                 {
 250                         RT_TRACE(COMP_ERR, "FW_STATUS_LOAD_EMEM FAIL CPU, Status=%x\r\n", CPUStatus);
 251                         return false;
 252                 }
 253
 254                 // Turn On CPU
 255                 rtStatus = FirmwareEnableCPU(dev);
 256                 if(rtStatus != RT_STATUS_SUCCESS)
 257                 {
 258                         RT_TRACE(COMP_ERR, "Enable CPU fail ! \n" );
 259                         return false;
 260                 }
 261         }
 262         else if( LoadFWStatus == FW_STATUS_LOAD_DMEM)
 263         {
 264                 do
 265                 {//Polling DMEM code done
 266                         CPUStatus = read_nic_byte(dev, TCR);
 267                         if(CPUStatus& DMEM_CODE_DONE)
 268                                 break;
 269
 270                         udelay(5);
 271                 }while(PollingCnt--);
 272
 273                 if(!(CPUStatus & DMEM_CODE_DONE))
 274                 {
 275                         RT_TRACE(COMP_ERR, "Polling  DMEM code done fail ! CPUStatus(%#x)\n", CPUStatus);
 276                         return false;
 277                 }
 278
 279                 RT_TRACE(COMP_FIRMWARE, "DMEM code download success, CPUStatus(%#x)\n", CPUStatus);
 280
 281 //              PollingCnt = 100; // Set polling cycle to 10ms.
 282               PollingCnt = 10000; // Set polling cycle to 10ms.
 283
 284                 do
 285                 {//Polling Load Firmware ready
 286                         CPUStatus = read_nic_byte(dev, TCR);
 287                         if(CPUStatus & FWRDY)
 288                                 break;
 289
 290                         udelay(100);
 291                 }while(PollingCnt--);
 292
 293                 RT_TRACE(COMP_FIRMWARE, "Polling Load Firmware ready, CPUStatus(%x)\n", CPUStatus);
 294
 295                 //if(!(CPUStatus & LOAD_FW_READY))
 296                 //if((CPUStatus & LOAD_FW_READY) != 0xff)
 297                 if((CPUStatus & LOAD_FW_READY) != LOAD_FW_READY)
 298                 {
 299                         RT_TRACE(COMP_ERR, "Polling Load Firmware ready fail ! CPUStatus(%x)\n", CPUStatus);
 300                         return false;
 301                 }
 302
 303                //
 304               // <Roger_Notes> USB interface will update reserved followings parameters later!!
 305               // 2008.08.28.
 306               //
 307 #ifdef RTL8192SE
 308                 //write_nic_dword(dev, RQPN, 0x10101010);
 309                 //write_nic_byte(dev,  0xAB, 0x80);
 310 #endif
 311
 312                //
 313               // <Roger_Notes> If right here, we can set TCR/RCR to desired value
 314               // and config MAC lookback mode to normal mode. 2008.08.28.
 315               //
 316               tmpU4b = read_nic_dword(dev,TCR);
 317                 write_nic_dword(dev, TCR, (tmpU4b&(~TCR_ICV)));
 318
 319                 tmpU4b = read_nic_dword(dev, RCR);
 320                 write_nic_dword(dev, RCR,
 321                         (tmpU4b|RCR_APPFCS|RCR_APP_ICV|RCR_APP_MIC));
 322
 323                 RT_TRACE(COMP_FIRMWARE, "FirmwareCheckReady(): Current RCR settings(%#x)\n", tmpU4b);
 324
 325 #if (defined (RTL8192SU_FPGA_2MAC_VERIFICATION) ||defined (RTL8192SU_ASIC_VERIFICATION))
 326 #ifdef NOT_YET   //YJ,TMP
 327                 priv->TransmitConfig = read_nic_dword(dev, TCR);
 328                 RT_TRACE(COMP_FIRMWARE, "FirmwareCheckReady(): Current TCR settings(%x)\n", priv->TransmitConfig);
 329                 pHalData->FwRsvdTxPageCfg = read_nic_byte(dev, FW_RSVD_PG_CRTL);
 330 #endif
 331 #endif
 332
 333                 // Set to normal mode.
 334                 write_nic_byte(dev, LBKMD_SEL, LBK_NORMAL);
 335
 336         }
 337
 338         RT_TRACE(COMP_FIRMWARE, "<---FirmwareCheckReady(): LoadFWStatus(%d), rtStatus(%x)\n", LoadFWStatus, rtStatus);
 339         return (rtStatus == RT_STATUS_SUCCESS) ? true:false;
 340 }
 341
 342 //
 343 // Description:   This routine is to update the RF types in FW header partially.
 344 //
 345 // Created by Roger, 2008.12.24.
 346 //
 347 u8 FirmwareHeaderMapRfType(struct net_device *dev)
 348 {
 349         struct r8192_priv       *priv = ieee80211_priv(dev);
 350         switch(priv->rf_type)
 351         {
 352                 case RF_1T1R:   return 0x11;
 353                 case RF_1T2R:   return 0x12;
 354                 case RF_2T2R:   return 0x22;
 355                 case RF_2T2R_GREEN:     return 0x92;
 356                 default:
 357                         RT_TRACE(COMP_INIT, "Unknown RF type(%x)\n",priv->rf_type);
 358                         break;
 359         }
 360         return 0x22;
 361 }
 362
 363
 364 //
 365 // Description:   This routine is to update the private parts in FW header partially.
 366 //
 367 // Created by Roger, 2008.12.18.
 368 //
 369 void FirmwareHeaderPriveUpdate(struct net_device *dev, PRT_8192S_FIRMWARE_PRIV  pFwPriv)
 370 {
 371         struct r8192_priv       *priv = ieee80211_priv(dev);
 372 #ifdef RTL8192SU
 373         // Update USB endpoint number for RQPN settings.
 374         pFwPriv->usb_ep_num = priv->EEPROMUsbEndPointNumber; // endpoint number: 4, 6 and 11.
 375         RT_TRACE(COMP_INIT, "FirmwarePriveUpdate(): usb_ep_num(%#x)\n", pFwPriv->usb_ep_num);
 376 #endif
 377
 378         // Update RF types for RATR settings.
 379         pFwPriv->rf_config = FirmwareHeaderMapRfType(dev);
 380 }
 381
 382
 383
 384 bool FirmwareDownload92S(struct net_device *dev)
 385 {
 386         struct r8192_priv       *priv = ieee80211_priv(dev);
 387         bool                            rtStatus = true;
 388         const char              *pFwImageFileName[1] = {"RTL8192SU/rtl8192sfw.bin"};
 389         u8                              *pucMappedFile = NULL;
 390         u32                             ulFileLength, ulInitStep = 0;
 391         u8                              FwHdrSize = RT_8192S_FIRMWARE_HDR_SIZE;
 392         rt_firmware             *pFirmware = priv->pFirmware;
 393         u8                              FwStatus = FW_STATUS_INIT;
 394         PRT_8192S_FIRMWARE_HDR          pFwHdr = NULL;
 395         PRT_8192S_FIRMWARE_PRIV         pFwPriv = NULL;
 396         int                             rc;
 397         const struct firmware   *fw_entry;
 398         u32                             file_length = 0;
 399
 400         pFirmware->FWStatus = FW_STATUS_INIT;
 401
 402         RT_TRACE(COMP_FIRMWARE, " --->FirmwareDownload92S()\n");
 403
 404         //3//
 405         //3 //<1> Open Image file, and map file to contineous memory if open file success.
 406         //3  //        or read image file from array. Default load from BIN file
 407         //3//
 408 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
 409         priv->firmware_source = FW_SOURCE_HEADER_FILE;
 410 #else
 411         priv->firmware_source = FW_SOURCE_IMG_FILE;// We should decided by Reg.
 412 #endif
 413
 414         switch( priv->firmware_source )
 415         {
 416                 case FW_SOURCE_IMG_FILE:
 417 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
 418                         if(pFirmware->szFwTmpBufferLen == 0)
 419                         {
 420
 421                                 rc = request_firmware(&fw_entry, pFwImageFileName[ulInitStep],&priv->udev->dev);//===>1
 422                                 if(rc < 0 ) {
 423                                         RT_TRACE(COMP_ERR, "request firmware fail!\n");
 424                                         goto DownloadFirmware_Fail;
 425                                 }
 426
 427                                 if(fw_entry->size > sizeof(pFirmware->szFwTmpBuffer))
 428                                 {
 429                                         RT_TRACE(COMP_ERR, "img file size exceed the container buffer fail!\n");
 430                                         release_firmware(fw_entry);
 431                                         goto DownloadFirmware_Fail;
 432                                 }
 433
 434                                 memcpy(pFirmware->szFwTmpBuffer,fw_entry->data,fw_entry->size);
 435                                 pFirmware->szFwTmpBufferLen = fw_entry->size;
 436                                 release_firmware(fw_entry);
 437
 438                                 pucMappedFile = pFirmware->szFwTmpBuffer;
 439                                 file_length = pFirmware->szFwTmpBufferLen;
 440
 441                                 //Retrieve FW header.
 442                                 pFirmware->pFwHeader = (PRT_8192S_FIRMWARE_HDR) pucMappedFile;
 443                                 pFwHdr = pFirmware->pFwHeader;
 444                                 RT_TRACE(COMP_FIRMWARE,"signature:%x, version:%x, size:%x, imemsize:%x, sram size:%x\n", \
 445                                                 pFwHdr->Signature, pFwHdr->Version, pFwHdr->DMEMSize, \
 446                                                 pFwHdr->IMG_IMEM_SIZE, pFwHdr->IMG_SRAM_SIZE);
 447                                 pFirmware->FirmwareVersion =  byte(pFwHdr->Version ,0);
 448                                 if ((pFwHdr->IMG_IMEM_SIZE==0) || (pFwHdr->IMG_IMEM_SIZE > sizeof(pFirmware->FwIMEM)))
 449                                 {
 450                                         RT_TRACE(COMP_ERR, "%s: memory for data image is less than IMEM required\n",\
 451                                                         __FUNCTION__);
 452                                         goto DownloadFirmware_Fail;
 453                                 } else {
 454                                         pucMappedFile+=FwHdrSize;
 455
 456                                         //Retrieve IMEM image.
 457                                         memcpy(pFirmware->FwIMEM, pucMappedFile, pFwHdr->IMG_IMEM_SIZE);
 458                                         pFirmware->FwIMEMLen = pFwHdr->IMG_IMEM_SIZE;
 459                                 }
 460
 461                                 if (pFwHdr->IMG_SRAM_SIZE > sizeof(pFirmware->FwEMEM))
 462                                 {
 463                                         RT_TRACE(COMP_ERR, "%s: memory for data image is less than EMEM required\n",\
 464                                                         __FUNCTION__);
 465                                         goto DownloadFirmware_Fail;
 466                                 } else {
 467                                         pucMappedFile += pFirmware->FwIMEMLen;
 468
 469                                         /* Retriecve EMEM image */
 470                                         memcpy(pFirmware->FwEMEM, pucMappedFile, pFwHdr->IMG_SRAM_SIZE);//===>6
 471                                         pFirmware->FwEMEMLen = pFwHdr->IMG_SRAM_SIZE;
 472                                 }
 473
 474
 475                         }
 476 #endif
 477                         break;
 478
 479                 case FW_SOURCE_HEADER_FILE:
 480 #if 1
 481 #define Rtl819XFwImageArray Rtl8192SUFwImgArray
 482                         //2008.11.10 Add by tynli.
 483                         pucMappedFile = Rtl819XFwImageArray;
 484                         ulFileLength = ImgArrayLength;
 485
 486                         RT_TRACE(COMP_INIT,"Fw download from header.\n");
 487                         /* Retrieve FW header*/
 488                         pFirmware->pFwHeader = (PRT_8192S_FIRMWARE_HDR) pucMappedFile;
 489                         pFwHdr = pFirmware->pFwHeader;
 490                         RT_TRACE(COMP_FIRMWARE,"signature:%x, version:%x, size:%x, imemsize:%x, sram size:%x\n", \
 491                                         pFwHdr->Signature, pFwHdr->Version, pFwHdr->DMEMSize, \
 492                                         pFwHdr->IMG_IMEM_SIZE, pFwHdr->IMG_SRAM_SIZE);
 493                         pFirmware->FirmwareVersion =  byte(pFwHdr->Version ,0);
 494
 495                         if ((pFwHdr->IMG_IMEM_SIZE==0) || (pFwHdr->IMG_IMEM_SIZE > sizeof(pFirmware->FwIMEM)))
 496                         {
 497                                 printk("FirmwareDownload92S(): memory for data image is less than IMEM required\n");
 498                                 goto DownloadFirmware_Fail;
 499                         } else {
 500                                 pucMappedFile+=FwHdrSize;
 501                                 //Retrieve IMEM image.
 502                                 memcpy(pFirmware->FwIMEM, pucMappedFile, pFwHdr->IMG_IMEM_SIZE);
 503                                 pFirmware->FwIMEMLen = pFwHdr->IMG_IMEM_SIZE;
 504                         }
 505
 506                         if (pFwHdr->IMG_SRAM_SIZE > sizeof(pFirmware->FwEMEM))
 507                         {
 508                                 printk(" FirmwareDownload92S(): memory for data image is less than EMEM required\n");
 509                                 goto DownloadFirmware_Fail;
 510                         } else {
 511                                 pucMappedFile+= pFirmware->FwIMEMLen;
 512
 513                                 //Retriecve EMEM image.
 514                                 memcpy(pFirmware->FwEMEM, pucMappedFile, pFwHdr->IMG_SRAM_SIZE);
 515                                 pFirmware->FwEMEMLen = pFwHdr->IMG_SRAM_SIZE;
 516                         }
 517 #endif
 518                         break;
 519                 default:
 520                         break;
 521         }
 522
 523         FwStatus = FirmwareGetNextStatus(pFirmware->FWStatus);
 524         while(FwStatus!= FW_STATUS_READY)
 525         {
 526                 // Image buffer redirection.
 527                 switch(FwStatus)
 528                 {
 529                         case FW_STATUS_LOAD_IMEM:
 530                                 pucMappedFile = pFirmware->FwIMEM;
 531                                 ulFileLength = pFirmware->FwIMEMLen;
 532                                 break;
 533
 534                         case FW_STATUS_LOAD_EMEM:
 535                                 pucMappedFile = pFirmware->FwEMEM;
 536                                 ulFileLength = pFirmware->FwEMEMLen;
 537                                 break;
 538
 539                         case FW_STATUS_LOAD_DMEM:
 540                                 /* <Roger_Notes> Partial update the content of header private. 2008.12.18 */
 541                                 pFwHdr = pFirmware->pFwHeader;
 542                                 pFwPriv = (PRT_8192S_FIRMWARE_PRIV)&pFwHdr->FWPriv;
 543                                 FirmwareHeaderPriveUpdate(dev, pFwPriv);
 544                                 pucMappedFile = (u8*)(pFirmware->pFwHeader)+RT_8192S_FIRMWARE_HDR_EXCLUDE_PRI_SIZE;
 545                                 ulFileLength = FwHdrSize-RT_8192S_FIRMWARE_HDR_EXCLUDE_PRI_SIZE;
 546                                 break;
 547
 548                         default:
 549                                 RT_TRACE(COMP_ERR, "Unexpected Download step!!\n");
 550                                 goto DownloadFirmware_Fail;
 551                                 break;
 552                 }
 553
 554                 //3//
 555                 //3// <2> Download image file
 556         //3     //
 557                 rtStatus = FirmwareDownloadCode(dev, pucMappedFile, ulFileLength);
 558
 559                 if(rtStatus != true)
 560                 {
 561                         RT_TRACE(COMP_ERR, "FirmwareDownloadCode() fail ! \n" );
 562                         goto DownloadFirmware_Fail;
 563                 }
 564
 565                 //3//
 566                 //3// <3> Check whether load FW process is ready
 567         //3     //
 568                 rtStatus = FirmwareCheckReady(dev, FwStatus);
 569
 570                 if(rtStatus != true)
 571                 {
 572                         RT_TRACE(COMP_ERR, "FirmwareDownloadCode() fail ! \n");
 573                         goto DownloadFirmware_Fail;
 574                 }
 575
 576                 FwStatus = FirmwareGetNextStatus(pFirmware->FWStatus);
 577         }
 578
 579         RT_TRACE(COMP_FIRMWARE, "Firmware Download Success!!\n");
 580         return rtStatus;
 581
 582         DownloadFirmware_Fail:
 583         RT_TRACE(COMP_ERR, "Firmware Download Fail!!%x\n",read_nic_word(dev, TCR));
 584         rtStatus = false;
 585         return rtStatus;
 586 }
 587 #else
 588 void firmware_init_param(struct net_device *dev)
 589 {
 590         struct r8192_priv       *priv = ieee80211_priv(dev);
 591         rt_firmware             *pfirmware = priv->pFirmware;
 592
 593         pfirmware->cmdpacket_frag_thresold = GET_COMMAND_PACKET_FRAG_THRESHOLD(MAX_TRANSMIT_BUFFER_SIZE);
 594 }
 595
 596 /*
 597  * segment the img and use the ptr and length to remember info on each segment
 598  *
 599  */
 600 bool fw_download_code(struct net_device *dev, u8 *code_virtual_address, u32 buffer_len)
 601 {
 602         struct r8192_priv   *priv = ieee80211_priv(dev);
 603         bool                rt_status = true;
 604         //u16               frag_threshold;
 605         u16                 frag_length, frag_offset = 0;
 606         //u16               total_size;
 607         int                 i;
 608
 609         //rt_firmware       *pfirmware = priv->pFirmware;
 610         struct sk_buff      *skb;
 611         unsigned char       *seg_ptr;
 612         cb_desc             *tcb_desc;
 613         u8                  bLastIniPkt;
 614 #ifdef RTL8192SE
 615         fw_SetRQPN(dev);        // For 92SE only
 616 #endif
 617
 618 #ifndef RTL8192SU
 619         if(buffer_len >= 64000-USB_HWDESC_HEADER_LEN)
 620         {
 621                 return rt_status;
 622         }
 623         firmware_init_param(dev);
 624         //Fragmentation might be required
 625         frag_threshold = pfirmware->cmdpacket_frag_thresold;
 626 #endif
 627
 628         do {
 629 #ifndef RTL8192SU
 630                 if((buffer_len - frag_offset) > frag_threshold) {
 631                         frag_length = frag_threshold ;
 632                         bLastIniPkt = 0;
 633
 634                 } else
 635 #endif
 636                 {
 637                         frag_length = buffer_len - frag_offset;
 638                         bLastIniPkt = 1;
 639
 640                 }
 641
 642                 /* Allocate skb buffer to contain firmware info and tx descriptor info
 643                  * add 4 to avoid packet appending overflow.
 644                  * */
 645                 #ifdef RTL8192U
 646                 skb  = dev_alloc_skb(USB_HWDESC_HEADER_LEN + frag_length + 4);
 647                 #else
 648                 skb  = dev_alloc_skb(frag_length + 4);
 649                 #endif
 650                 memcpy((unsigned char *)(skb->cb),&dev,sizeof(dev));
 651                 tcb_desc = (cb_desc*)(skb->cb + MAX_DEV_ADDR_SIZE);
 652                 tcb_desc->queue_index = TXCMD_QUEUE;
 653                 tcb_desc->bCmdOrInit = DESC_PACKET_TYPE_INIT;
 654                 tcb_desc->bLastIniPkt = bLastIniPkt;
 655
 656                 #ifdef RTL8192U
 657                 skb_reserve(skb, USB_HWDESC_HEADER_LEN);
 658                 #endif
 659                 seg_ptr = skb->data;
 660                 /*
 661                  * Transform from little endian to big endian
 662                  * and pending  zero
 663                  */
 664                 for(i=0 ; i < frag_length; i+=4) {
 665                         *seg_ptr++ = ((i+0)<frag_length)?code_virtual_address[i+3]:0;
 666                         *seg_ptr++ = ((i+1)<frag_length)?code_virtual_address[i+2]:0;
 667                         *seg_ptr++ = ((i+2)<frag_length)?code_virtual_address[i+1]:0;
 668                         *seg_ptr++ = ((i+3)<frag_length)?code_virtual_address[i+0]:0;
 669                 }
 670                 tcb_desc->txbuf_size= (u16)i;
 671                 skb_put(skb, i);
 672
 673                 if(!priv->ieee80211->check_nic_enough_desc(dev,tcb_desc->queue_index)||
 674                         (!skb_queue_empty(&priv->ieee80211->skb_waitQ[tcb_desc->queue_index]))||\
 675                         (priv->ieee80211->queue_stop) ) {
 676                         RT_TRACE(COMP_FIRMWARE,"=====================================================> tx full!\n");
 677                         skb_queue_tail(&priv->ieee80211->skb_waitQ[tcb_desc->queue_index], skb);
 678                 } else {
 679                         priv->ieee80211->softmac_hard_start_xmit(skb,dev);
 680                 }
 681
 682                 code_virtual_address += frag_length;
 683                 frag_offset += frag_length;
 684
 685         }while(frag_offset < buffer_len);
 686
 687         return rt_status;
 688
 689 #if 0
 690 cmdsend_downloadcode_fail:
 691         rt_status = false;
 692         RT_TRACE(COMP_ERR, "CmdSendDownloadCode fail !!\n");
 693         return rt_status;
 694 #endif
 695 }
 696
 697 bool
 698 fwSendNullPacket(
 699         struct net_device *dev,
 700         u32                     Length
 701 )
 702 {
 703         bool    rtStatus = true;
 704         struct r8192_priv   *priv = ieee80211_priv(dev);
 705         struct sk_buff      *skb;
 706         cb_desc             *tcb_desc;
 707         unsigned char       *ptr_buf;
 708         bool    bLastInitPacket = false;
 709
 710         //PlatformAcquireSpinLock(dev, RT_TX_SPINLOCK);
 711
 712         //Get TCB and local buffer from common pool. (It is shared by CmdQ, MgntQ, and USB coalesce DataQ)
 713         skb  = dev_alloc_skb(Length+ 4);
 714         memcpy((unsigned char *)(skb->cb),&dev,sizeof(dev));
 715         tcb_desc = (cb_desc*)(skb->cb + MAX_DEV_ADDR_SIZE);
 716         tcb_desc->queue_index = TXCMD_QUEUE;
 717         tcb_desc->bCmdOrInit = DESC_PACKET_TYPE_INIT;
 718         tcb_desc->bLastIniPkt = bLastInitPacket;
 719         ptr_buf = skb_put(skb, Length);
 720         memset(ptr_buf,0,Length);
 721         tcb_desc->txbuf_size= (u16)Length;
 722
 723         if(!priv->ieee80211->check_nic_enough_desc(dev,tcb_desc->queue_index)||
 724                         (!skb_queue_empty(&priv->ieee80211->skb_waitQ[tcb_desc->queue_index]))||\
 725                         (priv->ieee80211->queue_stop) ) {
 726                         RT_TRACE(COMP_FIRMWARE,"===================NULL packet==================================> tx full!\n");
 727                         skb_queue_tail(&priv->ieee80211->skb_waitQ[tcb_desc->queue_index], skb);
 728                 } else {
 729                         priv->ieee80211->softmac_hard_start_xmit(skb,dev);
 730                 }
 731
 732         //PlatformReleaseSpinLock(dev, RT_TX_SPINLOCK);
 733         return rtStatus;
 734 }
 735
 736 //-----------------------------------------------------------------------------
 737 // Procedure:    Check whether main code is download OK. If OK, turn on CPU
 738 //
 739 // Description:   CPU register locates in different page against general register.
 740 //                          Switch to CPU register in the begin and switch back before return
 741 //
 742 //
 743 // Arguments:   The pointer of the dev
 744 //
 745 // Returns:
 746 //        NDIS_STATUS_FAILURE - the following initialization process should be terminated
 747 //        NDIS_STATUS_SUCCESS - if firmware initialization process success
 748 //-----------------------------------------------------------------------------
 749 bool CPUcheck_maincodeok_turnonCPU(struct net_device *dev)
 750 {
 751         bool            rt_status = true;
 752         int             check_putcodeOK_time = 200000, check_bootOk_time = 200000;
 753         u32             CPU_status = 0;
 754
 755         /* Check whether put code OK */
 756         do {
 757                 CPU_status = read_nic_dword(dev, CPU_GEN);
 758
 759                 if(CPU_status&CPU_GEN_PUT_CODE_OK)
 760                         break;
 761
 762         }while(check_putcodeOK_time--);
 763
 764         if(!(CPU_status&CPU_GEN_PUT_CODE_OK)) {
 765                 RT_TRACE(COMP_ERR, "Download Firmware: Put code fail!\n");
 766                 goto CPUCheckMainCodeOKAndTurnOnCPU_Fail;
 767         } else {
 768                 RT_TRACE(COMP_FIRMWARE, "Download Firmware: Put code ok!\n");
 769         }
 770
 771         /* Turn On CPU */
 772         CPU_status = read_nic_dword(dev, CPU_GEN);
 773         write_nic_byte(dev, CPU_GEN, (u8)((CPU_status|CPU_GEN_PWR_STB_CPU)&0xff));
 774         mdelay(1000);
 775
 776         /* Check whether CPU boot OK */
 777         do {
 778                 CPU_status = read_nic_dword(dev, CPU_GEN);
 779
 780                 if(CPU_status&CPU_GEN_BOOT_RDY)
 781                         break;
 782         }while(check_bootOk_time--);
 783
 784         if(!(CPU_status&CPU_GEN_BOOT_RDY)) {
 785                 goto CPUCheckMainCodeOKAndTurnOnCPU_Fail;
 786         } else {
 787                 RT_TRACE(COMP_FIRMWARE, "Download Firmware: Boot ready!\n");
 788         }
 789
 790         return rt_status;
 791
 792 CPUCheckMainCodeOKAndTurnOnCPU_Fail:
 793         RT_TRACE(COMP_ERR, "ERR in %s()\n", __FUNCTION__);
 794         rt_status = FALSE;
 795         return rt_status;
 796 }
 797
 798 bool CPUcheck_firmware_ready(struct net_device *dev)
 799 {
 800
 801         bool            rt_status = true;
 802         int             check_time = 200000;
 803         u32             CPU_status = 0;
 804
 805         /* Check Firmware Ready */
 806         do {
 807                 CPU_status = read_nic_dword(dev, CPU_GEN);
 808
 809                 if(CPU_status&CPU_GEN_FIRM_RDY)
 810                         break;
 811
 812         }while(check_time--);
 813
 814         if(!(CPU_status&CPU_GEN_FIRM_RDY))
 815                 goto CPUCheckFirmwareReady_Fail;
 816         else
 817                 RT_TRACE(COMP_FIRMWARE, "Download Firmware: Firmware ready!\n");
 818
 819         return rt_status;
 820
 821 CPUCheckFirmwareReady_Fail:
 822         RT_TRACE(COMP_ERR, "ERR in %s()\n", __FUNCTION__);
 823         rt_status = false;
 824         return rt_status;
 825
 826 }
 827
 828 bool init_firmware(struct net_device *dev)
 829 {
 830         struct r8192_priv       *priv = ieee80211_priv(dev);
 831         bool                    rt_status = TRUE;
 832
 833         u8                      *firmware_img_buf[3] = { &rtl8190_fwboot_array[0],
 834                                                          &rtl8190_fwmain_array[0],
 835                                                          &rtl8190_fwdata_array[0]};
 836
 837         u32                     firmware_img_len[3] = { sizeof(rtl8190_fwboot_array),
 838                                                         sizeof(rtl8190_fwmain_array),
 839                                                         sizeof(rtl8190_fwdata_array)};
 840         u32                     file_length = 0;
 841         u8                      *mapped_file = NULL;
 842         u32                     init_step = 0;
 843         opt_rst_type_e  rst_opt = OPT_SYSTEM_RESET;
 844         firmware_init_step_e    starting_state = FW_INIT_STEP0_BOOT;
 845
 846         rt_firmware             *pfirmware = priv->pFirmware;
 847         const struct firmware   *fw_entry;
 848         const char *fw_name[3] = { "RTL8192U/boot.img",
 849                            "RTL8192U/main.img",
 850                            "RTL8192U/data.img"};
 851         int rc;
 852
 853         RT_TRACE(COMP_FIRMWARE, " PlatformInitFirmware()==>\n");
 854
 855         if (pfirmware->firmware_status == FW_STATUS_0_INIT ) {
 856                 /* it is called by reset */
 857                 rst_opt = OPT_SYSTEM_RESET;
 858                 starting_state = FW_INIT_STEP0_BOOT;
 859                 // TODO: system reset
 860
 861         }else if(pfirmware->firmware_status == FW_STATUS_5_READY) {
 862                 /* it is called by Initialize */
 863                 rst_opt = OPT_FIRMWARE_RESET;
 864                 starting_state = FW_INIT_STEP2_DATA;
 865         }else {
 866                  RT_TRACE(COMP_FIRMWARE, "PlatformInitFirmware: undefined firmware state\n");
 867         }
 868
 869         /*
 870          * Download boot, main, and data image for System reset.
 871          * Download data image for firmware reseta
 872          */
 873 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
 874         priv->firmware_source = FW_SOURCE_HEADER_FILE;
 875 #else
 876         priv->firmware_source = FW_SOURCE_IMG_FILE;
 877 #endif
 878         for(init_step = starting_state; init_step <= FW_INIT_STEP2_DATA; init_step++) {
 879                 /*
 880                  * Open Image file, and map file to contineous memory if open file success.
 881                  * or read image file from array. Default load from IMG file
 882                  */
 883                 if(rst_opt == OPT_SYSTEM_RESET) {
 884                         switch(priv->firmware_source) {
 885                                 case FW_SOURCE_IMG_FILE:
 886                                 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
 887                                         rc = request_firmware(&fw_entry, fw_name[init_step],&priv->udev->dev);
 888                                         if(rc < 0 ) {
 889                                                 RT_TRACE(COMP_ERR, "request firmware fail!\n");
 890                                                 goto download_firmware_fail;
 891                                         }
 892
 893                                         if(fw_entry->size > sizeof(pfirmware->firmware_buf)) {
 894                                                 RT_TRACE(COMP_ERR, "img file size exceed the container buffer fail!\n");
 895                                                 goto download_firmware_fail;
 896                                         }
 897
 898                                         if(init_step != FW_INIT_STEP1_MAIN) {
 899                                                 memcpy(pfirmware->firmware_buf,fw_entry->data,fw_entry->size);
 900                                                 mapped_file = pfirmware->firmware_buf;
 901                                                 file_length = fw_entry->size;
 902                                         } else {
 903                                         #ifdef RTL8190P
 904                                                 memcpy(pfirmware->firmware_buf,fw_entry->data,fw_entry->size);
 905                                                 mapped_file = pfirmware->firmware_buf;
 906                                                 file_length = fw_entry->size;
 907                                         #else
 908                                                 memset(pfirmware->firmware_buf,0,128);
 909                                                 memcpy(&pfirmware->firmware_buf[128],fw_entry->data,fw_entry->size);
 910                                                 mapped_file = pfirmware->firmware_buf;
 911                                                 file_length = fw_entry->size + 128;
 912                                         #endif
 913                                         }
 914                                         pfirmware->firmware_buf_size = file_length;
 915                                         #endif
 916                                         break;
 917
 918                                 case FW_SOURCE_HEADER_FILE:
 919                                         mapped_file =  firmware_img_buf[init_step];
 920                                         file_length  = firmware_img_len[init_step];
 921                                         if(init_step == FW_INIT_STEP2_DATA) {
 922                                                 memcpy(pfirmware->firmware_buf, mapped_file, file_length);
 923                                                 pfirmware->firmware_buf_size = file_length;
 924                                         }
 925                                         break;
 926
 927                                 default:
 928                                         break;
 929                         }
 930
 931
 932                 }else if(rst_opt == OPT_FIRMWARE_RESET ) {
 933                         /* we only need to download data.img here */
 934                         mapped_file = pfirmware->firmware_buf;
 935                         file_length = pfirmware->firmware_buf_size;
 936                 }
 937
 938                 /* Download image file */
 939                 /* The firmware download process is just as following,
 940                  * 1. that is each packet will be segmented and inserted to the wait queue.
 941                  * 2. each packet segment will be put in the skb_buff packet.
 942                  * 3. each skb_buff packet data content will already include the firmware info
 943                  *   and Tx descriptor info
 944                  * */
 945                 rt_status = fw_download_code(dev,mapped_file,file_length);
 946                 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
 947                 if(rst_opt == OPT_SYSTEM_RESET) {
 948                         release_firmware(fw_entry);
 949                 }
 950                 #endif
 951
 952                 if(rt_status != TRUE) {
 953                         goto download_firmware_fail;
 954                 }
 955
 956                 switch(init_step) {
 957                         case FW_INIT_STEP0_BOOT:
 958                                 /* Download boot
 959                                  * initialize command descriptor.
 960                                  * will set polling bit when firmware code is also configured
 961                                  */
 962                                 pfirmware->firmware_status = FW_STATUS_1_MOVE_BOOT_CODE;
 963 #ifdef RTL8190P
 964                                 // To initialize IMEM, CPU move code  from 0x80000080, hence, we send 0x80 byte packet
 965                                 rt_status = fwSendNullPacket(dev, RTL8190_CPU_START_OFFSET);
 966                                 if(rt_status != true)
 967                                 {
 968                                         RT_TRACE(COMP_INIT, "fwSendNullPacket() fail ! \n");
 969                                         goto  download_firmware_fail;
 970                                 }
 971 #endif
 972                                 //mdelay(1000);
 973                                 /*
 974                                  * To initialize IMEM, CPU move code  from 0x80000080,
 975                                  * hence, we send 0x80 byte packet
 976                                  */
 977                                 break;
 978
 979                         case FW_INIT_STEP1_MAIN:
 980                                 /* Download firmware code. Wait until Boot Ready and Turn on CPU */
 981                                 pfirmware->firmware_status = FW_STATUS_2_MOVE_MAIN_CODE;
 982
 983                                 /* Check Put Code OK and Turn On CPU */
 984                                 rt_status = CPUcheck_maincodeok_turnonCPU(dev);
 985                                 if(rt_status != TRUE) {
 986                                         RT_TRACE(COMP_ERR, "CPUcheck_maincodeok_turnonCPU fail!\n");
 987                                         goto download_firmware_fail;
 988                                 }
 989
 990                                 pfirmware->firmware_status = FW_STATUS_3_TURNON_CPU;
 991                                 break;
 992
 993                         case FW_INIT_STEP2_DATA:
 994                                 /* download initial data code */
 995                                 pfirmware->firmware_status = FW_STATUS_4_MOVE_DATA_CODE;
 996                                 mdelay(1);
 997
 998                                 rt_status = CPUcheck_firmware_ready(dev);
 999                                 if(rt_status != TRUE) {
1000                                         RT_TRACE(COMP_ERR, "CPUcheck_firmware_ready fail(%d)!\n",rt_status);
1001                                         goto download_firmware_fail;
1002                                 }
1003
1004                                 /* wait until data code is initialized ready.*/
1005                                 pfirmware->firmware_status = FW_STATUS_5_READY;
1006                                 break;
1007                 }
1008         }
1009
1010         RT_TRACE(COMP_FIRMWARE, "Firmware Download Success\n");
1011         //assert(pfirmware->firmware_status == FW_STATUS_5_READY, ("Firmware Download Fail\n"));
1012
1013         return rt_status;
1014
1015 download_firmware_fail:
1016         RT_TRACE(COMP_ERR, "ERR in %s()\n", __FUNCTION__);
1017         rt_status = FALSE;
1018         return rt_status;
1019
1020 }
1021 #endif
1022