drivers/staging/bcm/nvm.c

   1 #include "headers.h"
   2
   3 #define DWORD unsigned int
   4
   5 static int BcmDoChipSelect(struct bcm_mini_adapter *Adapter, unsigned int offset);
   6 static int BcmGetActiveDSD(struct bcm_mini_adapter *Adapter);
   7 static int BcmGetActiveISO(struct bcm_mini_adapter *Adapter);
   8 static unsigned int BcmGetEEPROMSize(struct bcm_mini_adapter *Adapter);
   9 static int BcmGetFlashCSInfo(struct bcm_mini_adapter *Adapter);
  10 static unsigned int BcmGetFlashSectorSize(struct bcm_mini_adapter *Adapter, unsigned int FlashSectorSizeSig, unsigned int FlashSectorSize);
  11
  12 static VOID BcmValidateNvmType(struct bcm_mini_adapter *Adapter);
  13 static int BcmGetNvmSize(struct bcm_mini_adapter *Adapter);
  14 static unsigned int BcmGetFlashSize(struct bcm_mini_adapter *Adapter);
  15 static enum bcm_nvm_type BcmGetNvmType(struct bcm_mini_adapter *Adapter);
  16
  17 static int BcmGetSectionValEndOffset(struct bcm_mini_adapter *Adapter, enum bcm_flash2x_section_val eFlash2xSectionVal);
  18
  19 static B_UINT8 IsOffsetWritable(struct bcm_mini_adapter *Adapter, unsigned int uiOffset);
  20 static int IsSectionWritable(struct bcm_mini_adapter *Adapter, enum bcm_flash2x_section_val Section);
  21 static int IsSectionExistInVendorInfo(struct bcm_mini_adapter *Adapter, enum bcm_flash2x_section_val section);
  22
  23 static int ReadDSDPriority(struct bcm_mini_adapter *Adapter, enum bcm_flash2x_section_val dsd);
  24 static int ReadDSDSignature(struct bcm_mini_adapter *Adapter, enum bcm_flash2x_section_val dsd);
  25 static int ReadISOPriority(struct bcm_mini_adapter *Adapter, enum bcm_flash2x_section_val iso);
  26 static int ReadISOSignature(struct bcm_mini_adapter *Adapter, enum bcm_flash2x_section_val iso);
  27
  28 static int CorruptDSDSig(struct bcm_mini_adapter *Adapter, enum bcm_flash2x_section_val eFlash2xSectionVal);
  29 static int CorruptISOSig(struct bcm_mini_adapter *Adapter, enum bcm_flash2x_section_val eFlash2xSectionVal);
  30 static int SaveHeaderIfPresent(struct bcm_mini_adapter *Adapter, PUCHAR pBuff, unsigned int uiSectAlignAddr);
  31 static int WriteToFlashWithoutSectorErase(struct bcm_mini_adapter *Adapter, PUINT pBuff,
  32                                         enum bcm_flash2x_section_val eFlash2xSectionVal,
  33                                         unsigned int uiOffset, unsigned int uiNumBytes);
  34 static enum bcm_flash2x_section_val getHighestPriDSD(struct bcm_mini_adapter *Adapter);
  35 static enum bcm_flash2x_section_val getHighestPriISO(struct bcm_mini_adapter *Adapter);
  36
  37 static int BeceemFlashBulkRead(
  38         struct bcm_mini_adapter *Adapter,
  39         PUINT pBuffer,
  40         unsigned int uiOffset,
  41         unsigned int uiNumBytes);
  42
  43 static int BeceemFlashBulkWrite(
  44         struct bcm_mini_adapter *Adapter,
  45         PUINT pBuffer,
  46         unsigned int uiOffset,
  47         unsigned int uiNumBytes,
  48         BOOLEAN bVerify);
  49
  50 static int GetFlashBaseAddr(struct bcm_mini_adapter *Adapter);
  51
  52 static int ReadBeceemEEPROMBulk(struct bcm_mini_adapter *Adapter, unsigned int dwAddress, unsigned int *pdwData, unsigned int dwNumData);
  53
  54 /* Procedure:   ReadEEPROMStatusRegister
  55  *
  56  * Description: Reads the standard EEPROM Status Register.
  57  *
  58  * Arguments:
  59  *              Adapter    - ptr to Adapter object instance
  60  * Returns:
  61  *              OSAL_STATUS_CODE
  62  */
  63 static UCHAR ReadEEPROMStatusRegister(struct bcm_mini_adapter *Adapter)
  64 {
  65         UCHAR uiData = 0;
  66         DWORD dwRetries = MAX_EEPROM_RETRIES * RETRIES_PER_DELAY;
  67         unsigned int uiStatus = 0;
  68         unsigned int value = 0;
  69         unsigned int value1 = 0;
  70
  71         /* Read the EEPROM status register */
  72         value = EEPROM_READ_STATUS_REGISTER;
  73         wrmalt(Adapter, EEPROM_CMDQ_SPI_REG, &value, sizeof(value));
  74
  75         while (dwRetries != 0) {
  76                 value = 0;
  77                 uiStatus = 0;
  78                 rdmalt(Adapter, EEPROM_SPI_Q_STATUS1_REG, &uiStatus, sizeof(uiStatus));
  79                 if (Adapter->device_removed == TRUE) {
  80                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Modem has got removed hence exiting....");
  81                         break;
  82                 }
  83
  84                 /* Wait for Avail bit to be set. */
  85                 if ((uiStatus & EEPROM_READ_DATA_AVAIL) != 0) {
  86                         /* Clear the Avail/Full bits - which ever is set. */
  87                         value = uiStatus & (EEPROM_READ_DATA_AVAIL | EEPROM_READ_DATA_FULL);
  88                         wrmalt(Adapter, EEPROM_SPI_Q_STATUS1_REG, &value, sizeof(value));
  89
  90                         value = 0;
  91                         rdmalt(Adapter, EEPROM_READ_DATAQ_REG, &value, sizeof(value));
  92                         uiData = (UCHAR)value;
  93
  94                         break;
  95                 }
  96
  97                 dwRetries--;
  98                 if (dwRetries == 0) {
  99                         rdmalt(Adapter, EEPROM_SPI_Q_STATUS1_REG, &value, sizeof(value));
 100                         rdmalt(Adapter, EEPROM_SPI_Q_STATUS_REG, &value1, sizeof(value1));
 101                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "0x3004 = %x 0x3008 = %x, retries = %d failed.\n", value, value1, MAX_EEPROM_RETRIES * RETRIES_PER_DELAY);
 102                         return uiData;
 103                 }
 104                 if (!(dwRetries%RETRIES_PER_DELAY))
 105                         udelay(1000);
 106                 uiStatus = 0 ;
 107         }
 108         return uiData;
 109 } /* ReadEEPROMStatusRegister */
 110
 111 /*
 112  * Procedure:   ReadBeceemEEPROMBulk
 113  *
 114  * Description: This routine reads 16Byte data from EEPROM
 115  *
 116  * Arguments:
 117  *              Adapter    - ptr to Adapter object instance
 118  *      dwAddress   - EEPROM Offset to read the data from.
 119  *      pdwData     - Pointer to double word where data needs to be stored in.  //              dwNumWords  - Number of words.  Valid values are 4 ONLY.
 120  *
 121  * Returns:
 122  *              OSAL_STATUS_CODE:
 123  */
 124
 125 int ReadBeceemEEPROMBulk(struct bcm_mini_adapter *Adapter,
 126                         DWORD dwAddress,
 127                         DWORD *pdwData,
 128                         DWORD dwNumWords)
 129 {
 130         DWORD dwIndex = 0;
 131         DWORD dwRetries = MAX_EEPROM_RETRIES * RETRIES_PER_DELAY;
 132         unsigned int uiStatus  = 0;
 133         unsigned int value = 0;
 134         unsigned int value1 = 0;
 135         UCHAR *pvalue;
 136
 137         /* Flush the read and cmd queue. */
 138         value = (EEPROM_READ_QUEUE_FLUSH | EEPROM_CMD_QUEUE_FLUSH);
 139         wrmalt(Adapter, SPI_FLUSH_REG, &value, sizeof(value));
 140         value = 0;
 141         wrmalt(Adapter, SPI_FLUSH_REG, &value, sizeof(value));
 142
 143         /* Clear the Avail/Full bits. */
 144         value = (EEPROM_READ_DATA_AVAIL | EEPROM_READ_DATA_FULL);
 145         wrmalt(Adapter, EEPROM_SPI_Q_STATUS1_REG, &value, sizeof(value));
 146
 147         value = dwAddress | ((dwNumWords == 4) ? EEPROM_16_BYTE_PAGE_READ : EEPROM_4_BYTE_PAGE_READ);
 148         wrmalt(Adapter, EEPROM_CMDQ_SPI_REG, &value, sizeof(value));
 149
 150         while (dwRetries != 0) {
 151                 uiStatus = 0;
 152                 rdmalt(Adapter, EEPROM_SPI_Q_STATUS1_REG, &uiStatus, sizeof(uiStatus));
 153                 if (Adapter->device_removed == TRUE) {
 154                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Modem has got Removed.hence exiting from loop...");
 155                         return -ENODEV;
 156                 }
 157
 158                 /* If we are reading 16 bytes we want to be sure that the queue
 159                  * is full before we read.  In the other cases we are ok if the
 160                  * queue has data available
 161                  */
 162                 if (dwNumWords == 4) {
 163                         if ((uiStatus & EEPROM_READ_DATA_FULL) != 0) {
 164                                 /* Clear the Avail/Full bits - which ever is set. */
 165                                 value = (uiStatus & (EEPROM_READ_DATA_AVAIL | EEPROM_READ_DATA_FULL));
 166                                 wrmalt(Adapter, EEPROM_SPI_Q_STATUS1_REG, &value, sizeof(value));
 167                                 break;
 168                         }
 169                 } else if (dwNumWords == 1) {
 170                         if ((uiStatus & EEPROM_READ_DATA_AVAIL) != 0) {
 171                                 /* We just got Avail and we have to read 32bits so we
 172                                  * need this sleep for Cardbus kind of devices.
 173                                  */
 174                                 if (Adapter->chip_id == 0xBECE0210)
 175                                         udelay(800);
 176
 177                                 /* Clear the Avail/Full bits - which ever is set. */
 178                                 value = (uiStatus & (EEPROM_READ_DATA_AVAIL | EEPROM_READ_DATA_FULL));
 179                                 wrmalt(Adapter, EEPROM_SPI_Q_STATUS1_REG, &value, sizeof(value));
 180                                 break;
 181                         }
 182                 }
 183
 184                 uiStatus = 0;
 185
 186                 dwRetries--;
 187                 if (dwRetries == 0) {
 188                         value = 0;
 189                         value1 = 0;
 190                         rdmalt(Adapter, EEPROM_SPI_Q_STATUS1_REG, &value, sizeof(value));
 191                         rdmalt(Adapter, EEPROM_SPI_Q_STATUS_REG, &value1, sizeof(value1));
 192                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "dwNumWords %d 0x3004 = %x 0x3008 = %x  retries = %d failed.\n",
 193                                         dwNumWords, value,  value1,  MAX_EEPROM_RETRIES * RETRIES_PER_DELAY);
 194                         return STATUS_FAILURE;
 195                 }
 196
 197                 if (!(dwRetries%RETRIES_PER_DELAY))
 198                         udelay(1000);
 199         }
 200
 201         for (dwIndex = 0; dwIndex < dwNumWords; dwIndex++) {
 202                 /* We get only a byte at a time - from LSB to MSB. We shift it into an integer. */
 203                 pvalue = (PUCHAR)(pdwData + dwIndex);
 204
 205                 value = 0;
 206                 rdmalt(Adapter, EEPROM_READ_DATAQ_REG, &value, sizeof(value));
 207
 208                 pvalue[0] = value;
 209
 210                 value = 0;
 211                 rdmalt(Adapter, EEPROM_READ_DATAQ_REG, &value, sizeof(value));
 212
 213                 pvalue[1] = value;
 214
 215                 value = 0;
 216                 rdmalt(Adapter, EEPROM_READ_DATAQ_REG, &value, sizeof(value));
 217
 218                 pvalue[2] = value;
 219
 220                 value = 0;
 221                 rdmalt(Adapter, EEPROM_READ_DATAQ_REG, &value, sizeof(value));
 222
 223                 pvalue[3] = value;
 224         }
 225
 226         return STATUS_SUCCESS;
 227 } /* ReadBeceemEEPROMBulk() */
 228
 229 /*
 230  * Procedure:   ReadBeceemEEPROM
 231  *
 232  * Description: This routine reads 4 data from EEPROM.  It uses 1 or 2 page
 233  *                              reads to do this operation.
 234  *
 235  * Arguments:
 236  *              Adapter     - ptr to Adapter object instance
 237  *      uiOffset        - EEPROM Offset to read the data from.
 238  *      pBuffer         - Pointer to word where data needs to be stored in.
 239  *
 240  * Returns:
 241  *              OSAL_STATUS_CODE:
 242  */
 243
 244 int ReadBeceemEEPROM(struct bcm_mini_adapter *Adapter,
 245                 DWORD uiOffset,
 246                 DWORD *pBuffer)
 247 {
 248         unsigned int uiData[8]          = {0};
 249         unsigned int uiByteOffset       = 0;
 250         unsigned int uiTempOffset       = 0;
 251
 252         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, " ====> ");
 253
 254         uiTempOffset = uiOffset - (uiOffset % MAX_RW_SIZE);
 255         uiByteOffset = uiOffset - uiTempOffset;
 256
 257         ReadBeceemEEPROMBulk(Adapter, uiTempOffset, (PUINT)&uiData[0], 4);
 258
 259         /* A word can overlap at most over 2 pages. In that case we read the
 260          * next page too.
 261          */
 262         if (uiByteOffset > 12)
 263                 ReadBeceemEEPROMBulk(Adapter, uiTempOffset + MAX_RW_SIZE, (PUINT)&uiData[4], 4);
 264
 265         memcpy((PUCHAR)pBuffer, (((PUCHAR)&uiData[0]) + uiByteOffset), 4);
 266
 267         return STATUS_SUCCESS;
 268 } /* ReadBeceemEEPROM() */
 269
 270 int ReadMacAddressFromNVM(struct bcm_mini_adapter *Adapter)
 271 {
 272         int Status;
 273         unsigned char puMacAddr[6];
 274
 275         Status = BeceemNVMRead(Adapter,
 276                         (PUINT)&puMacAddr[0],
 277                         INIT_PARAMS_1_MACADDRESS_ADDRESS,
 278                         MAC_ADDRESS_SIZE);
 279
 280         if (Status == STATUS_SUCCESS)
 281                 memcpy(Adapter->dev->dev_addr, puMacAddr, MAC_ADDRESS_SIZE);
 282
 283         return Status;
 284 }
 285
 286 /*
 287  * Procedure:   BeceemEEPROMBulkRead
 288  *
 289  * Description: Reads the EEPROM and returns the Data.
 290  *
 291  * Arguments:
 292  *              Adapter    - ptr to Adapter object instance
 293  *              pBuffer    - Buffer to store the data read from EEPROM
 294  *              uiOffset   - Offset of EEPROM from where data should be read
 295  *              uiNumBytes - Number of bytes to be read from the EEPROM.
 296  *
 297  * Returns:
 298  *              OSAL_STATUS_SUCCESS - if EEPROM read is successful.
 299  *              <FAILURE>                       - if failed.
 300  */
 301
 302 int BeceemEEPROMBulkRead(struct bcm_mini_adapter *Adapter,
 303                         PUINT pBuffer,
 304                         unsigned int uiOffset,
 305                         unsigned int uiNumBytes)
 306 {
 307         unsigned int uiData[4]          = {0};
 308         /* unsigned int uiAddress       = 0; */
 309         unsigned int uiBytesRemaining   = uiNumBytes;
 310         unsigned int uiIndex            = 0;
 311         unsigned int uiTempOffset       = 0;
 312         unsigned int uiExtraBytes       = 0;
 313         unsigned int uiFailureRetries   = 0;
 314         PUCHAR pcBuff = (PUCHAR)pBuffer;
 315
 316         if (uiOffset % MAX_RW_SIZE && uiBytesRemaining) {
 317                 uiTempOffset = uiOffset - (uiOffset % MAX_RW_SIZE);
 318                 uiExtraBytes = uiOffset - uiTempOffset;
 319                 ReadBeceemEEPROMBulk(Adapter, uiTempOffset, (PUINT)&uiData[0], 4);
 320                 if (uiBytesRemaining >= (MAX_RW_SIZE - uiExtraBytes)) {
 321                         memcpy(pBuffer, (((PUCHAR)&uiData[0]) + uiExtraBytes), MAX_RW_SIZE - uiExtraBytes);
 322                         uiBytesRemaining -= (MAX_RW_SIZE - uiExtraBytes);
 323                         uiIndex += (MAX_RW_SIZE - uiExtraBytes);
 324                         uiOffset += (MAX_RW_SIZE - uiExtraBytes);
 325                 } else {
 326                         memcpy(pBuffer, (((PUCHAR)&uiData[0]) + uiExtraBytes), uiBytesRemaining);
 327                         uiIndex += uiBytesRemaining;
 328                         uiOffset += uiBytesRemaining;
 329                         uiBytesRemaining = 0;
 330                 }
 331         }
 332
 333         while (uiBytesRemaining && uiFailureRetries != 128) {
 334                 if (Adapter->device_removed)
 335                         return -1;
 336
 337                 if (uiBytesRemaining >= MAX_RW_SIZE) {
 338                         /* For the requests more than or equal to 16 bytes, use bulk
 339                          * read function to make the access faster.
 340                          * We read 4 Dwords of data
 341                          */
 342                         if (ReadBeceemEEPROMBulk(Adapter, uiOffset, &uiData[0], 4) == 0) {
 343                                 memcpy(pcBuff + uiIndex, &uiData[0], MAX_RW_SIZE);
 344                                 uiOffset += MAX_RW_SIZE;
 345                                 uiBytesRemaining -= MAX_RW_SIZE;
 346                                 uiIndex += MAX_RW_SIZE;
 347                         } else {
 348                                 uiFailureRetries++;
 349                                 mdelay(3); /* sleep for a while before retry... */
 350                         }
 351                 } else if (uiBytesRemaining >= 4) {
 352                         if (ReadBeceemEEPROM(Adapter, uiOffset, &uiData[0]) == 0) {
 353                                 memcpy(pcBuff + uiIndex, &uiData[0], 4);
 354                                 uiOffset += 4;
 355                                 uiBytesRemaining -= 4;
 356                                 uiIndex += 4;
 357                         } else {
 358                                 uiFailureRetries++;
 359                                 mdelay(3); /* sleep for a while before retry... */
 360                         }
 361                 } else {
 362                         /* Handle the reads less than 4 bytes... */
 363                         PUCHAR pCharBuff = (PUCHAR)pBuffer;
 364                         pCharBuff += uiIndex;
 365                         if (ReadBeceemEEPROM(Adapter, uiOffset, &uiData[0]) == 0) {
 366                                 memcpy(pCharBuff, &uiData[0], uiBytesRemaining); /* copy only bytes requested. */
 367                                 uiBytesRemaining = 0;
 368                         } else {
 369                                 uiFailureRetries++;
 370                                 mdelay(3); /* sleep for a while before retry... */
 371                         }
 372                 }
 373         }
 374
 375         return 0;
 376 }
 377
 378 /*
 379  * Procedure:   BeceemFlashBulkRead
 380  *
 381  * Description: Reads the FLASH and returns the Data.
 382  *
 383  * Arguments:
 384  *              Adapter    - ptr to Adapter object instance
 385  *              pBuffer    - Buffer to store the data read from FLASH
 386  *              uiOffset   - Offset of FLASH from where data should be read
 387  *              uiNumBytes - Number of bytes to be read from the FLASH.
 388  *
 389  * Returns:
 390  *              OSAL_STATUS_SUCCESS - if FLASH read is successful.
 391  *              <FAILURE>                       - if failed.
 392  */
 393
 394 static int BeceemFlashBulkRead(struct bcm_mini_adapter *Adapter,
 395                         PUINT pBuffer,
 396                         unsigned int uiOffset,
 397                         unsigned int uiNumBytes)
 398 {
 399         unsigned int uiIndex = 0;
 400         unsigned int uiBytesToRead = uiNumBytes;
 401         int Status = 0;
 402         unsigned int uiPartOffset = 0;
 403         int bytes;
 404
 405         if (Adapter->device_removed) {
 406                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Device Got Removed");
 407                 return -ENODEV;
 408         }
 409
 410         /* Adding flash Base address
 411          * uiOffset = uiOffset + GetFlashBaseAddr(Adapter);
 412          */
 413         #if defined(BCM_SHM_INTERFACE) && !defined(FLASH_DIRECT_ACCESS)
 414                 Status = bcmflash_raw_read((uiOffset/FLASH_PART_SIZE), (uiOffset % FLASH_PART_SIZE), (unsigned char *)pBuffer, uiNumBytes);
 415                 return Status;
 416         #endif
 417
 418         Adapter->SelectedChip = RESET_CHIP_SELECT;
 419
 420         if (uiOffset % MAX_RW_SIZE) {
 421                 BcmDoChipSelect(Adapter, uiOffset);
 422                 uiPartOffset = (uiOffset & (FLASH_PART_SIZE - 1)) + GetFlashBaseAddr(Adapter);
 423
 424                 uiBytesToRead = MAX_RW_SIZE - (uiOffset % MAX_RW_SIZE);
 425                 uiBytesToRead = MIN(uiNumBytes, uiBytesToRead);
 426
 427                 bytes = rdm(Adapter, uiPartOffset, (PCHAR)pBuffer + uiIndex, uiBytesToRead);
 428                 if (bytes < 0) {
 429                         Status = bytes;
 430                         Adapter->SelectedChip = RESET_CHIP_SELECT;
 431                         return Status;
 432                 }
 433
 434                 uiIndex += uiBytesToRead;
 435                 uiOffset += uiBytesToRead;
 436                 uiNumBytes -= uiBytesToRead;
 437         }
 438
 439         while (uiNumBytes) {
 440                 BcmDoChipSelect(Adapter, uiOffset);
 441                 uiPartOffset = (uiOffset & (FLASH_PART_SIZE - 1)) + GetFlashBaseAddr(Adapter);
 442
 443                 uiBytesToRead = MIN(uiNumBytes, MAX_RW_SIZE);
 444
 445                 bytes = rdm(Adapter, uiPartOffset, (PCHAR)pBuffer + uiIndex, uiBytesToRead);
 446                 if (bytes < 0) {
 447                         Status = bytes;
 448                         break;
 449                 }
 450
 451                 uiIndex += uiBytesToRead;
 452                 uiOffset += uiBytesToRead;
 453                 uiNumBytes -= uiBytesToRead;
 454         }
 455         Adapter->SelectedChip = RESET_CHIP_SELECT;
 456         return Status;
 457 }
 458
 459 /*
 460  * Procedure:   BcmGetFlashSize
 461  *
 462  * Description: Finds the size of FLASH.
 463  *
 464  * Arguments:
 465  *              Adapter    - ptr to Adapter object instance
 466  *
 467  * Returns:
 468  *              unsigned int - size of the FLASH Storage.
 469  *
 470  */
 471
 472 static unsigned int BcmGetFlashSize(struct bcm_mini_adapter *Adapter)
 473 {
 474         if (IsFlash2x(Adapter))
 475                 return Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader + sizeof(struct bcm_dsd_header);
 476         else
 477                 return 32 * 1024;
 478 }
 479
 480 /*
 481  * Procedure:   BcmGetEEPROMSize
 482  *
 483  * Description: Finds the size of EEPROM.
 484  *
 485  * Arguments:
 486  *              Adapter    - ptr to Adapter object instance
 487  *
 488  * Returns:
 489  *              unsigned int - size of the EEPROM Storage.
 490  *
 491  */
 492
 493 static unsigned int BcmGetEEPROMSize(struct bcm_mini_adapter *Adapter)
 494 {
 495         unsigned int uiData = 0;
 496         unsigned int uiIndex = 0;
 497
 498         /*
 499          * if EEPROM is present and already Calibrated,it will have
 500          * 'BECM' string at 0th offset.
 501          * To find the EEPROM size read the possible boundaries of the
 502          * EEPROM like 4K,8K etc..accessing the EEPROM beyond its size will
 503          * result in wrap around. So when we get the End of the EEPROM we will
 504          * get 'BECM' string which is indeed at offset 0.
 505          */
 506         BeceemEEPROMBulkRead(Adapter, &uiData, 0x0, 4);
 507         if (uiData == BECM) {
 508                 for (uiIndex = 2; uiIndex <= 256; uiIndex *= 2) {
 509                         BeceemEEPROMBulkRead(Adapter, &uiData, uiIndex * 1024, 4);
 510                         if (uiData == BECM)
 511                                 return uiIndex * 1024;
 512                 }
 513         } else {
 514                 /*
 515                  * EEPROM may not be present or not programmed
 516                  */
 517                 uiData = 0xBABEFACE;
 518                 if (BeceemEEPROMBulkWrite(Adapter, (PUCHAR)&uiData, 0, 4, TRUE) == 0) {
 519                         uiData = 0;
 520                         for (uiIndex = 2; uiIndex <= 256; uiIndex *= 2) {
 521                                 BeceemEEPROMBulkRead(Adapter, &uiData, uiIndex * 1024, 4);
 522                                 if (uiData == 0xBABEFACE)
 523                                         return uiIndex * 1024;
 524                         }
 525                 }
 526         }
 527         return 0;
 528 }
 529
 530 /*
 531  * Procedure:   FlashSectorErase
 532  *
 533  * Description: Finds the sector size of the FLASH.
 534  *
 535  * Arguments:
 536  *              Adapter    - ptr to Adapter object instance
 537  *              addr       - sector start address
 538  *              numOfSectors - number of sectors to  be erased.
 539  *
 540  * Returns:
 541  *              OSAL_STATUS_CODE
 542  *
 543  */
 544
 545 static int FlashSectorErase(struct bcm_mini_adapter *Adapter,
 546                         unsigned int addr,
 547                         unsigned int numOfSectors)
 548 {
 549         unsigned int iIndex = 0, iRetries = 0;
 550         unsigned int uiStatus = 0;
 551         unsigned int value;
 552         int bytes;
 553
 554         for (iIndex = 0; iIndex < numOfSectors; iIndex++) {
 555                 value = 0x06000000;
 556                 wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value));
 557
 558                 value = (0xd8000000 | (addr & 0xFFFFFF));
 559                 wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value));
 560                 iRetries = 0;
 561
 562                 do {
 563                         value = (FLASH_CMD_STATUS_REG_READ << 24);
 564                         if (wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value)) < 0) {
 565                                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Programing of FLASH_SPI_CMDQ_REG fails");
 566                                 return STATUS_FAILURE;
 567                         }
 568
 569                         bytes = rdmalt(Adapter, FLASH_SPI_READQ_REG, &uiStatus, sizeof(uiStatus));
 570                         if (bytes < 0) {
 571                                 uiStatus = bytes;
 572                                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Reading status of FLASH_SPI_READQ_REG fails");
 573                                 return uiStatus;
 574                         }
 575                         iRetries++;
 576                         /* After every try lets make the CPU free for 10 ms. generally time taken by the
 577                          * the sector erase cycle is 500 ms to 40000 msec. hence sleeping 10 ms
 578                          * won't hamper performance in any case.
 579                          */
 580                         mdelay(10);
 581                 } while ((uiStatus & 0x1) && (iRetries < 400));
 582
 583                 if (uiStatus & 0x1) {
 584                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "iRetries crossing the limit of 80000\n");
 585                         return STATUS_FAILURE;
 586                 }
 587
 588                 addr += Adapter->uiSectorSize;
 589         }
 590         return 0;
 591 }
 592 /*
 593  * Procedure:   flashByteWrite
 594  *
 595  * Description: Performs Byte by Byte write to flash
 596  *
 597  * Arguments:
 598  *              Adapter   - ptr to Adapter object instance
 599  *              uiOffset   - Offset of the flash where data needs to be written to.
 600  *              pData   - Address of Data to be written.
 601  * Returns:
 602  *              OSAL_STATUS_CODE
 603  *
 604  */
 605
 606 static int flashByteWrite(struct bcm_mini_adapter *Adapter,
 607                         unsigned int uiOffset,
 608                         PVOID pData)
 609 {
 610         unsigned int uiStatus = 0;
 611         int  iRetries = MAX_FLASH_RETRIES * FLASH_PER_RETRIES_DELAY; /* 3 */
 612         unsigned int value;
 613         ULONG ulData = *(PUCHAR)pData;
 614         int bytes;
 615         /*
 616          * need not write 0xFF because write requires an erase and erase will
 617          * make whole sector 0xFF.
 618          */
 619
 620         if (0xFF == ulData)
 621                 return STATUS_SUCCESS;
 622
 623         /* DumpDebug(NVM_RW,("flashWrite ====>\n")); */
 624         value = (FLASH_CMD_WRITE_ENABLE << 24);
 625         if (wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value)) < 0) {
 626                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Write enable in FLASH_SPI_CMDQ_REG register fails");
 627                 return STATUS_FAILURE;
 628         }
 629
 630         if (wrm(Adapter, FLASH_SPI_WRITEQ_REG, (PCHAR)&ulData, 4) < 0) {
 631                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "DATA Write on FLASH_SPI_WRITEQ_REG fails");
 632                 return STATUS_FAILURE;
 633         }
 634         value = (0x02000000 | (uiOffset & 0xFFFFFF));
 635         if (wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value)) < 0) {
 636                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Programming of FLASH_SPI_CMDQ_REG fails");
 637                 return STATUS_FAILURE;
 638         }
 639
 640         /* __udelay(950); */
 641
 642         do {
 643                 value = (FLASH_CMD_STATUS_REG_READ << 24);
 644                 if (wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value)) < 0) {
 645                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Programing of FLASH_SPI_CMDQ_REG fails");
 646                         return STATUS_FAILURE;
 647                 }
 648                 /* __udelay(1); */
 649                 bytes = rdmalt(Adapter, FLASH_SPI_READQ_REG, &uiStatus, sizeof(uiStatus));
 650                 if (bytes < 0) {
 651                         uiStatus = bytes;
 652                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Reading status of FLASH_SPI_READQ_REG fails");
 653                         return uiStatus;
 654                 }
 655                 iRetries--;
 656                 if (iRetries && ((iRetries % FLASH_PER_RETRIES_DELAY) == 0))
 657                         udelay(1000);
 658
 659         } while ((uiStatus & 0x1) && (iRetries  > 0));
 660
 661         if (uiStatus & 0x1) {
 662                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Flash Write fails even after checking status for 200 times.");
 663                 return STATUS_FAILURE;
 664         }
 665
 666         return STATUS_SUCCESS;
 667 }
 668
 669 /*
 670  * Procedure:   flashWrite
 671  *
 672  * Description: Performs write to flash
 673  *
 674  * Arguments:
 675  *              Adapter    - ptr to Adapter object instance
 676  *              uiOffset   - Offset of the flash where data needs to be written to.
 677  *              pData   - Address of Data to be written.
 678  * Returns:
 679  *              OSAL_STATUS_CODE
 680  *
 681  */
 682
 683 static int flashWrite(struct bcm_mini_adapter *Adapter,
 684                 unsigned int uiOffset,
 685                 PVOID pData)
 686 {
 687         /* unsigned int uiStatus = 0;
 688          * int  iRetries = 0;
 689          * unsigned int uiReadBack = 0;
 690          */
 691         unsigned int uiStatus = 0;
 692         int  iRetries = MAX_FLASH_RETRIES * FLASH_PER_RETRIES_DELAY; /* 3 */
 693         unsigned int value;
 694         unsigned int uiErasePattern[4] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
 695         int bytes;
 696         /*
 697          * need not write 0xFFFFFFFF because write requires an erase and erase will
 698          * make whole sector 0xFFFFFFFF.
 699          */
 700         if (!memcmp(pData, uiErasePattern, MAX_RW_SIZE))
 701                 return 0;
 702
 703         value = (FLASH_CMD_WRITE_ENABLE << 24);
 704
 705         if (wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value)) < 0) {
 706                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Write Enable of FLASH_SPI_CMDQ_REG fails");
 707                 return STATUS_FAILURE;
 708         }
 709
 710         if (wrm(Adapter, uiOffset, (PCHAR)pData, MAX_RW_SIZE) < 0) {
 711                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Data write fails...");
 712                 return STATUS_FAILURE;
 713         }
 714
 715         /* __udelay(950); */
 716         do {
 717                 value = (FLASH_CMD_STATUS_REG_READ << 24);
 718                 if (wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value)) < 0) {
 719                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Programing of FLASH_SPI_CMDQ_REG fails");
 720                         return STATUS_FAILURE;
 721                 }
 722                 /* __udelay(1); */
 723                 bytes = rdmalt(Adapter, FLASH_SPI_READQ_REG, &uiStatus, sizeof(uiStatus));
 724                 if (bytes < 0) {
 725                         uiStatus = bytes;
 726                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Reading status of FLASH_SPI_READQ_REG fails");
 727                         return uiStatus;
 728                 }
 729
 730                 iRetries--;
 731                 /* this will ensure that in there will be no changes in the current path.
 732                  * currently one rdm/wrm takes 125 us.
 733                  * Hence  125 *2 * FLASH_PER_RETRIES_DELAY > 3 ms(worst case delay)
 734                  * Hence current implementation cycle will intoduce no delay in current path
 735                  */
 736                 if (iRetries && ((iRetries % FLASH_PER_RETRIES_DELAY) == 0))
 737                         udelay(1000);
 738         } while ((uiStatus & 0x1) && (iRetries > 0));
 739
 740         if (uiStatus & 0x1) {
 741                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Flash Write fails even after checking status for 200 times.");
 742                 return STATUS_FAILURE;
 743         }
 744
 745         return STATUS_SUCCESS;
 746 }
 747
 748 /*-----------------------------------------------------------------------------
 749  * Procedure:   flashByteWriteStatus
 750  *
 751  * Description: Performs byte by byte write to flash with write done status check
 752  *
 753  * Arguments:
 754  *              Adapter    - ptr to Adapter object instance
 755  *              uiOffset    - Offset of the flash where data needs to be written to.
 756  *              pData    - Address of the Data to be written.
 757  * Returns:
 758  *              OSAL_STATUS_CODE
 759  *
 760  */
 761 static int flashByteWriteStatus(struct bcm_mini_adapter *Adapter,
 762                                 unsigned int uiOffset,
 763                                 PVOID pData)
 764 {
 765         unsigned int uiStatus = 0;
 766         int  iRetries = MAX_FLASH_RETRIES * FLASH_PER_RETRIES_DELAY; /* 3 */
 767         ULONG ulData  = *(PUCHAR)pData;
 768         unsigned int value;
 769         int bytes;
 770
 771         /*
 772          * need not write 0xFFFFFFFF because write requires an erase and erase will
 773          * make whole sector 0xFFFFFFFF.
 774          */
 775
 776         if (0xFF == ulData)
 777                 return STATUS_SUCCESS;
 778
 779         /* DumpDebug(NVM_RW,("flashWrite ====>\n")); */
 780
 781         value = (FLASH_CMD_WRITE_ENABLE << 24);
 782         if (wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value)) < 0) {
 783                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Write enable in FLASH_SPI_CMDQ_REG register fails");
 784                 return STATUS_SUCCESS;
 785         }
 786         if (wrm(Adapter, FLASH_SPI_WRITEQ_REG, (PCHAR)&ulData, 4) < 0) {
 787                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "DATA Write on FLASH_SPI_WRITEQ_REG fails");
 788                 return STATUS_FAILURE;
 789         }
 790         value = (0x02000000 | (uiOffset & 0xFFFFFF));
 791         if (wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value)) < 0) {
 792                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Programming of FLASH_SPI_CMDQ_REG fails");
 793                 return STATUS_FAILURE;
 794         }
 795
 796         /* msleep(1); */
 797
 798         do {
 799                 value = (FLASH_CMD_STATUS_REG_READ << 24);
 800                 if (wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value)) < 0) {
 801                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Programing of FLASH_SPI_CMDQ_REG fails");
 802                         return STATUS_FAILURE;
 803                 }
 804                 /* __udelay(1); */
 805                 bytes = rdmalt(Adapter, FLASH_SPI_READQ_REG, &uiStatus, sizeof(uiStatus));
 806                 if (bytes < 0) {
 807                         uiStatus = bytes;
 808                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Reading status of FLASH_SPI_READQ_REG fails");
 809                         return uiStatus;
 810                 }
 811
 812                 iRetries--;
 813                 if (iRetries && ((iRetries % FLASH_PER_RETRIES_DELAY) == 0))
 814                         udelay(1000);
 815
 816         } while ((uiStatus & 0x1) && (iRetries > 0));
 817
 818         if (uiStatus & 0x1) {
 819                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Flash Write fails even after checking status for 200 times.");
 820                 return STATUS_FAILURE;
 821         }
 822
 823         return STATUS_SUCCESS;
 824 }
 825 /*
 826  * Procedure:   flashWriteStatus
 827  *
 828  * Description: Performs write to flash with write done status check
 829  *
 830  * Arguments:
 831  *              Adapter    - ptr to Adapter object instance
 832  *              uiOffset    - Offset of the flash where data needs to be written to.
 833  *              pData    - Address of the Data to be written.
 834  * Returns:
 835  *              OSAL_STATUS_CODE
 836  *
 837  */
 838
 839 static int flashWriteStatus(struct bcm_mini_adapter *Adapter,
 840                         unsigned int uiOffset,
 841                         PVOID pData)
 842 {
 843         unsigned int uiStatus = 0;
 844         int  iRetries = MAX_FLASH_RETRIES * FLASH_PER_RETRIES_DELAY; /* 3 */
 845         /* unsigned int uiReadBack = 0; */
 846         unsigned int value;
 847         unsigned int uiErasePattern[4] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
 848         int bytes;
 849
 850         /*
 851          * need not write 0xFFFFFFFF because write requires an erase and erase will
 852          * make whole sector 0xFFFFFFFF.
 853          */
 854         if (!memcmp(pData, uiErasePattern, MAX_RW_SIZE))
 855                 return 0;
 856
 857         value = (FLASH_CMD_WRITE_ENABLE << 24);
 858         if (wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value)) < 0) {
 859                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Write Enable of FLASH_SPI_CMDQ_REG fails");
 860                 return STATUS_FAILURE;
 861         }
 862
 863         if (wrm(Adapter, uiOffset, (PCHAR)pData, MAX_RW_SIZE) < 0) {
 864                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Data write fails...");
 865                 return STATUS_FAILURE;
 866         }
 867         /* __udelay(1); */
 868
 869         do {
 870                 value = (FLASH_CMD_STATUS_REG_READ << 24);
 871                 if (wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value)) < 0) {
 872                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Programing of FLASH_SPI_CMDQ_REG fails");
 873                         return STATUS_FAILURE;
 874                 }
 875                 /* __udelay(1); */
 876                 bytes = rdmalt(Adapter, FLASH_SPI_READQ_REG, &uiStatus, sizeof(uiStatus));
 877                 if (bytes < 0) {
 878                         uiStatus = bytes;
 879                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Reading status of FLASH_SPI_READQ_REG fails");
 880                         return uiStatus;
 881                 }
 882                 iRetries--;
 883                 /* this will ensure that in there will be no changes in the current path.
 884                  * currently one rdm/wrm takes 125 us.
 885                  * Hence  125 *2  * FLASH_PER_RETRIES_DELAY  >3 ms(worst case delay)
 886                  * Hence current implementation cycle will intoduce no delay in current path
 887                  */
 888                 if (iRetries && ((iRetries % FLASH_PER_RETRIES_DELAY) == 0))
 889                         udelay(1000);
 890
 891         } while ((uiStatus & 0x1) && (iRetries > 0));
 892
 893         if (uiStatus & 0x1) {
 894                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Flash Write fails even after checking status for 200 times.");
 895                 return STATUS_FAILURE;
 896         }
 897
 898         return STATUS_SUCCESS;
 899 }
 900
 901 /*
 902  * Procedure:   BcmRestoreBlockProtectStatus
 903  *
 904  * Description: Restores the original block protection status.
 905  *
 906  * Arguments:
 907  *              Adapter    - ptr to Adapter object instance
 908  *              ulWriteStatus   -Original status
 909  * Returns:
 910  *              <VOID>
 911  *
 912  */
 913
 914 static VOID BcmRestoreBlockProtectStatus(struct bcm_mini_adapter *Adapter, ULONG ulWriteStatus)
 915 {
 916         unsigned int value;
 917         value = (FLASH_CMD_WRITE_ENABLE << 24);
 918         wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value));
 919
 920         udelay(20);
 921         value = (FLASH_CMD_STATUS_REG_WRITE << 24) | (ulWriteStatus << 16);
 922         wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value));
 923         udelay(20);
 924 }
 925
 926 /*
 927  * Procedure:   BcmFlashUnProtectBlock
 928  *
 929  * Description: UnProtects appropriate blocks for writing.
 930  *
 931  * Arguments:
 932  *              Adapter    - ptr to Adapter object instance
 933  *              uiOffset   - Offset of the flash where data needs to be written to. This should be Sector aligned.
 934  * Returns:
 935  *              ULONG   - Status value before UnProtect.
 936  *
 937  */
 938
 939 static ULONG BcmFlashUnProtectBlock(struct bcm_mini_adapter *Adapter, unsigned int uiOffset, unsigned int uiLength)
 940 {
 941         ULONG ulStatus          = 0;
 942         ULONG ulWriteStatus     = 0;
 943         unsigned int value;
 944
 945         uiOffset = uiOffset&0x000FFFFF;
 946         /*
 947          * Implemented only for 1MB Flash parts.
 948          */
 949         if (FLASH_PART_SST25VF080B == Adapter->ulFlashID) {
 950                 /*
 951                  * Get Current BP status.
 952                  */
 953                 value = (FLASH_CMD_STATUS_REG_READ << 24);
 954                 wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value));
 955                 udelay(10);
 956                 /*
 957                  * Read status will be WWXXYYZZ. We have to take only WW.
 958                  */
 959                 rdmalt(Adapter, FLASH_SPI_READQ_REG, (PUINT)&ulStatus, sizeof(ulStatus));
 960                 ulStatus >>= 24;
 961                 ulWriteStatus = ulStatus;
 962                 /*
 963                  * Bits [5-2] give current block level protection status.
 964                  * Bit5: BP3 - DONT CARE
 965                  * BP2-BP0: 0 - NO PROTECTION, 1 - UPPER 1/16, 2 - UPPER 1/8, 3 - UPPER 1/4
 966                  *                4 - UPPER 1/2. 5 to 7 - ALL BLOCKS
 967                  */
 968
 969                 if (ulStatus) {
 970                         if ((uiOffset+uiLength) <= 0x80000) {
 971                                 /*
 972                                  * Offset comes in lower half of 1MB. Protect the upper half.
 973                                  * Clear BP1 and BP0 and set BP2.
 974                                  */
 975                                 ulWriteStatus |= (0x4<<2);
 976                                 ulWriteStatus &= ~(0x3<<2);
 977                         } else if ((uiOffset + uiLength) <= 0xC0000) {
 978                                 /*
 979                                  * Offset comes below Upper 1/4. Upper 1/4 can be protected.
 980                                  *  Clear BP2 and set BP1 and BP0.
 981                                  */
 982                                 ulWriteStatus |= (0x3<<2);
 983                                 ulWriteStatus &= ~(0x1<<4);
 984                         } else if ((uiOffset + uiLength) <= 0xE0000) {
 985                                 /*
 986                                  * Offset comes below Upper 1/8. Upper 1/8 can be protected.
 987                                  * Clear BP2 and BP0  and set BP1
 988                                  */
 989                                 ulWriteStatus |= (0x1<<3);
 990                                 ulWriteStatus &= ~(0x5<<2);
 991                         } else if ((uiOffset + uiLength) <= 0xF0000) {
 992                                 /*
 993                                  * Offset comes below Upper 1/16. Only upper 1/16 can be protected.
 994                                  * Set BP0 and Clear BP2,BP1.
 995                                  */
 996                                 ulWriteStatus |= (0x1<<2);
 997                                 ulWriteStatus &= ~(0x3<<3);
 998                         } else {
 999                                 /*
1000                                  * Unblock all.
1001                                  * Clear BP2,BP1 and BP0.
1002                                  */
1003                                 ulWriteStatus &= ~(0x7<<2);
1004                         }
1005
1006                         value = (FLASH_CMD_WRITE_ENABLE << 24);
1007                         wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value));
1008                         udelay(20);
1009                         value = (FLASH_CMD_STATUS_REG_WRITE << 24) | (ulWriteStatus << 16);
1010                         wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value));
1011                         udelay(20);
1012                 }
1013         }
1014         return ulStatus;
1015 }
1016
1017 /*
1018  * Procedure:   BeceemFlashBulkWrite
1019  *
1020  * Description: Performs write to the flash
1021  *
1022  * Arguments:
1023  *              Adapter    - ptr to Adapter object instance
1024  * pBuffer - Data to be written.
1025  *              uiOffset   - Offset of the flash where data needs to be written to.
1026  *              uiNumBytes - Number of bytes to be written.
1027  *              bVerify    - read verify flag.
1028  * Returns:
1029  *              OSAL_STATUS_CODE
1030  *
1031  */
1032
1033 static int BeceemFlashBulkWrite(struct bcm_mini_adapter *Adapter,
1034                                 PUINT pBuffer,
1035                                 unsigned int uiOffset,
1036                                 unsigned int uiNumBytes,
1037                                 BOOLEAN bVerify)
1038 {
1039         PCHAR pTempBuff                 = NULL;
1040         PUCHAR pcBuffer                 = (PUCHAR)pBuffer;
1041         unsigned int uiIndex                    = 0;
1042         unsigned int uiOffsetFromSectStart      = 0;
1043         unsigned int uiSectAlignAddr            = 0;
1044         unsigned int uiCurrSectOffsetAddr       = 0;
1045         unsigned int uiSectBoundary             = 0;
1046         unsigned int uiNumSectTobeRead          = 0;
1047         UCHAR ucReadBk[16]              = {0};
1048         ULONG ulStatus                  = 0;
1049         int Status                      = STATUS_SUCCESS;
1050         unsigned int uiTemp                     = 0;
1051         unsigned int index                      = 0;
1052         unsigned int uiPartOffset               = 0;
1053
1054         #if defined(BCM_SHM_INTERFACE) && !defined(FLASH_DIRECT_ACCESS)
1055                 Status = bcmflash_raw_write((uiOffset / FLASH_PART_SIZE), (uiOffset % FLASH_PART_SIZE), (unsigned char *)pBuffer, uiNumBytes);
1056                 return Status;
1057         #endif
1058
1059         uiOffsetFromSectStart = uiOffset & ~(Adapter->uiSectorSize - 1);
1060
1061         /* Adding flash Base address
1062          * uiOffset = uiOffset + GetFlashBaseAddr(Adapter);
1063          */
1064
1065         uiSectAlignAddr = uiOffset & ~(Adapter->uiSectorSize - 1);
1066         uiCurrSectOffsetAddr = uiOffset & (Adapter->uiSectorSize - 1);
1067         uiSectBoundary = uiSectAlignAddr + Adapter->uiSectorSize;
1068
1069         pTempBuff = kmalloc(Adapter->uiSectorSize, GFP_KERNEL);
1070         if (!pTempBuff)
1071                 goto BeceemFlashBulkWrite_EXIT;
1072         /*
1073          * check if the data to be written is overlapped across sectors
1074          */
1075         if (uiOffset+uiNumBytes < uiSectBoundary) {
1076                 uiNumSectTobeRead = 1;
1077         } else {
1078                 /* Number of sectors  = Last sector start address/First sector start address */
1079                 uiNumSectTobeRead =  (uiCurrSectOffsetAddr + uiNumBytes) / Adapter->uiSectorSize;
1080                 if ((uiCurrSectOffsetAddr + uiNumBytes)%Adapter->uiSectorSize)
1081                         uiNumSectTobeRead++;
1082         }
1083         /* Check whether Requested sector is writable or not in case of flash2x write. But if  write call is
1084          * for DSD calibration, allow it without checking of sector permission
1085          */
1086
1087         if (IsFlash2x(Adapter) && (Adapter->bAllDSDWriteAllow == FALSE)) {
1088                 index = 0;
1089                 uiTemp = uiNumSectTobeRead;
1090                 while (uiTemp) {
1091                         if (IsOffsetWritable(Adapter, uiOffsetFromSectStart + index * Adapter->uiSectorSize) == FALSE) {
1092                                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Sector Starting at offset <0X%X> is not writable",
1093                                                 (uiOffsetFromSectStart + index * Adapter->uiSectorSize));
1094                                 Status = SECTOR_IS_NOT_WRITABLE;
1095                                 goto BeceemFlashBulkWrite_EXIT;
1096                         }
1097                         uiTemp = uiTemp - 1;
1098                         index = index + 1 ;
1099                 }
1100         }
1101         Adapter->SelectedChip = RESET_CHIP_SELECT;
1102         while (uiNumSectTobeRead) {
1103                 /* do_gettimeofday(&tv1);
1104                  * BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "\nTime In start of write :%ld ms\n",(tv1.tv_sec *1000 + tv1.tv_usec /1000));
1105                  */
1106                 uiPartOffset = (uiSectAlignAddr & (FLASH_PART_SIZE - 1)) + GetFlashBaseAddr(Adapter);
1107
1108                 BcmDoChipSelect(Adapter, uiSectAlignAddr);
1109
1110                 if (0 != BeceemFlashBulkRead(Adapter,
1111                                                 (PUINT)pTempBuff,
1112                                                 uiOffsetFromSectStart,
1113                                                 Adapter->uiSectorSize)) {
1114                         Status = -1;
1115                         goto BeceemFlashBulkWrite_EXIT;
1116                 }
1117
1118                 /* do_gettimeofday(&tr);
1119                  * BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Total time taken by Read :%ld ms\n", (tr.tv_sec *1000 + tr.tv_usec/1000) - (tv1.tv_sec *1000 + tv1.tv_usec/1000));
1120                  */
1121                 ulStatus = BcmFlashUnProtectBlock(Adapter, uiSectAlignAddr, Adapter->uiSectorSize);
1122
1123                 if (uiNumSectTobeRead > 1) {
1124                         memcpy(&pTempBuff[uiCurrSectOffsetAddr], pcBuffer, uiSectBoundary - (uiSectAlignAddr + uiCurrSectOffsetAddr));
1125                         pcBuffer += ((uiSectBoundary - (uiSectAlignAddr + uiCurrSectOffsetAddr)));
1126                         uiNumBytes -= (uiSectBoundary - (uiSectAlignAddr + uiCurrSectOffsetAddr));
1127                 } else {
1128                         memcpy(&pTempBuff[uiCurrSectOffsetAddr], pcBuffer, uiNumBytes);
1129                 }
1130
1131                 if (IsFlash2x(Adapter))
1132                         SaveHeaderIfPresent(Adapter, (PUCHAR)pTempBuff, uiOffsetFromSectStart);
1133
1134                 FlashSectorErase(Adapter, uiPartOffset, 1);
1135                 /* do_gettimeofday(&te);
1136                  * BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Total time taken by Erase :%ld ms\n", (te.tv_sec *1000 + te.tv_usec/1000) - (tr.tv_sec *1000 + tr.tv_usec/1000));
1137                  */
1138                 for (uiIndex = 0; uiIndex < Adapter->uiSectorSize; uiIndex += Adapter->ulFlashWriteSize) {
1139                         if (Adapter->device_removed) {
1140                                 Status = -1;
1141                                 goto BeceemFlashBulkWrite_EXIT;
1142                         }
1143
1144                         if (STATUS_SUCCESS != (*Adapter->fpFlashWrite)(Adapter, uiPartOffset + uiIndex, (&pTempBuff[uiIndex]))) {
1145                                 Status = -1;
1146                                 goto BeceemFlashBulkWrite_EXIT;
1147                         }
1148                 }
1149
1150                 /* do_gettimeofday(&tw);
1151                  * BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Total time taken in Write  to Flash :%ld ms\n", (tw.tv_sec *1000 + tw.tv_usec/1000) - (te.tv_sec *1000 + te.tv_usec/1000));
1152                  */
1153                 for (uiIndex = 0; uiIndex < Adapter->uiSectorSize; uiIndex += MAX_RW_SIZE) {
1154                         if (STATUS_SUCCESS == BeceemFlashBulkRead(Adapter, (PUINT)ucReadBk, uiOffsetFromSectStart + uiIndex, MAX_RW_SIZE)) {
1155                                 if (Adapter->ulFlashWriteSize == 1) {
1156                                         unsigned int uiReadIndex = 0;
1157                                         for (uiReadIndex = 0; uiReadIndex < 16; uiReadIndex++) {
1158                                                 if (ucReadBk[uiReadIndex] != pTempBuff[uiIndex + uiReadIndex]) {
1159                                                         if (STATUS_SUCCESS != (*Adapter->fpFlashWriteWithStatusCheck)(Adapter, uiPartOffset + uiIndex + uiReadIndex, &pTempBuff[uiIndex+uiReadIndex])) {
1160                                                                 Status = STATUS_FAILURE;
1161                                                                 goto BeceemFlashBulkWrite_EXIT;
1162                                                         }
1163                                                 }
1164                                         }
1165                                 } else {
1166                                         if (memcmp(ucReadBk, &pTempBuff[uiIndex], MAX_RW_SIZE)) {
1167                                                 if (STATUS_SUCCESS != (*Adapter->fpFlashWriteWithStatusCheck)(Adapter, uiPartOffset + uiIndex, &pTempBuff[uiIndex])) {
1168                                                         Status = STATUS_FAILURE;
1169                                                         goto BeceemFlashBulkWrite_EXIT;
1170                                                 }
1171                                         }
1172                                 }
1173                         }
1174                 }
1175                 /* do_gettimeofday(&twv);
1176                  * BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Total time taken in Write  to Flash verification :%ld ms\n", (twv.tv_sec *1000 + twv.tv_usec/1000) - (tw.tv_sec *1000 + tw.tv_usec/1000));
1177                  */
1178                 if (ulStatus) {
1179                         BcmRestoreBlockProtectStatus(Adapter, ulStatus);
1180                         ulStatus = 0;
1181                 }
1182
1183                 uiCurrSectOffsetAddr = 0;
1184                 uiSectAlignAddr = uiSectBoundary;
1185                 uiSectBoundary += Adapter->uiSectorSize;
1186                 uiOffsetFromSectStart += Adapter->uiSectorSize;
1187                 uiNumSectTobeRead--;
1188         }
1189         /* do_gettimeofday(&tv2);
1190          * BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Time after Write :%ld ms\n",(tv2.tv_sec *1000 + tv2.tv_usec/1000));
1191          * BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Total time taken by in Write is :%ld ms\n", (tv2.tv_sec *1000 + tv2.tv_usec/1000) - (tv1.tv_sec *1000 + tv1.tv_usec/1000));
1192          *
1193          * Cleanup.
1194          */
1195 BeceemFlashBulkWrite_EXIT:
1196         if (ulStatus)
1197                 BcmRestoreBlockProtectStatus(Adapter, ulStatus);
1198
1199         kfree(pTempBuff);
1200
1201         Adapter->SelectedChip = RESET_CHIP_SELECT;
1202         return Status;
1203 }
1204
1205 /*
1206  * Procedure:   BeceemFlashBulkWriteStatus
1207  *
1208  * Description: Writes to Flash. Checks the SPI status after each write.
1209  *
1210  * Arguments:
1211  *              Adapter         - ptr to Adapter object instance
1212  *              pBuffer         - Data to be written.
1213  *              uiOffset        - Offset of the flash where data needs to be written to.
1214  *              uiNumBytes      - Number of bytes to be written.
1215  *              bVerify         - read verify flag.
1216  * Returns:
1217  *              OSAL_STATUS_CODE
1218  *
1219  */
1220
1221 static int BeceemFlashBulkWriteStatus(struct bcm_mini_adapter *Adapter,
1222                                 PUINT pBuffer,
1223                                 unsigned int uiOffset,
1224                                 unsigned int uiNumBytes,
1225                                 BOOLEAN bVerify)
1226 {
1227         PCHAR pTempBuff                 = NULL;
1228         PUCHAR pcBuffer                 = (PUCHAR)pBuffer;
1229         unsigned int uiIndex                    = 0;
1230         unsigned int uiOffsetFromSectStart      = 0;
1231         unsigned int uiSectAlignAddr            = 0;
1232         unsigned int uiCurrSectOffsetAddr       = 0;
1233         unsigned int uiSectBoundary             = 0;
1234         unsigned int uiNumSectTobeRead          = 0;
1235         UCHAR ucReadBk[16]              = {0};
1236         ULONG ulStatus                  = 0;
1237         unsigned int Status                     = STATUS_SUCCESS;
1238         unsigned int uiTemp                     = 0;
1239         unsigned int index                      = 0;
1240         unsigned int uiPartOffset               = 0;
1241
1242         uiOffsetFromSectStart = uiOffset & ~(Adapter->uiSectorSize - 1);
1243
1244         /* uiOffset += Adapter->ulFlashCalStart;
1245          * Adding flash Base address
1246          * uiOffset = uiOffset + GetFlashBaseAddr(Adapter);
1247          */
1248         uiSectAlignAddr = uiOffset & ~(Adapter->uiSectorSize - 1);
1249         uiCurrSectOffsetAddr = uiOffset & (Adapter->uiSectorSize - 1);
1250         uiSectBoundary = uiSectAlignAddr + Adapter->uiSectorSize;
1251
1252         pTempBuff = kmalloc(Adapter->uiSectorSize, GFP_KERNEL);
1253         if (!pTempBuff)
1254                 goto BeceemFlashBulkWriteStatus_EXIT;
1255
1256         /*
1257          * check if the data to be written is overlapped across sectors
1258          */
1259         if (uiOffset+uiNumBytes < uiSectBoundary) {
1260                 uiNumSectTobeRead = 1;
1261         } else {
1262                 /* Number of sectors  = Last sector start address/First sector start address */
1263                 uiNumSectTobeRead =  (uiCurrSectOffsetAddr + uiNumBytes) / Adapter->uiSectorSize;
1264                 if ((uiCurrSectOffsetAddr + uiNumBytes)%Adapter->uiSectorSize)
1265                         uiNumSectTobeRead++;
1266         }
1267
1268         if (IsFlash2x(Adapter) && (Adapter->bAllDSDWriteAllow == FALSE)) {
1269                 index = 0;
1270                 uiTemp = uiNumSectTobeRead;
1271                 while (uiTemp) {
1272                         if (IsOffsetWritable(Adapter, uiOffsetFromSectStart + index * Adapter->uiSectorSize) == FALSE) {
1273                                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Sector Starting at offset <0X%x> is not writable",
1274                                                 (uiOffsetFromSectStart + index * Adapter->uiSectorSize));
1275                                 Status = SECTOR_IS_NOT_WRITABLE;
1276                                 goto BeceemFlashBulkWriteStatus_EXIT;
1277                         }
1278                         uiTemp = uiTemp - 1;
1279                         index = index + 1 ;
1280                 }
1281         }
1282
1283         Adapter->SelectedChip = RESET_CHIP_SELECT;
1284         while (uiNumSectTobeRead) {
1285                 uiPartOffset = (uiSectAlignAddr & (FLASH_PART_SIZE - 1)) + GetFlashBaseAddr(Adapter);
1286
1287                 BcmDoChipSelect(Adapter, uiSectAlignAddr);
1288                 if (0 != BeceemFlashBulkRead(Adapter,
1289                                                 (PUINT)pTempBuff,
1290                                                 uiOffsetFromSectStart,
1291                                                 Adapter->uiSectorSize)) {
1292                         Status = -1;
1293                         goto BeceemFlashBulkWriteStatus_EXIT;
1294                 }
1295
1296                 ulStatus = BcmFlashUnProtectBlock(Adapter, uiOffsetFromSectStart, Adapter->uiSectorSize);
1297
1298                 if (uiNumSectTobeRead > 1) {
1299                         memcpy(&pTempBuff[uiCurrSectOffsetAddr], pcBuffer, uiSectBoundary - (uiSectAlignAddr + uiCurrSectOffsetAddr));
1300                         pcBuffer += ((uiSectBoundary - (uiSectAlignAddr + uiCurrSectOffsetAddr)));
1301                         uiNumBytes -= (uiSectBoundary - (uiSectAlignAddr + uiCurrSectOffsetAddr));
1302                 } else {
1303                         memcpy(&pTempBuff[uiCurrSectOffsetAddr], pcBuffer, uiNumBytes);
1304                 }
1305
1306                 if (IsFlash2x(Adapter))
1307                         SaveHeaderIfPresent(Adapter, (PUCHAR)pTempBuff, uiOffsetFromSectStart);
1308
1309                 FlashSectorErase(Adapter, uiPartOffset, 1);
1310
1311                 for (uiIndex = 0; uiIndex < Adapter->uiSectorSize; uiIndex += Adapter->ulFlashWriteSize) {
1312                         if (Adapter->device_removed) {
1313                                 Status = -1;
1314                                 goto BeceemFlashBulkWriteStatus_EXIT;
1315                         }
1316
1317                         if (STATUS_SUCCESS != (*Adapter->fpFlashWriteWithStatusCheck)(Adapter, uiPartOffset+uiIndex, &pTempBuff[uiIndex])) {
1318                                 Status = -1;
1319                                 goto BeceemFlashBulkWriteStatus_EXIT;
1320                         }
1321                 }
1322
1323                 if (bVerify) {
1324                         for (uiIndex = 0; uiIndex < Adapter->uiSectorSize; uiIndex += MAX_RW_SIZE) {
1325                                 if (STATUS_SUCCESS == BeceemFlashBulkRead(Adapter, (PUINT)ucReadBk, uiOffsetFromSectStart + uiIndex, MAX_RW_SIZE)) {
1326                                         if (memcmp(ucReadBk, &pTempBuff[uiIndex], MAX_RW_SIZE)) {
1327                                                 Status = STATUS_FAILURE;
1328                                                 goto BeceemFlashBulkWriteStatus_EXIT;
1329                                         }
1330                                 }
1331                         }
1332                 }
1333
1334                 if (ulStatus) {
1335                         BcmRestoreBlockProtectStatus(Adapter, ulStatus);
1336                         ulStatus = 0;
1337                 }
1338
1339                 uiCurrSectOffsetAddr = 0;
1340                 uiSectAlignAddr = uiSectBoundary;
1341                 uiSectBoundary += Adapter->uiSectorSize;
1342                 uiOffsetFromSectStart += Adapter->uiSectorSize;
1343                 uiNumSectTobeRead--;
1344         }
1345 /*
1346  * Cleanup.
1347  */
1348 BeceemFlashBulkWriteStatus_EXIT:
1349         if (ulStatus)
1350                 BcmRestoreBlockProtectStatus(Adapter, ulStatus);
1351
1352         kfree(pTempBuff);
1353         Adapter->SelectedChip = RESET_CHIP_SELECT;
1354         return Status;
1355 }
1356
1357 /*
1358  * Procedure:   PropagateCalParamsFromEEPROMToMemory
1359  *
1360  * Description: Dumps the calibration section of EEPROM to DDR.
1361  *
1362  * Arguments:
1363  *              Adapter    - ptr to Adapter object instance
1364  * Returns:
1365  *              OSAL_STATUS_CODE
1366  *
1367  */
1368
1369 int PropagateCalParamsFromEEPROMToMemory(struct bcm_mini_adapter *Adapter)
1370 {
1371         PCHAR pBuff = kmalloc(BUFFER_4K, GFP_KERNEL);
1372         unsigned int uiEepromSize = 0;
1373         unsigned int uiIndex = 0;
1374         unsigned int uiBytesToCopy = 0;
1375         unsigned int uiCalStartAddr = EEPROM_CALPARAM_START;
1376         unsigned int uiMemoryLoc = EEPROM_CAL_DATA_INTERNAL_LOC;
1377         unsigned int value;
1378         int Status = 0;
1379
1380         if (!pBuff)
1381                 return -ENOMEM;
1382
1383         if (0 != BeceemEEPROMBulkRead(Adapter, &uiEepromSize, EEPROM_SIZE_OFFSET, 4)) {
1384                 kfree(pBuff);
1385                 return -1;
1386         }
1387
1388         uiEepromSize >>= 16;
1389         if (uiEepromSize > 1024 * 1024) {
1390                 kfree(pBuff);
1391                 return -1;
1392         }
1393
1394         uiBytesToCopy = MIN(BUFFER_4K, uiEepromSize);
1395
1396         while (uiBytesToCopy) {
1397                 if (0 != BeceemEEPROMBulkRead(Adapter, (PUINT)pBuff, uiCalStartAddr, uiBytesToCopy)) {
1398                         Status = -1;
1399                         break;
1400                 }
1401                 wrm(Adapter, uiMemoryLoc, (PCHAR)(((PULONG)pBuff) + uiIndex), uiBytesToCopy);
1402                 uiMemoryLoc += uiBytesToCopy;
1403                 uiEepromSize -= uiBytesToCopy;
1404                 uiCalStartAddr += uiBytesToCopy;
1405                 uiIndex += uiBytesToCopy / 4;
1406                 uiBytesToCopy = MIN(BUFFER_4K, uiEepromSize);
1407
1408         }
1409         value = 0xbeadbead;
1410         wrmalt(Adapter, EEPROM_CAL_DATA_INTERNAL_LOC - 4, &value, sizeof(value));
1411         value = 0xbeadbead;
1412         wrmalt(Adapter, EEPROM_CAL_DATA_INTERNAL_LOC - 8, &value, sizeof(value));
1413         kfree(pBuff);
1414
1415         return Status;
1416 }
1417
1418 /*
1419  * Procedure:   PropagateCalParamsFromFlashToMemory
1420  *
1421  * Description: Dumps the calibration section of EEPROM to DDR.
1422  *
1423  * Arguments:
1424  *              Adapter    - ptr to Adapter object instance
1425  * Returns:
1426  *              OSAL_STATUS_CODE
1427  *
1428  */
1429
1430 int PropagateCalParamsFromFlashToMemory(struct bcm_mini_adapter *Adapter)
1431 {
1432         PCHAR pBuff, pPtr;
1433         unsigned int uiEepromSize = 0;
1434         unsigned int uiBytesToCopy = 0;
1435         /* unsigned int uiIndex = 0; */
1436         unsigned int uiCalStartAddr = EEPROM_CALPARAM_START;
1437         unsigned int uiMemoryLoc = EEPROM_CAL_DATA_INTERNAL_LOC;
1438         unsigned int value;
1439         int Status = 0;
1440
1441         /*
1442          * Write the signature first. This will ensure firmware does not access EEPROM.
1443          */
1444         value = 0xbeadbead;
1445         wrmalt(Adapter, EEPROM_CAL_DATA_INTERNAL_LOC - 4, &value, sizeof(value));
1446         value = 0xbeadbead;
1447         wrmalt(Adapter, EEPROM_CAL_DATA_INTERNAL_LOC - 8, &value, sizeof(value));
1448
1449         if (0 != BeceemNVMRead(Adapter, &uiEepromSize, EEPROM_SIZE_OFFSET, 4))
1450                 return -1;
1451
1452         uiEepromSize = ntohl(uiEepromSize);
1453         uiEepromSize >>= 16;
1454
1455         /*
1456          * subtract the auto init section size
1457          */
1458         uiEepromSize -= EEPROM_CALPARAM_START;
1459
1460         if (uiEepromSize > 1024 * 1024)
1461                 return -1;
1462
1463         pBuff = kmalloc(uiEepromSize, GFP_KERNEL);
1464         if (pBuff == NULL)
1465                 return -ENOMEM;
1466
1467         if (0 != BeceemNVMRead(Adapter, (PUINT)pBuff, uiCalStartAddr, uiEepromSize)) {
1468                 kfree(pBuff);
1469                 return -1;
1470         }
1471
1472         pPtr = pBuff;
1473
1474         uiBytesToCopy = MIN(BUFFER_4K, uiEepromSize);
1475
1476         while (uiBytesToCopy) {
1477                 Status = wrm(Adapter, uiMemoryLoc, (PCHAR)pPtr, uiBytesToCopy);
1478                 if (Status) {
1479                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "wrm failed with status :%d", Status);
1480                         break;
1481                 }
1482
1483                 pPtr += uiBytesToCopy;
1484                 uiEepromSize -= uiBytesToCopy;
1485                 uiMemoryLoc += uiBytesToCopy;
1486                 uiBytesToCopy = MIN(BUFFER_4K, uiEepromSize);
1487         }
1488
1489         kfree(pBuff);
1490         return Status;
1491 }
1492
1493 /*
1494  * Procedure:   BeceemEEPROMReadBackandVerify
1495  *
1496  * Description: Read back the data written and verifies.
1497  *
1498  * Arguments:
1499  *              Adapter         - ptr to Adapter object instance
1500  *              pBuffer         - Data to be written.
1501  *              uiOffset        - Offset of the flash where data needs to be written to.
1502  *              uiNumBytes      - Number of bytes to be written.
1503  * Returns:
1504  *              OSAL_STATUS_CODE
1505  *
1506  */
1507
1508 static int BeceemEEPROMReadBackandVerify(struct bcm_mini_adapter *Adapter,
1509                                         PUINT pBuffer,
1510                                         unsigned int uiOffset,
1511                                         unsigned int uiNumBytes)
1512 {
1513         unsigned int uiRdbk     = 0;
1514         unsigned int uiIndex    = 0;
1515         unsigned int uiData     = 0;
1516         unsigned int auiData[4] = {0};
1517
1518         while (uiNumBytes) {
1519                 if (Adapter->device_removed)
1520                         return -1;
1521
1522                 if (uiNumBytes >= MAX_RW_SIZE) {
1523                         /* for the requests more than or equal to MAX_RW_SIZE bytes, use bulk read function to make the access faster. */
1524                         BeceemEEPROMBulkRead(Adapter, &auiData[0], uiOffset, MAX_RW_SIZE);
1525
1526                         if (memcmp(&pBuffer[uiIndex], &auiData[0], MAX_RW_SIZE)) {
1527                                 /* re-write */
1528                                 BeceemEEPROMBulkWrite(Adapter, (PUCHAR)(pBuffer + uiIndex), uiOffset, MAX_RW_SIZE, FALSE);
1529                                 mdelay(3);
1530                                 BeceemEEPROMBulkRead(Adapter, &auiData[0], uiOffset, MAX_RW_SIZE);
1531
1532                                 if (memcmp(&pBuffer[uiIndex], &auiData[0], MAX_RW_SIZE))
1533                                         return -1;
1534                         }
1535                         uiOffset += MAX_RW_SIZE;
1536                         uiNumBytes -= MAX_RW_SIZE;
1537                         uiIndex += 4;
1538                 } else if (uiNumBytes >= 4) {
1539                         BeceemEEPROMBulkRead(Adapter, &uiData, uiOffset, 4);
1540                         if (uiData != pBuffer[uiIndex]) {
1541                                 /* re-write */
1542                                 BeceemEEPROMBulkWrite(Adapter, (PUCHAR)(pBuffer + uiIndex), uiOffset, 4, FALSE);
1543                                 mdelay(3);
1544                                 BeceemEEPROMBulkRead(Adapter, &uiData, uiOffset, 4);
1545                                 if (uiData != pBuffer[uiIndex])
1546                                         return -1;
1547                         }
1548                         uiOffset += 4;
1549                         uiNumBytes -= 4;
1550                         uiIndex++;
1551                 } else {
1552                         /* Handle the reads less than 4 bytes... */
1553                         uiData = 0;
1554                         memcpy(&uiData, ((PUCHAR)pBuffer) + (uiIndex * sizeof(unsigned int)), uiNumBytes);
1555                         BeceemEEPROMBulkRead(Adapter, &uiRdbk, uiOffset, 4);
1556
1557                         if (memcmp(&uiData, &uiRdbk, uiNumBytes))
1558                                 return -1;
1559
1560                         uiNumBytes = 0;
1561                 }
1562         }
1563
1564         return 0;
1565 }
1566
1567 static VOID BcmSwapWord(unsigned int *ptr1)
1568 {
1569         unsigned int tempval = (unsigned int)*ptr1;
1570         char *ptr2 = (char *)&tempval;
1571         char *ptr = (char *)ptr1;
1572
1573         ptr[0] = ptr2[3];
1574         ptr[1] = ptr2[2];
1575         ptr[2] = ptr2[1];
1576         ptr[3] = ptr2[0];
1577 }
1578
1579 /*
1580  * Procedure:   BeceemEEPROMWritePage
1581  *
1582  * Description: Performs page write (16bytes) to the EEPROM
1583  *
1584  * Arguments:
1585  *              Adapter         - ptr to Adapter object instance
1586  *              uiData          - Data to be written.
1587  *              uiOffset        - Offset of the EEPROM where data needs to be written to.
1588  * Returns:
1589  *              OSAL_STATUS_CODE
1590  *
1591  */
1592
1593 static int BeceemEEPROMWritePage(struct bcm_mini_adapter *Adapter, unsigned int uiData[], unsigned int uiOffset)
1594 {
1595         unsigned int uiRetries = MAX_EEPROM_RETRIES * RETRIES_PER_DELAY;
1596         unsigned int uiStatus = 0;
1597         UCHAR uiEpromStatus = 0;
1598         unsigned int value = 0;
1599
1600         /* Flush the Write/Read/Cmd queues. */
1601         value = (EEPROM_WRITE_QUEUE_FLUSH | EEPROM_CMD_QUEUE_FLUSH | EEPROM_READ_QUEUE_FLUSH);
1602         wrmalt(Adapter, SPI_FLUSH_REG, &value, sizeof(value));
1603         value = 0;
1604         wrmalt(Adapter, SPI_FLUSH_REG, &value, sizeof(value));
1605
1606         /* Clear the Empty/Avail/Full bits.  After this it has been confirmed
1607          * that the bit was cleared by reading back the register. See NOTE below.
1608          * We also clear the Read queues as we do a EEPROM status register read
1609          * later.
1610          */
1611         value = (EEPROM_WRITE_QUEUE_EMPTY | EEPROM_WRITE_QUEUE_AVAIL | EEPROM_WRITE_QUEUE_FULL | EEPROM_READ_DATA_AVAIL | EEPROM_READ_DATA_FULL);
1612         wrmalt(Adapter, EEPROM_SPI_Q_STATUS1_REG, &value, sizeof(value));
1613
1614         /* Enable write */
1615         value = EEPROM_WRITE_ENABLE;
1616         wrmalt(Adapter, EEPROM_CMDQ_SPI_REG, &value, sizeof(value));
1617
1618         /* We can write back to back 8bits * 16 into the queue and as we have
1619          * checked for the queue to be empty we can write in a burst.
1620          */
1621
1622         value = uiData[0];
1623         BcmSwapWord(&value);
1624         wrm(Adapter, EEPROM_WRITE_DATAQ_REG, (PUCHAR)&value, 4);
1625
1626         value = uiData[1];
1627         BcmSwapWord(&value);
1628         wrm(Adapter, EEPROM_WRITE_DATAQ_REG, (PUCHAR)&value, 4);
1629
1630         value = uiData[2];
1631         BcmSwapWord(&value);
1632         wrm(Adapter, EEPROM_WRITE_DATAQ_REG, (PUCHAR)&value, 4);
1633
1634         value = uiData[3];
1635         BcmSwapWord(&value);
1636         wrm(Adapter, EEPROM_WRITE_DATAQ_REG, (PUCHAR)&value, 4);
1637
1638         /* NOTE : After this write, on readback of EEPROM_SPI_Q_STATUS1_REG
1639          * shows that we see 7 for the EEPROM data write.  Which means that
1640          * queue got full, also space is available as well as the queue is empty.
1641          * This may happen in sequence.
1642          */
1643         value =  EEPROM_16_BYTE_PAGE_WRITE | uiOffset;
1644         wrmalt(Adapter, EEPROM_CMDQ_SPI_REG, &value, sizeof(value));
1645
1646         /* Ideally we should loop here without tries and eventually succeed.
1647          * What we are checking if the previous write has completed, and this
1648          * may take time. We should wait till the Empty bit is set.
1649          */
1650         uiStatus = 0;
1651         rdmalt(Adapter, EEPROM_SPI_Q_STATUS1_REG, &uiStatus, sizeof(uiStatus));
1652         while ((uiStatus & EEPROM_WRITE_QUEUE_EMPTY) == 0) {
1653                 uiRetries--;
1654                 if (uiRetries == 0) {
1655                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "0x0f003004 = %x, %d retries failed.\n", uiStatus, MAX_EEPROM_RETRIES * RETRIES_PER_DELAY);
1656                         return STATUS_FAILURE;
1657                 }
1658
1659                 if (!(uiRetries%RETRIES_PER_DELAY))
1660                         udelay(1000);
1661
1662                 uiStatus = 0;
1663                 rdmalt(Adapter, EEPROM_SPI_Q_STATUS1_REG, &uiStatus, sizeof(uiStatus));
1664                 if (Adapter->device_removed == TRUE) {
1665                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Modem got removed hence exiting from loop....");
1666                         return -ENODEV;
1667                 }
1668         }
1669
1670         if (uiRetries != 0) {
1671                 /* Clear the ones that are set - either, Empty/Full/Avail bits */
1672                 value = (uiStatus & (EEPROM_WRITE_QUEUE_EMPTY | EEPROM_WRITE_QUEUE_AVAIL | EEPROM_WRITE_QUEUE_FULL));
1673                 wrmalt(Adapter, EEPROM_SPI_Q_STATUS1_REG, &value, sizeof(value));
1674         }
1675
1676         /* Here we should check if the EEPROM status register is correct before
1677          * proceeding. Bit 0 in the EEPROM Status register should be 0 before
1678          * we proceed further.  A 1 at Bit 0 indicates that the EEPROM is busy
1679          * with the previous write. Note also that issuing this read finally
1680          * means the previous write to the EEPROM has completed.
1681          */
1682         uiRetries = MAX_EEPROM_RETRIES * RETRIES_PER_DELAY;
1683         uiEpromStatus = 0;
1684         while (uiRetries != 0) {
1685                 uiEpromStatus = ReadEEPROMStatusRegister(Adapter);
1686                 if (Adapter->device_removed == TRUE) {
1687                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Modem has got removed hence exiting from loop...");
1688                         return -ENODEV;
1689                 }
1690                 if ((EEPROM_STATUS_REG_WRITE_BUSY & uiEpromStatus) == 0) {
1691                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "EEPROM status register = %x tries = %d\n", uiEpromStatus, (MAX_EEPROM_RETRIES * RETRIES_PER_DELAY - uiRetries));
1692                         return STATUS_SUCCESS;
1693                 }
1694                 uiRetries--;
1695                 if (uiRetries == 0) {
1696                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "0x0f003004 = %x, for EEPROM status read %d retries failed.\n", uiEpromStatus, MAX_EEPROM_RETRIES * RETRIES_PER_DELAY);
1697                         return STATUS_FAILURE;
1698                 }
1699                 uiEpromStatus = 0;
1700                 if (!(uiRetries%RETRIES_PER_DELAY))
1701                         udelay(1000);
1702         }
1703
1704         return STATUS_SUCCESS;
1705 } /* BeceemEEPROMWritePage */
1706
1707 /*
1708  * Procedure:   BeceemEEPROMBulkWrite
1709  *
1710  * Description: Performs write to the EEPROM
1711  *
1712  * Arguments:
1713  *              Adapter         - ptr to Adapter object instance
1714  *              pBuffer         - Data to be written.
1715  *              uiOffset        - Offset of the EEPROM where data needs to be written to.
1716  *              uiNumBytes      - Number of bytes to be written.
1717  *              bVerify         - read verify flag.
1718  * Returns:
1719  *              OSAL_STATUS_CODE
1720  *
1721  */
1722
1723 int BeceemEEPROMBulkWrite(struct bcm_mini_adapter *Adapter,
1724                         PUCHAR pBuffer,
1725                         unsigned int uiOffset,
1726                         unsigned int uiNumBytes,
1727                         BOOLEAN bVerify)
1728 {
1729         unsigned int uiBytesToCopy      = uiNumBytes;
1730         /* unsigned int uiRdbk          = 0; */
1731         unsigned int uiData[4]          = {0};
1732         unsigned int uiIndex            = 0;
1733         unsigned int uiTempOffset       = 0;
1734         unsigned int uiExtraBytes       = 0;
1735         /* PUINT puiBuffer      = (PUINT)pBuffer;
1736          * int value;
1737          */
1738
1739         if (uiOffset % MAX_RW_SIZE && uiBytesToCopy) {
1740                 uiTempOffset = uiOffset - (uiOffset % MAX_RW_SIZE);
1741                 uiExtraBytes = uiOffset - uiTempOffset;
1742
1743                 BeceemEEPROMBulkRead(Adapter, &uiData[0], uiTempOffset, MAX_RW_SIZE);
1744
1745                 if (uiBytesToCopy >= (16 - uiExtraBytes)) {
1746                         memcpy((((PUCHAR)&uiData[0]) + uiExtraBytes), pBuffer, MAX_RW_SIZE - uiExtraBytes);
1747
1748                         if (STATUS_FAILURE == BeceemEEPROMWritePage(Adapter, uiData, uiTempOffset))
1749                                 return STATUS_FAILURE;
1750
1751                         uiBytesToCopy -= (MAX_RW_SIZE - uiExtraBytes);
1752                         uiIndex += (MAX_RW_SIZE - uiExtraBytes);
1753                         uiOffset += (MAX_RW_SIZE - uiExtraBytes);
1754                 } else {
1755                         memcpy((((PUCHAR)&uiData[0]) + uiExtraBytes), pBuffer, uiBytesToCopy);
1756
1757                         if (STATUS_FAILURE == BeceemEEPROMWritePage(Adapter, uiData, uiTempOffset))
1758                                 return STATUS_FAILURE;
1759
1760                         uiIndex += uiBytesToCopy;
1761                         uiOffset += uiBytesToCopy;
1762                         uiBytesToCopy = 0;
1763                 }
1764         }
1765
1766         while (uiBytesToCopy) {
1767                 if (Adapter->device_removed)
1768                         return -1;
1769
1770                 if (uiBytesToCopy >= MAX_RW_SIZE) {
1771                         if (STATUS_FAILURE == BeceemEEPROMWritePage(Adapter, (PUINT) &pBuffer[uiIndex], uiOffset))
1772                                 return STATUS_FAILURE;
1773
1774                         uiIndex += MAX_RW_SIZE;
1775                         uiOffset += MAX_RW_SIZE;
1776                         uiBytesToCopy -= MAX_RW_SIZE;
1777                 } else {
1778                         /*
1779                          * To program non 16byte aligned data, read 16byte and then update.
1780                          */
1781                         BeceemEEPROMBulkRead(Adapter, &uiData[0], uiOffset, 16);
1782                         memcpy(&uiData[0], pBuffer + uiIndex, uiBytesToCopy);
1783
1784                         if (STATUS_FAILURE == BeceemEEPROMWritePage(Adapter, uiData, uiOffset))
1785                                 return STATUS_FAILURE;
1786
1787                         uiBytesToCopy = 0;
1788                 }
1789         }
1790
1791         return 0;
1792 }
1793
1794 /*
1795  * Procedure:   BeceemNVMRead
1796  *
1797  * Description: Reads n number of bytes from NVM.
1798  *
1799  * Arguments:
1800  *              Adapter      - ptr to Adapter object instance
1801  *              pBuffer       - Buffer to store the data read from NVM
1802  *              uiOffset       - Offset of NVM from where data should be read
1803  *              uiNumBytes - Number of bytes to be read from the NVM.
1804  *
1805  * Returns:
1806  *              OSAL_STATUS_SUCCESS - if NVM read is successful.
1807  *              <FAILURE>                       - if failed.
1808  */
1809
1810 int BeceemNVMRead(struct bcm_mini_adapter *Adapter,
1811                 PUINT pBuffer,
1812                 unsigned int uiOffset,
1813                 unsigned int uiNumBytes)
1814 {
1815         int Status = 0;
1816
1817         #if !defined(BCM_SHM_INTERFACE) || defined(FLASH_DIRECT_ACCESS)
1818                 unsigned int uiTemp = 0, value;
1819         #endif
1820
1821         if (Adapter->eNVMType == NVM_FLASH) {
1822                 if (Adapter->bFlashRawRead == FALSE) {
1823                         if (IsSectionExistInVendorInfo(Adapter, Adapter->eActiveDSD))
1824                                 return vendorextnReadSection(Adapter, (PUCHAR)pBuffer, Adapter->eActiveDSD, uiOffset, uiNumBytes);
1825
1826                         uiOffset = uiOffset + Adapter->ulFlashCalStart;
1827                 }
1828
1829                 #if defined(BCM_SHM_INTERFACE) && !defined(FLASH_DIRECT_ACCESS)
1830                         Status = bcmflash_raw_read((uiOffset / FLASH_PART_SIZE), (uiOffset % FLASH_PART_SIZE), (unsigned char *)pBuffer, uiNumBytes);
1831                 #else
1832                         rdmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
1833                         value = 0;
1834                         wrmalt(Adapter, 0x0f000C80, &value, sizeof(value));
1835                         Status = BeceemFlashBulkRead(Adapter,
1836                                                 pBuffer,
1837                                                 uiOffset,
1838                                                 uiNumBytes);
1839                         wrmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
1840                 #endif
1841         } else if (Adapter->eNVMType == NVM_EEPROM) {
1842                 Status = BeceemEEPROMBulkRead(Adapter,
1843                                         pBuffer,
1844                                         uiOffset,
1845                                         uiNumBytes);
1846         } else {
1847                 Status = -1;
1848         }
1849
1850         return Status;
1851 }
1852
1853 /*
1854  * Procedure:   BeceemNVMWrite
1855  *
1856  * Description: Writes n number of bytes to NVM.
1857  *
1858  * Arguments:
1859  *              Adapter      - ptr to Adapter object instance
1860  *              pBuffer       - Buffer contains the data to be written.
1861  *              uiOffset       - Offset of NVM where data to be written to.
1862  *              uiNumBytes - Number of bytes to be written..
1863  *
1864  * Returns:
1865  *              OSAL_STATUS_SUCCESS - if NVM write is successful.
1866  *              <FAILURE>                       - if failed.
1867  */
1868
1869 int BeceemNVMWrite(struct bcm_mini_adapter *Adapter,
1870                 PUINT pBuffer,
1871                 unsigned int uiOffset,
1872                 unsigned int uiNumBytes,
1873                 BOOLEAN bVerify)
1874 {
1875         int Status = 0;
1876         unsigned int uiTemp = 0;
1877         unsigned int uiMemoryLoc = EEPROM_CAL_DATA_INTERNAL_LOC;
1878         unsigned int uiIndex = 0;
1879
1880         #if !defined(BCM_SHM_INTERFACE) || defined(FLASH_DIRECT_ACCESS)
1881                 unsigned int value;
1882         #endif
1883
1884         unsigned int uiFlashOffset = 0;
1885
1886         if (Adapter->eNVMType == NVM_FLASH) {
1887                 if (IsSectionExistInVendorInfo(Adapter, Adapter->eActiveDSD))
1888                         Status = vendorextnWriteSection(Adapter, (PUCHAR)pBuffer, Adapter->eActiveDSD, uiOffset, uiNumBytes, bVerify);
1889                 else {
1890                         uiFlashOffset = uiOffset + Adapter->ulFlashCalStart;
1891
1892                         #if defined(BCM_SHM_INTERFACE) && !defined(FLASH_DIRECT_ACCESS)
1893                                 Status = bcmflash_raw_write((uiFlashOffset / FLASH_PART_SIZE), (uiFlashOffset % FLASH_PART_SIZE), (unsigned char *)pBuffer, uiNumBytes);
1894                         #else
1895                                 rdmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
1896                                 value = 0;
1897                                 wrmalt(Adapter, 0x0f000C80, &value, sizeof(value));
1898
1899                                 if (Adapter->bStatusWrite == TRUE)
1900                                         Status = BeceemFlashBulkWriteStatus(Adapter,
1901                                                                         pBuffer,
1902                                                                         uiFlashOffset,
1903                                                                         uiNumBytes ,
1904                                                                         bVerify);
1905                                 else
1906
1907                                         Status = BeceemFlashBulkWrite(Adapter,
1908                                                                 pBuffer,
1909                                                                 uiFlashOffset,
1910                                                                 uiNumBytes,
1911                                                                 bVerify);
1912                         #endif
1913                 }
1914
1915                 if (uiOffset >= EEPROM_CALPARAM_START) {
1916                         uiMemoryLoc += (uiOffset - EEPROM_CALPARAM_START);
1917                         while (uiNumBytes) {
1918                                 if (uiNumBytes > BUFFER_4K) {
1919                                         wrm(Adapter, (uiMemoryLoc+uiIndex), (PCHAR)(pBuffer + (uiIndex / 4)), BUFFER_4K);
1920                                         uiNumBytes -= BUFFER_4K;
1921                                         uiIndex += BUFFER_4K;
1922                                 } else {
1923                                         wrm(Adapter, uiMemoryLoc+uiIndex, (PCHAR)(pBuffer + (uiIndex / 4)), uiNumBytes);
1924                                         uiNumBytes = 0;
1925                                         break;
1926                                 }
1927                         }
1928                 } else {
1929                         if ((uiOffset + uiNumBytes) > EEPROM_CALPARAM_START) {
1930                                 ULONG ulBytesTobeSkipped = 0;
1931                                 PUCHAR pcBuffer = (PUCHAR)pBuffer; /* char pointer to take care of odd byte cases. */
1932                                 uiNumBytes -= (EEPROM_CALPARAM_START - uiOffset);
1933                                 ulBytesTobeSkipped += (EEPROM_CALPARAM_START - uiOffset);
1934                                 uiOffset += (EEPROM_CALPARAM_START - uiOffset);
1935                                 while (uiNumBytes) {
1936                                         if (uiNumBytes > BUFFER_4K) {
1937                                                 wrm(Adapter, uiMemoryLoc + uiIndex, (PCHAR)&pcBuffer[ulBytesTobeSkipped + uiIndex], BUFFER_4K);
1938                                                 uiNumBytes -= BUFFER_4K;
1939                                                 uiIndex += BUFFER_4K;
1940                                         } else {
1941                                                 wrm(Adapter, uiMemoryLoc + uiIndex, (PCHAR)&pcBuffer[ulBytesTobeSkipped + uiIndex], uiNumBytes);
1942                                                 uiNumBytes = 0;
1943                                                 break;
1944                                         }
1945                                 }
1946                         }
1947                 }
1948                 /* restore the values. */
1949                 wrmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
1950         } else if (Adapter->eNVMType == NVM_EEPROM) {
1951                 Status = BeceemEEPROMBulkWrite(Adapter,
1952                                         (PUCHAR)pBuffer,
1953                                         uiOffset,
1954                                         uiNumBytes,
1955                                         bVerify);
1956                 if (bVerify)
1957                         Status = BeceemEEPROMReadBackandVerify(Adapter, (PUINT)pBuffer, uiOffset, uiNumBytes);
1958         } else {
1959                 Status = -1;
1960         }
1961         return Status;
1962 }
1963
1964 /*
1965  * Procedure:   BcmUpdateSectorSize
1966  *
1967  * Description: Updates the sector size to FLASH.
1968  *
1969  * Arguments:
1970  *              Adapter       - ptr to Adapter object instance
1971  *          uiSectorSize - sector size
1972  *
1973  * Returns:
1974  *              OSAL_STATUS_SUCCESS - if NVM write is successful.
1975  *              <FAILURE>                       - if failed.
1976  */
1977
1978 int BcmUpdateSectorSize(struct bcm_mini_adapter *Adapter, unsigned int uiSectorSize)
1979 {
1980         int Status = -1;
1981         struct bcm_flash_cs_info sFlashCsInfo = {0};
1982         unsigned int uiTemp = 0;
1983         unsigned int uiSectorSig = 0;
1984         unsigned int uiCurrentSectorSize = 0;
1985         unsigned int value;
1986
1987         rdmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
1988         value = 0;
1989         wrmalt(Adapter, 0x0f000C80, &value, sizeof(value));
1990
1991         /*
1992          * Before updating the sector size in the reserved area, check if already present.
1993          */
1994         BeceemFlashBulkRead(Adapter, (PUINT)&sFlashCsInfo, Adapter->ulFlashControlSectionStart, sizeof(sFlashCsInfo));
1995         uiSectorSig = ntohl(sFlashCsInfo.FlashSectorSizeSig);
1996         uiCurrentSectorSize = ntohl(sFlashCsInfo.FlashSectorSize);
1997
1998         if (uiSectorSig == FLASH_SECTOR_SIZE_SIG) {
1999                 if ((uiCurrentSectorSize <= MAX_SECTOR_SIZE) && (uiCurrentSectorSize >= MIN_SECTOR_SIZE)) {
2000                         if (uiSectorSize == uiCurrentSectorSize) {
2001                                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Provided sector size is same as programmed in Flash");
2002                                 Status = STATUS_SUCCESS;
2003                                 goto Restore;
2004                         }
2005                 }
2006         }
2007
2008         if ((uiSectorSize <= MAX_SECTOR_SIZE) && (uiSectorSize >= MIN_SECTOR_SIZE)) {
2009                 sFlashCsInfo.FlashSectorSize = htonl(uiSectorSize);
2010                 sFlashCsInfo.FlashSectorSizeSig = htonl(FLASH_SECTOR_SIZE_SIG);
2011
2012                 Status = BeceemFlashBulkWrite(Adapter,
2013                                         (PUINT)&sFlashCsInfo,
2014                                         Adapter->ulFlashControlSectionStart,
2015                                         sizeof(sFlashCsInfo),
2016                                         TRUE);
2017         }
2018
2019 Restore:
2020         /* restore the values. */
2021         wrmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
2022
2023         return Status;
2024 }
2025
2026 /*
2027  * Procedure:   BcmGetFlashSectorSize
2028  *
2029  * Description: Finds the sector size of the FLASH.
2030  *
2031  * Arguments:
2032  *              Adapter    - ptr to Adapter object instance
2033  *
2034  * Returns:
2035  *              unsigned int - sector size.
2036  *
2037  */
2038
2039 static unsigned int BcmGetFlashSectorSize(struct bcm_mini_adapter *Adapter, unsigned int FlashSectorSizeSig, unsigned int FlashSectorSize)
2040 {
2041         unsigned int uiSectorSize = 0;
2042         unsigned int uiSectorSig = 0;
2043
2044         if (Adapter->bSectorSizeOverride &&
2045                 (Adapter->uiSectorSizeInCFG <= MAX_SECTOR_SIZE &&
2046                         Adapter->uiSectorSizeInCFG >= MIN_SECTOR_SIZE)) {
2047                 Adapter->uiSectorSize = Adapter->uiSectorSizeInCFG;
2048         } else {
2049                 uiSectorSig = FlashSectorSizeSig;
2050
2051                 if (uiSectorSig == FLASH_SECTOR_SIZE_SIG) {
2052                         uiSectorSize = FlashSectorSize;
2053                         /*
2054                          * If the sector size stored in the FLASH makes sense then use it.
2055                          */
2056                         if (uiSectorSize <= MAX_SECTOR_SIZE && uiSectorSize >= MIN_SECTOR_SIZE) {
2057                                 Adapter->uiSectorSize = uiSectorSize;
2058                         } else if (Adapter->uiSectorSizeInCFG <= MAX_SECTOR_SIZE &&
2059                                 Adapter->uiSectorSizeInCFG >= MIN_SECTOR_SIZE) {
2060                                 /* No valid size in FLASH, check if Config file has it. */
2061                                 Adapter->uiSectorSize = Adapter->uiSectorSizeInCFG;
2062                         } else {
2063                                 /* Init to Default, if none of the above works. */
2064                                 Adapter->uiSectorSize = DEFAULT_SECTOR_SIZE;
2065                         }
2066                 } else {
2067                         if (Adapter->uiSectorSizeInCFG <= MAX_SECTOR_SIZE &&
2068                                 Adapter->uiSectorSizeInCFG >= MIN_SECTOR_SIZE)
2069                                 Adapter->uiSectorSize = Adapter->uiSectorSizeInCFG;
2070                         else
2071                                 Adapter->uiSectorSize = DEFAULT_SECTOR_SIZE;
2072                 }
2073         }
2074
2075         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Sector size  :%x\n", Adapter->uiSectorSize);
2076
2077         return Adapter->uiSectorSize;
2078 }
2079
2080 /*
2081  * Procedure:   BcmInitEEPROMQueues
2082  *
2083  * Description: Initialization of EEPROM queues.
2084  *
2085  * Arguments:
2086  *              Adapter    - ptr to Adapter object instance
2087  *
2088  * Returns:
2089  *              <OSAL_STATUS_CODE>
2090  */
2091
2092 static int BcmInitEEPROMQueues(struct bcm_mini_adapter *Adapter)
2093 {
2094         unsigned int value = 0;
2095         /* CHIP Bug : Clear the Avail bits on the Read queue. The default
2096          * value on this register is supposed to be 0x00001102.
2097          * But we get 0x00001122.
2098          */
2099         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Fixing reset value on 0x0f003004 register\n");
2100         value = EEPROM_READ_DATA_AVAIL;
2101         wrmalt(Adapter, EEPROM_SPI_Q_STATUS1_REG, &value, sizeof(value));
2102
2103         /* Flush the all the EEPROM queues. */
2104         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, " Flushing the queues\n");
2105         value = EEPROM_ALL_QUEUE_FLUSH;
2106         wrmalt(Adapter, SPI_FLUSH_REG, &value, sizeof(value));
2107
2108         value = 0;
2109         wrmalt(Adapter, SPI_FLUSH_REG, &value, sizeof(value));
2110
2111         /* Read the EEPROM Status Register. Just to see, no real purpose. */
2112         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "EEPROM Status register value = %x\n", ReadEEPROMStatusRegister(Adapter));
2113
2114         return STATUS_SUCCESS;
2115 } /* BcmInitEEPROMQueues() */
2116
2117 /*
2118  * Procedure:   BcmInitNVM
2119  *
2120  * Description: Initialization of NVM, EEPROM size,FLASH size, sector size etc.
2121  *
2122  * Arguments:
2123  *              Adapter    - ptr to Adapter object instance
2124  *
2125  * Returns:
2126  *              <OSAL_STATUS_CODE>
2127  */
2128
2129 int BcmInitNVM(struct bcm_mini_adapter *ps_adapter)
2130 {
2131         BcmValidateNvmType(ps_adapter);
2132         BcmInitEEPROMQueues(ps_adapter);
2133
2134         if (ps_adapter->eNVMType == NVM_AUTODETECT) {
2135                 ps_adapter->eNVMType = BcmGetNvmType(ps_adapter);
2136                 if (ps_adapter->eNVMType == NVM_UNKNOWN)
2137                         BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_PRINTK, 0, 0, "NVM Type is unknown!!\n");
2138         } else if (ps_adapter->eNVMType == NVM_FLASH) {
2139                 BcmGetFlashCSInfo(ps_adapter);
2140         }
2141
2142         BcmGetNvmSize(ps_adapter);
2143
2144         return STATUS_SUCCESS;
2145 }
2146
2147 /* BcmGetNvmSize : set the EEPROM or flash size in Adapter.
2148  *
2149  * Input Parameter:
2150  *              Adapter data structure
2151  * Return Value :
2152  *              0. means success;
2153  */
2154
2155 static int BcmGetNvmSize(struct bcm_mini_adapter *Adapter)
2156 {
2157         if (Adapter->eNVMType == NVM_EEPROM)
2158                 Adapter->uiNVMDSDSize = BcmGetEEPROMSize(Adapter);
2159         else if (Adapter->eNVMType == NVM_FLASH)
2160                 Adapter->uiNVMDSDSize = BcmGetFlashSize(Adapter);
2161
2162         return 0;
2163 }
2164
2165 /*
2166  * Procedure:   BcmValidateNvm
2167  *
2168  * Description: Validates the NVM Type option selected against the device
2169  *
2170  * Arguments:
2171  *              Adapter    - ptr to Adapter object instance
2172  *
2173  * Returns:
2174  *              <VOID>
2175  */
2176
2177 static VOID BcmValidateNvmType(struct bcm_mini_adapter *Adapter)
2178 {
2179         /*
2180          * if forcing the FLASH through CFG file, we should ensure device really has a FLASH.
2181          * Accessing the FLASH address without the FLASH being present can cause hang/freeze etc.
2182          * So if NVM_FLASH is selected for older chipsets, change it to AUTODETECT where EEPROM is 1st choice.
2183          */
2184
2185         if (Adapter->eNVMType == NVM_FLASH &&
2186                 Adapter->chip_id < 0xBECE3300)
2187                 Adapter->eNVMType = NVM_AUTODETECT;
2188 }
2189
2190 /*
2191  * Procedure:   BcmReadFlashRDID
2192  *
2193  * Description: Reads ID from Serial Flash
2194  *
2195  * Arguments:
2196  *              Adapter    - ptr to Adapter object instance
2197  *
2198  * Returns:
2199  *              Flash ID
2200  */
2201
2202 static ULONG BcmReadFlashRDID(struct bcm_mini_adapter *Adapter)
2203 {
2204         ULONG ulRDID = 0;
2205         unsigned int value;
2206
2207         /*
2208          * Read ID Instruction.
2209          */
2210         value = (FLASH_CMD_READ_ID << 24);
2211         wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value));
2212
2213         /* Delay */
2214         udelay(10);
2215
2216         /*
2217          * Read SPI READQ REG. The output will be WWXXYYZZ.
2218          * The ID is 3Bytes long and is WWXXYY. ZZ needs to be Ignored.
2219          */
2220         rdmalt(Adapter, FLASH_SPI_READQ_REG, (PUINT)&ulRDID, sizeof(ulRDID));
2221
2222         return ulRDID >> 8;
2223 }
2224
2225 int BcmAllocFlashCSStructure(struct bcm_mini_adapter *psAdapter)
2226 {
2227         if (!psAdapter) {
2228                 BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_PRINTK, 0, 0, "Adapter structure point is NULL");
2229                 return -EINVAL;
2230         }
2231         psAdapter->psFlashCSInfo = (struct bcm_flash_cs_info *)kzalloc(sizeof(struct bcm_flash_cs_info), GFP_KERNEL);
2232         if (psAdapter->psFlashCSInfo == NULL) {
2233                 BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_PRINTK, 0, 0, "Can't Allocate memory for Flash 1.x");
2234                 return -ENOMEM;
2235         }
2236
2237         psAdapter->psFlash2xCSInfo = (struct bcm_flash2x_cs_info *)kzalloc(sizeof(struct bcm_flash2x_cs_info), GFP_KERNEL);
2238         if (!psAdapter->psFlash2xCSInfo) {
2239                 BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_PRINTK, 0, 0, "Can't Allocate memory for Flash 2.x");
2240                 kfree(psAdapter->psFlashCSInfo);
2241                 return -ENOMEM;
2242         }
2243
2244         psAdapter->psFlash2xVendorInfo = (struct bcm_flash2x_vendor_info *)kzalloc(sizeof(struct bcm_flash2x_vendor_info), GFP_KERNEL);
2245         if (!psAdapter->psFlash2xVendorInfo) {
2246                 BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_PRINTK, 0, 0, "Can't Allocate Vendor Info Memory for Flash 2.x");
2247                 kfree(psAdapter->psFlashCSInfo);
2248                 kfree(psAdapter->psFlash2xCSInfo);
2249                 return -ENOMEM;
2250         }
2251
2252         return STATUS_SUCCESS;
2253 }
2254
2255 int BcmDeAllocFlashCSStructure(struct bcm_mini_adapter *psAdapter)
2256 {
2257         if (!psAdapter) {
2258                 BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_PRINTK, 0, 0, "Adapter structure point is NULL");
2259                 return -EINVAL;
2260         }
2261         kfree(psAdapter->psFlashCSInfo);
2262         kfree(psAdapter->psFlash2xCSInfo);
2263         kfree(psAdapter->psFlash2xVendorInfo);
2264         return STATUS_SUCCESS;
2265 }
2266
2267 static int BcmDumpFlash2XCSStructure(struct bcm_flash2x_cs_info *psFlash2xCSInfo, struct bcm_mini_adapter *Adapter)
2268 {
2269         unsigned int Index = 0;
2270
2271         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "**********************FLASH2X CS Structure *******************");
2272         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Signature is  :%x", (psFlash2xCSInfo->MagicNumber));
2273         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Flash Major Version :%d", MAJOR_VERSION(psFlash2xCSInfo->FlashLayoutVersion));
2274         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Flash Minor Version :%d", MINOR_VERSION(psFlash2xCSInfo->FlashLayoutVersion));
2275         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, " ISOImageMajorVersion:0x%x", (psFlash2xCSInfo->ISOImageVersion));
2276         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "SCSIFirmwareMajorVersion :0x%x", (psFlash2xCSInfo->SCSIFirmwareVersion));
2277         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForPart1ISOImage :0x%x", (psFlash2xCSInfo->OffsetFromZeroForPart1ISOImage));
2278         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForScsiFirmware :0x%x", (psFlash2xCSInfo->OffsetFromZeroForScsiFirmware));
2279         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "SizeOfScsiFirmware  :0x%x", (psFlash2xCSInfo->SizeOfScsiFirmware));
2280         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForPart2ISOImage :0x%x", (psFlash2xCSInfo->OffsetFromZeroForPart2ISOImage));
2281         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForDSDStart :0x%x", (psFlash2xCSInfo->OffsetFromZeroForDSDStart));
2282         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForDSDEnd :0x%x", (psFlash2xCSInfo->OffsetFromZeroForDSDEnd));
2283         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForVSAStart :0x%x", (psFlash2xCSInfo->OffsetFromZeroForVSAStart));
2284         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForVSAEnd :0x%x", (psFlash2xCSInfo->OffsetFromZeroForVSAEnd));
2285         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForControlSectionStart :0x%x", (psFlash2xCSInfo->OffsetFromZeroForControlSectionStart));
2286         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForControlSectionData :0x%x", (psFlash2xCSInfo->OffsetFromZeroForControlSectionData));
2287         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "CDLessInactivityTimeout :0x%x", (psFlash2xCSInfo->CDLessInactivityTimeout));
2288         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "NewImageSignature :0x%x", (psFlash2xCSInfo->NewImageSignature));
2289         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "FlashSectorSizeSig :0x%x", (psFlash2xCSInfo->FlashSectorSizeSig));
2290         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "FlashSectorSize :0x%x", (psFlash2xCSInfo->FlashSectorSize));
2291         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "FlashWriteSupportSize :0x%x", (psFlash2xCSInfo->FlashWriteSupportSize));
2292         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "TotalFlashSize :0x%X", (psFlash2xCSInfo->TotalFlashSize));
2293         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "FlashBaseAddr :0x%x", (psFlash2xCSInfo->FlashBaseAddr));
2294         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "FlashPartMaxSize :0x%x", (psFlash2xCSInfo->FlashPartMaxSize));
2295         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "IsCDLessDeviceBootSig :0x%x", (psFlash2xCSInfo->IsCDLessDeviceBootSig));
2296         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "MassStorageTimeout :0x%x", (psFlash2xCSInfo->MassStorageTimeout));
2297         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage1Part1Start :0x%x", (psFlash2xCSInfo->OffsetISOImage1Part1Start));
2298         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage1Part1End :0x%x", (psFlash2xCSInfo->OffsetISOImage1Part1End));
2299         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage1Part2Start :0x%x", (psFlash2xCSInfo->OffsetISOImage1Part2Start));
2300         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage1Part2End :0x%x", (psFlash2xCSInfo->OffsetISOImage1Part2End));
2301         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage1Part3Start :0x%x", (psFlash2xCSInfo->OffsetISOImage1Part3Start));
2302         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage1Part3End :0x%x", (psFlash2xCSInfo->OffsetISOImage1Part3End));
2303         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage2Part1Start :0x%x", (psFlash2xCSInfo->OffsetISOImage2Part1Start));
2304         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage2Part1End :0x%x", (psFlash2xCSInfo->OffsetISOImage2Part1End));
2305         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage2Part2Start :0x%x", (psFlash2xCSInfo->OffsetISOImage2Part2Start));
2306         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage2Part2End :0x%x", (psFlash2xCSInfo->OffsetISOImage2Part2End));
2307         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage2Part3Start :0x%x", (psFlash2xCSInfo->OffsetISOImage2Part3Start));
2308         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage2Part3End :0x%x", (psFlash2xCSInfo->OffsetISOImage2Part3End));
2309         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromDSDStartForDSDHeader :0x%x", (psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader));
2310         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForDSD1Start :0x%x", (psFlash2xCSInfo->OffsetFromZeroForDSD1Start));
2311         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForDSD1End :0x%x", (psFlash2xCSInfo->OffsetFromZeroForDSD1End));
2312         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForDSD2Start :0x%x", (psFlash2xCSInfo->OffsetFromZeroForDSD2Start));
2313         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForDSD2End :0x%x", (psFlash2xCSInfo->OffsetFromZeroForDSD2End));
2314         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForVSA1Start :0x%x", (psFlash2xCSInfo->OffsetFromZeroForVSA1Start));
2315         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForVSA1End :0x%x", (psFlash2xCSInfo->OffsetFromZeroForVSA1End));
2316         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForVSA2Start :0x%x", (psFlash2xCSInfo->OffsetFromZeroForVSA2Start));
2317         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForVSA2End :0x%x", (psFlash2xCSInfo->OffsetFromZeroForVSA2End));
2318         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Sector Access Bit Map is Defined as :");
2319
2320         for (Index = 0; Index < (FLASH2X_TOTAL_SIZE / (DEFAULT_SECTOR_SIZE * 16)); Index++)
2321                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "SectorAccessBitMap[%d] :0x%x", Index,
2322                                 (psFlash2xCSInfo->SectorAccessBitMap[Index]));
2323
2324         return STATUS_SUCCESS;
2325 }
2326
2327 static int ConvertEndianOf2XCSStructure(struct bcm_flash2x_cs_info *psFlash2xCSInfo)
2328 {
2329         unsigned int Index = 0;
2330
2331         psFlash2xCSInfo->MagicNumber = ntohl(psFlash2xCSInfo->MagicNumber);
2332         psFlash2xCSInfo->FlashLayoutVersion = ntohl(psFlash2xCSInfo->FlashLayoutVersion);
2333         /* psFlash2xCSInfo->FlashLayoutMinorVersion = ntohs(psFlash2xCSInfo->FlashLayoutMinorVersion); */
2334         psFlash2xCSInfo->ISOImageVersion = ntohl(psFlash2xCSInfo->ISOImageVersion);
2335         psFlash2xCSInfo->SCSIFirmwareVersion = ntohl(psFlash2xCSInfo->SCSIFirmwareVersion);
2336         psFlash2xCSInfo->OffsetFromZeroForPart1ISOImage = ntohl(psFlash2xCSInfo->OffsetFromZeroForPart1ISOImage);
2337         psFlash2xCSInfo->OffsetFromZeroForScsiFirmware = ntohl(psFlash2xCSInfo->OffsetFromZeroForScsiFirmware);
2338         psFlash2xCSInfo->SizeOfScsiFirmware = ntohl(psFlash2xCSInfo->SizeOfScsiFirmware);
2339         psFlash2xCSInfo->OffsetFromZeroForPart2ISOImage = ntohl(psFlash2xCSInfo->OffsetFromZeroForPart2ISOImage);
2340         psFlash2xCSInfo->OffsetFromZeroForDSDStart = ntohl(psFlash2xCSInfo->OffsetFromZeroForDSDStart);
2341         psFlash2xCSInfo->OffsetFromZeroForDSDEnd = ntohl(psFlash2xCSInfo->OffsetFromZeroForDSDEnd);
2342         psFlash2xCSInfo->OffsetFromZeroForVSAStart = ntohl(psFlash2xCSInfo->OffsetFromZeroForVSAStart);
2343         psFlash2xCSInfo->OffsetFromZeroForVSAEnd = ntohl(psFlash2xCSInfo->OffsetFromZeroForVSAEnd);
2344         psFlash2xCSInfo->OffsetFromZeroForControlSectionStart = ntohl(psFlash2xCSInfo->OffsetFromZeroForControlSectionStart);
2345         psFlash2xCSInfo->OffsetFromZeroForControlSectionData = ntohl(psFlash2xCSInfo->OffsetFromZeroForControlSectionData);
2346         psFlash2xCSInfo->CDLessInactivityTimeout = ntohl(psFlash2xCSInfo->CDLessInactivityTimeout);
2347         psFlash2xCSInfo->NewImageSignature = ntohl(psFlash2xCSInfo->NewImageSignature);
2348         psFlash2xCSInfo->FlashSectorSizeSig = ntohl(psFlash2xCSInfo->FlashSectorSizeSig);
2349         psFlash2xCSInfo->FlashSectorSize = ntohl(psFlash2xCSInfo->FlashSectorSize);
2350         psFlash2xCSInfo->FlashWriteSupportSize = ntohl(psFlash2xCSInfo->FlashWriteSupportSize);
2351         psFlash2xCSInfo->TotalFlashSize = ntohl(psFlash2xCSInfo->TotalFlashSize);
2352         psFlash2xCSInfo->FlashBaseAddr = ntohl(psFlash2xCSInfo->FlashBaseAddr);
2353         psFlash2xCSInfo->FlashPartMaxSize = ntohl(psFlash2xCSInfo->FlashPartMaxSize);
2354         psFlash2xCSInfo->IsCDLessDeviceBootSig = ntohl(psFlash2xCSInfo->IsCDLessDeviceBootSig);
2355         psFlash2xCSInfo->MassStorageTimeout = ntohl(psFlash2xCSInfo->MassStorageTimeout);
2356         psFlash2xCSInfo->OffsetISOImage1Part1Start = ntohl(psFlash2xCSInfo->OffsetISOImage1Part1Start);
2357         psFlash2xCSInfo->OffsetISOImage1Part1End = ntohl(psFlash2xCSInfo->OffsetISOImage1Part1End);
2358         psFlash2xCSInfo->OffsetISOImage1Part2Start = ntohl(psFlash2xCSInfo->OffsetISOImage1Part2Start);
2359         psFlash2xCSInfo->OffsetISOImage1Part2End = ntohl(psFlash2xCSInfo->OffsetISOImage1Part2End);
2360         psFlash2xCSInfo->OffsetISOImage1Part3Start = ntohl(psFlash2xCSInfo->OffsetISOImage1Part3Start);
2361         psFlash2xCSInfo->OffsetISOImage1Part3End = ntohl(psFlash2xCSInfo->OffsetISOImage1Part3End);
2362         psFlash2xCSInfo->OffsetISOImage2Part1Start = ntohl(psFlash2xCSInfo->OffsetISOImage2Part1Start);
2363         psFlash2xCSInfo->OffsetISOImage2Part1End = ntohl(psFlash2xCSInfo->OffsetISOImage2Part1End);
2364         psFlash2xCSInfo->OffsetISOImage2Part2Start = ntohl(psFlash2xCSInfo->OffsetISOImage2Part2Start);
2365         psFlash2xCSInfo->OffsetISOImage2Part2End = ntohl(psFlash2xCSInfo->OffsetISOImage2Part2End);
2366         psFlash2xCSInfo->OffsetISOImage2Part3Start = ntohl(psFlash2xCSInfo->OffsetISOImage2Part3Start);
2367         psFlash2xCSInfo->OffsetISOImage2Part3End = ntohl(psFlash2xCSInfo->OffsetISOImage2Part3End);
2368         psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader = ntohl(psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader);
2369         psFlash2xCSInfo->OffsetFromZeroForDSD1Start = ntohl(psFlash2xCSInfo->OffsetFromZeroForDSD1Start);
2370         psFlash2xCSInfo->OffsetFromZeroForDSD1End = ntohl(psFlash2xCSInfo->OffsetFromZeroForDSD1End);
2371         psFlash2xCSInfo->OffsetFromZeroForDSD2Start = ntohl(psFlash2xCSInfo->OffsetFromZeroForDSD2Start);
2372         psFlash2xCSInfo->OffsetFromZeroForDSD2End = ntohl(psFlash2xCSInfo->OffsetFromZeroForDSD2End);
2373         psFlash2xCSInfo->OffsetFromZeroForVSA1Start = ntohl(psFlash2xCSInfo->OffsetFromZeroForVSA1Start);
2374         psFlash2xCSInfo->OffsetFromZeroForVSA1End = ntohl(psFlash2xCSInfo->OffsetFromZeroForVSA1End);
2375         psFlash2xCSInfo->OffsetFromZeroForVSA2Start = ntohl(psFlash2xCSInfo->OffsetFromZeroForVSA2Start);
2376         psFlash2xCSInfo->OffsetFromZeroForVSA2End = ntohl(psFlash2xCSInfo->OffsetFromZeroForVSA2End);
2377
2378         for (Index = 0; Index < (FLASH2X_TOTAL_SIZE / (DEFAULT_SECTOR_SIZE * 16)); Index++)
2379                 psFlash2xCSInfo->SectorAccessBitMap[Index] = ntohl(psFlash2xCSInfo->SectorAccessBitMap[Index]);
2380
2381         return STATUS_SUCCESS;
2382 }
2383
2384 static int ConvertEndianOfCSStructure(struct bcm_flash_cs_info *psFlashCSInfo)
2385 {
2386         /* unsigned int Index = 0; */
2387         psFlashCSInfo->MagicNumber                              = ntohl(psFlashCSInfo->MagicNumber);
2388         psFlashCSInfo->FlashLayoutVersion                       = ntohl(psFlashCSInfo->FlashLayoutVersion);
2389         psFlashCSInfo->ISOImageVersion                          = ntohl(psFlashCSInfo->ISOImageVersion);
2390         /* won't convert according to old assumption */
2391         psFlashCSInfo->SCSIFirmwareVersion                      = (psFlashCSInfo->SCSIFirmwareVersion);
2392         psFlashCSInfo->OffsetFromZeroForPart1ISOImage           = ntohl(psFlashCSInfo->OffsetFromZeroForPart1ISOImage);
2393         psFlashCSInfo->OffsetFromZeroForScsiFirmware            = ntohl(psFlashCSInfo->OffsetFromZeroForScsiFirmware);
2394         psFlashCSInfo->SizeOfScsiFirmware                       = ntohl(psFlashCSInfo->SizeOfScsiFirmware);
2395         psFlashCSInfo->OffsetFromZeroForPart2ISOImage           = ntohl(psFlashCSInfo->OffsetFromZeroForPart2ISOImage);
2396         psFlashCSInfo->OffsetFromZeroForCalibrationStart        = ntohl(psFlashCSInfo->OffsetFromZeroForCalibrationStart);
2397         psFlashCSInfo->OffsetFromZeroForCalibrationEnd          = ntohl(psFlashCSInfo->OffsetFromZeroForCalibrationEnd);
2398         psFlashCSInfo->OffsetFromZeroForVSAStart                = ntohl(psFlashCSInfo->OffsetFromZeroForVSAStart);
2399         psFlashCSInfo->OffsetFromZeroForVSAEnd                  = ntohl(psFlashCSInfo->OffsetFromZeroForVSAEnd);
2400         psFlashCSInfo->OffsetFromZeroForControlSectionStart     = ntohl(psFlashCSInfo->OffsetFromZeroForControlSectionStart);
2401         psFlashCSInfo->OffsetFromZeroForControlSectionData      = ntohl(psFlashCSInfo->OffsetFromZeroForControlSectionData);
2402         psFlashCSInfo->CDLessInactivityTimeout                  = ntohl(psFlashCSInfo->CDLessInactivityTimeout);
2403         psFlashCSInfo->NewImageSignature                        = ntohl(psFlashCSInfo->NewImageSignature);
2404         psFlashCSInfo->FlashSectorSizeSig                       = ntohl(psFlashCSInfo->FlashSectorSizeSig);
2405         psFlashCSInfo->FlashSectorSize                          = ntohl(psFlashCSInfo->FlashSectorSize);
2406         psFlashCSInfo->FlashWriteSupportSize                    = ntohl(psFlashCSInfo->FlashWriteSupportSize);
2407         psFlashCSInfo->TotalFlashSize                           = ntohl(psFlashCSInfo->TotalFlashSize);
2408         psFlashCSInfo->FlashBaseAddr                            = ntohl(psFlashCSInfo->FlashBaseAddr);
2409         psFlashCSInfo->FlashPartMaxSize                         = ntohl(psFlashCSInfo->FlashPartMaxSize);
2410         psFlashCSInfo->IsCDLessDeviceBootSig                    = ntohl(psFlashCSInfo->IsCDLessDeviceBootSig);
2411         psFlashCSInfo->MassStorageTimeout                       = ntohl(psFlashCSInfo->MassStorageTimeout);
2412
2413         return STATUS_SUCCESS;
2414 }
2415
2416 static int IsSectionExistInVendorInfo(struct bcm_mini_adapter *Adapter, enum bcm_flash2x_section_val section)
2417 {
2418         return (Adapter->uiVendorExtnFlag &&
2419                 (Adapter->psFlash2xVendorInfo->VendorSection[section].AccessFlags & FLASH2X_SECTION_PRESENT) &&
2420                 (Adapter->psFlash2xVendorInfo->VendorSection[section].OffsetFromZeroForSectionStart != UNINIT_PTR_IN_CS));
2421 }
2422
2423 static VOID UpdateVendorInfo(struct bcm_mini_adapter *Adapter)
2424 {
2425         B_UINT32 i = 0;
2426         unsigned int uiSizeSection = 0;
2427
2428         Adapter->uiVendorExtnFlag = FALSE;
2429
2430         for (i = 0; i < TOTAL_SECTIONS; i++)
2431                 Adapter->psFlash2xVendorInfo->VendorSection[i].OffsetFromZeroForSectionStart = UNINIT_PTR_IN_CS;
2432
2433         if (STATUS_SUCCESS != vendorextnGetSectionInfo(Adapter, Adapter->psFlash2xVendorInfo))
2434                 return;
2435
2436         i = 0;
2437         while (i < TOTAL_SECTIONS) {
2438                 if (!(Adapter->psFlash2xVendorInfo->VendorSection[i].AccessFlags & FLASH2X_SECTION_PRESENT)) {
2439                         i++;
2440                         continue;
2441                 }
2442
2443                 Adapter->uiVendorExtnFlag = TRUE;
2444                 uiSizeSection = (Adapter->psFlash2xVendorInfo->VendorSection[i].OffsetFromZeroForSectionEnd -
2445                                 Adapter->psFlash2xVendorInfo->VendorSection[i].OffsetFromZeroForSectionStart);
2446
2447                 switch (i) {
2448                 case DSD0:
2449                         if ((uiSizeSection >= (Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader + sizeof(struct bcm_dsd_header))) &&
2450                                 (UNINIT_PTR_IN_CS != Adapter->psFlash2xVendorInfo->VendorSection[i].OffsetFromZeroForSectionStart))
2451                                 Adapter->psFlash2xCSInfo->OffsetFromZeroForDSDStart = Adapter->psFlash2xCSInfo->OffsetFromZeroForDSDEnd = VENDOR_PTR_IN_CS;
2452                         else
2453                                 Adapter->psFlash2xCSInfo->OffsetFromZeroForDSDStart = Adapter->psFlash2xCSInfo->OffsetFromZeroForDSDEnd = UNINIT_PTR_IN_CS;
2454                         break;
2455
2456                 case DSD1:
2457                         if ((uiSizeSection >= (Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader + sizeof(struct bcm_dsd_header))) &&
2458                                 (UNINIT_PTR_IN_CS != Adapter->psFlash2xVendorInfo->VendorSection[i].OffsetFromZeroForSectionStart))
2459                                 Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD1Start = Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD1End = VENDOR_PTR_IN_CS;
2460                         else
2461                                 Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD1Start = Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD1End = UNINIT_PTR_IN_CS;
2462                         break;
2463
2464                 case DSD2:
2465                         if ((uiSizeSection >= (Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader + sizeof(struct bcm_dsd_header))) &&
2466                                 (UNINIT_PTR_IN_CS != Adapter->psFlash2xVendorInfo->VendorSection[i].OffsetFromZeroForSectionStart))
2467                                 Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD2Start = Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD2End = VENDOR_PTR_IN_CS;
2468                         else
2469                                 Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD2Start = Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD2End = UNINIT_PTR_IN_CS;
2470                         break;
2471                 case VSA0:
2472                         if (UNINIT_PTR_IN_CS != Adapter->psFlash2xVendorInfo->VendorSection[i].OffsetFromZeroForSectionStart)
2473                                 Adapter->psFlash2xCSInfo->OffsetFromZeroForVSAStart = Adapter->psFlash2xCSInfo->OffsetFromZeroForVSAEnd = VENDOR_PTR_IN_CS;
2474                         else
2475                                 Adapter->psFlash2xCSInfo->OffsetFromZeroForVSAStart = Adapter->psFlash2xCSInfo->OffsetFromZeroForVSAEnd = UNINIT_PTR_IN_CS;
2476                         break;
2477
2478                 case VSA1:
2479                         if (UNINIT_PTR_IN_CS != Adapter->psFlash2xVendorInfo->VendorSection[i].OffsetFromZeroForSectionStart)
2480                                 Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA1Start = Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA1End = VENDOR_PTR_IN_CS;
2481                         else
2482                                 Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA1Start = Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA1End = UNINIT_PTR_IN_CS;
2483                         break;
2484                 case VSA2:
2485                         if (UNINIT_PTR_IN_CS != Adapter->psFlash2xVendorInfo->VendorSection[i].OffsetFromZeroForSectionStart)
2486                                 Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA2Start = Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA2End = VENDOR_PTR_IN_CS;
2487                         else
2488                                 Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA2Start = Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA2End = UNINIT_PTR_IN_CS;
2489                         break;
2490
2491                 default:
2492                         break;
2493                 }
2494                 i++;
2495         }
2496 }
2497
2498 /*
2499  * Procedure:   BcmGetFlashCSInfo
2500  *
2501  * Description: Reads control structure and gets Cal section addresses.
2502  *
2503  * Arguments:
2504  *              Adapter    - ptr to Adapter object instance
2505  *
2506  * Returns:
2507  *              <VOID>
2508  */
2509
2510 static int BcmGetFlashCSInfo(struct bcm_mini_adapter *Adapter)
2511 {
2512         /* struct bcm_flash_cs_info sFlashCsInfo = {0}; */
2513
2514         #if !defined(BCM_SHM_INTERFACE) || defined(FLASH_DIRECT_ACCESS)
2515                 unsigned int value;
2516         #endif
2517
2518         unsigned int uiFlashLayoutMajorVersion;
2519         Adapter->uiFlashLayoutMinorVersion = 0;
2520         Adapter->uiFlashLayoutMajorVersion = 0;
2521         Adapter->ulFlashControlSectionStart = FLASH_CS_INFO_START_ADDR;
2522
2523         Adapter->uiFlashBaseAdd = 0;
2524         Adapter->ulFlashCalStart = 0;
2525         memset(Adapter->psFlashCSInfo, 0 , sizeof(struct bcm_flash_cs_info));
2526         memset(Adapter->psFlash2xCSInfo, 0 , sizeof(struct bcm_flash2x_cs_info));
2527
2528         if (!Adapter->bDDRInitDone) {
2529                 value = FLASH_CONTIGIOUS_START_ADDR_BEFORE_INIT;
2530                 wrmalt(Adapter, 0xAF00A080, &value, sizeof(value));
2531         }
2532
2533         /* Reading first 8 Bytes to get the Flash Layout
2534          * MagicNumber(4 bytes) +FlashLayoutMinorVersion(2 Bytes) +FlashLayoutMajorVersion(2 Bytes)
2535          */
2536         BeceemFlashBulkRead(Adapter, (PUINT)Adapter->psFlashCSInfo, Adapter->ulFlashControlSectionStart, 8);
2537
2538         Adapter->psFlashCSInfo->FlashLayoutVersion =  ntohl(Adapter->psFlashCSInfo->FlashLayoutVersion);
2539         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Flash Layout Version :%X", (Adapter->psFlashCSInfo->FlashLayoutVersion));
2540         /* BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Flash Layout Minor Version :%d\n", ntohs(sFlashCsInfo.FlashLayoutMinorVersion)); */
2541         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Signature is  :%x\n", ntohl(Adapter->psFlashCSInfo->MagicNumber));
2542
2543         if (FLASH_CONTROL_STRUCT_SIGNATURE == ntohl(Adapter->psFlashCSInfo->MagicNumber)) {
2544                 uiFlashLayoutMajorVersion = MAJOR_VERSION((Adapter->psFlashCSInfo->FlashLayoutVersion));
2545                 Adapter->uiFlashLayoutMinorVersion = MINOR_VERSION((Adapter->psFlashCSInfo->FlashLayoutVersion));
2546         } else {
2547                 Adapter->uiFlashLayoutMinorVersion = 0;
2548                 uiFlashLayoutMajorVersion = 0;
2549         }
2550
2551         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "FLASH LAYOUT MAJOR VERSION :%X", uiFlashLayoutMajorVersion);
2552
2553         if (uiFlashLayoutMajorVersion < FLASH_2X_MAJOR_NUMBER) {
2554                 BeceemFlashBulkRead(Adapter, (PUINT)Adapter->psFlashCSInfo, Adapter->ulFlashControlSectionStart, sizeof(struct bcm_flash_cs_info));
2555                 ConvertEndianOfCSStructure(Adapter->psFlashCSInfo);
2556                 Adapter->ulFlashCalStart = (Adapter->psFlashCSInfo->OffsetFromZeroForCalibrationStart);
2557
2558                 if (!((Adapter->uiFlashLayoutMajorVersion == 1) && (Adapter->uiFlashLayoutMinorVersion == 1)))
2559                         Adapter->ulFlashControlSectionStart = Adapter->psFlashCSInfo->OffsetFromZeroForControlSectionStart;
2560
2561                 if ((FLASH_CONTROL_STRUCT_SIGNATURE == (Adapter->psFlashCSInfo->MagicNumber)) &&
2562                         (SCSI_FIRMWARE_MINOR_VERSION <= MINOR_VERSION(Adapter->psFlashCSInfo->SCSIFirmwareVersion)) &&
2563                         (FLASH_SECTOR_SIZE_SIG == (Adapter->psFlashCSInfo->FlashSectorSizeSig)) &&
2564                         (BYTE_WRITE_SUPPORT == (Adapter->psFlashCSInfo->FlashWriteSupportSize))) {
2565                         Adapter->ulFlashWriteSize = (Adapter->psFlashCSInfo->FlashWriteSupportSize);
2566                         Adapter->fpFlashWrite = flashByteWrite;
2567                         Adapter->fpFlashWriteWithStatusCheck = flashByteWriteStatus;
2568                 } else {
2569                         Adapter->ulFlashWriteSize = MAX_RW_SIZE;
2570                         Adapter->fpFlashWrite = flashWrite;
2571                         Adapter->fpFlashWriteWithStatusCheck = flashWriteStatus;
2572                 }
2573
2574                 BcmGetFlashSectorSize(Adapter, (Adapter->psFlashCSInfo->FlashSectorSizeSig),
2575                                 (Adapter->psFlashCSInfo->FlashSectorSize));
2576                 Adapter->uiFlashBaseAdd = Adapter->psFlashCSInfo->FlashBaseAddr & 0xFCFFFFFF;
2577         } else {
2578                 if (BcmFlash2xBulkRead(Adapter, (PUINT)Adapter->psFlash2xCSInfo, NO_SECTION_VAL,
2579                                         Adapter->ulFlashControlSectionStart, sizeof(struct bcm_flash2x_cs_info))) {
2580                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Unable to read CS structure\n");
2581                         return STATUS_FAILURE;
2582                 }
2583
2584                 ConvertEndianOf2XCSStructure(Adapter->psFlash2xCSInfo);
2585                 BcmDumpFlash2XCSStructure(Adapter->psFlash2xCSInfo, Adapter);
2586                 if ((FLASH_CONTROL_STRUCT_SIGNATURE == Adapter->psFlash2xCSInfo->MagicNumber) &&
2587                         (SCSI_FIRMWARE_MINOR_VERSION <= MINOR_VERSION(Adapter->psFlash2xCSInfo->SCSIFirmwareVersion)) &&
2588                         (FLASH_SECTOR_SIZE_SIG == Adapter->psFlash2xCSInfo->FlashSectorSizeSig) &&
2589                         (BYTE_WRITE_SUPPORT == Adapter->psFlash2xCSInfo->FlashWriteSupportSize)) {
2590                         Adapter->ulFlashWriteSize = Adapter->psFlash2xCSInfo->FlashWriteSupportSize;
2591                         Adapter->fpFlashWrite = flashByteWrite;
2592                         Adapter->fpFlashWriteWithStatusCheck = flashByteWriteStatus;
2593                 } else {
2594                         Adapter->ulFlashWriteSize = MAX_RW_SIZE;
2595                         Adapter->fpFlashWrite = flashWrite;
2596                         Adapter->fpFlashWriteWithStatusCheck = flashWriteStatus;
2597                 }
2598
2599                 BcmGetFlashSectorSize(Adapter, Adapter->psFlash2xCSInfo->FlashSectorSizeSig,
2600                                 Adapter->psFlash2xCSInfo->FlashSectorSize);
2601
2602                 UpdateVendorInfo(Adapter);
2603
2604                 BcmGetActiveDSD(Adapter);
2605                 BcmGetActiveISO(Adapter);
2606                 Adapter->uiFlashBaseAdd = Adapter->psFlash2xCSInfo->FlashBaseAddr & 0xFCFFFFFF;
2607                 Adapter->ulFlashControlSectionStart = Adapter->psFlash2xCSInfo->OffsetFromZeroForControlSectionStart;
2608         }
2609         /*
2610          * Concerns: what if CS sector size does not match with this sector size ???
2611          * what is the indication of AccessBitMap  in CS in flash 2.x ????
2612          */
2613         Adapter->ulFlashID = BcmReadFlashRDID(Adapter);
2614         Adapter->uiFlashLayoutMajorVersion = uiFlashLayoutMajorVersion;
2615
2616         return STATUS_SUCCESS;
2617 }
2618
2619 /*
2620  * Procedure:   BcmGetNvmType
2621  *
2622  * Description: Finds the type of NVM used.
2623  *
2624  * Arguments:
2625  *              Adapter    - ptr to Adapter object instance
2626  *
2627  * Returns:
2628  *              NVM_TYPE
2629  *
2630  */
2631
2632 static enum bcm_nvm_type BcmGetNvmType(struct bcm_mini_adapter *Adapter)
2633 {
2634         unsigned int uiData = 0;
2635
2636         BeceemEEPROMBulkRead(Adapter, &uiData, 0x0, 4);
2637         if (uiData == BECM)
2638                 return NVM_EEPROM;
2639
2640         /*
2641          * Read control struct and get cal addresses before accessing the flash
2642          */
2643         BcmGetFlashCSInfo(Adapter);
2644
2645         BeceemFlashBulkRead(Adapter, &uiData, 0x0 + Adapter->ulFlashCalStart, 4);
2646         if (uiData == BECM)
2647                 return NVM_FLASH;
2648
2649         /*
2650          * even if there is no valid signature on EEPROM/FLASH find out if they really exist.
2651          * if exist select it.
2652          */
2653         if (BcmGetEEPROMSize(Adapter))
2654                 return NVM_EEPROM;
2655
2656         /* TBD for Flash. */
2657         return NVM_UNKNOWN;
2658 }
2659
2660 /*
2661  * BcmGetSectionValStartOffset - this will calculate the section's starting offset if section val is given
2662  * @Adapter : Drivers Private Data structure
2663  * @eFlashSectionVal : Flash secion value defined in enum bcm_flash2x_section_val
2664  *
2665  * Return value:-
2666  * On success it return the start offset of the provided section val
2667  * On Failure -returns STATUS_FAILURE
2668  */
2669
2670 int BcmGetSectionValStartOffset(struct bcm_mini_adapter *Adapter, enum bcm_flash2x_section_val eFlashSectionVal)
2671 {
2672         /*
2673          * Considering all the section for which end offset can be calculated or directly given
2674          * in CS Structure. if matching case does not exist, return STATUS_FAILURE indicating section
2675          * endoffset can't be calculated or given in CS Structure.
2676          */
2677
2678         int SectStartOffset = 0;
2679
2680         SectStartOffset = INVALID_OFFSET;
2681
2682         if (IsSectionExistInVendorInfo(Adapter, eFlashSectionVal))
2683                 return Adapter->psFlash2xVendorInfo->VendorSection[eFlashSectionVal].OffsetFromZeroForSectionStart;
2684
2685         switch (eFlashSectionVal) {
2686         case ISO_IMAGE1:
2687                 if ((Adapter->psFlash2xCSInfo->OffsetISOImage1Part1Start != UNINIT_PTR_IN_CS) &&
2688                         (IsNonCDLessDevice(Adapter) == FALSE))
2689                         SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage1Part1Start);
2690                 break;
2691         case ISO_IMAGE2:
2692                 if ((Adapter->psFlash2xCSInfo->OffsetISOImage2Part1Start != UNINIT_PTR_IN_CS) &&
2693                         (IsNonCDLessDevice(Adapter) == FALSE))
2694                         SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage2Part1Start);
2695                 break;
2696         case DSD0:
2697                 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSDStart != UNINIT_PTR_IN_CS)
2698                         SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSDStart);
2699                 break;
2700         case DSD1:
2701                 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD1Start != UNINIT_PTR_IN_CS)
2702                         SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD1Start);
2703                 break;
2704         case DSD2:
2705                 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD2Start != UNINIT_PTR_IN_CS)
2706                         SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD2Start);
2707                 break;
2708         case VSA0:
2709                 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSAStart != UNINIT_PTR_IN_CS)
2710                         SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSAStart);
2711                 break;
2712         case VSA1:
2713                 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA1Start != UNINIT_PTR_IN_CS)
2714                         SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA1Start);
2715                 break;
2716         case VSA2:
2717                 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA2Start != UNINIT_PTR_IN_CS)
2718                         SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA2Start);
2719                 break;
2720         case SCSI:
2721                 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForScsiFirmware != UNINIT_PTR_IN_CS)
2722                         SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForScsiFirmware);
2723                 break;
2724         case CONTROL_SECTION:
2725                 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForControlSectionStart != UNINIT_PTR_IN_CS)
2726                         SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForControlSectionStart);
2727                 break;
2728         case ISO_IMAGE1_PART2:
2729                 if (Adapter->psFlash2xCSInfo->OffsetISOImage1Part2Start != UNINIT_PTR_IN_CS)
2730                         SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage1Part2Start);
2731                 break;
2732         case ISO_IMAGE1_PART3:
2733                 if (Adapter->psFlash2xCSInfo->OffsetISOImage1Part3Start != UNINIT_PTR_IN_CS)
2734                         SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage1Part3Start);
2735                 break;
2736         case ISO_IMAGE2_PART2:
2737                 if (Adapter->psFlash2xCSInfo->OffsetISOImage2Part2Start != UNINIT_PTR_IN_CS)
2738                         SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage2Part2Start);
2739                 break;
2740         case ISO_IMAGE2_PART3:
2741                 if (Adapter->psFlash2xCSInfo->OffsetISOImage2Part3Start != UNINIT_PTR_IN_CS)
2742                         SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage2Part3Start);
2743                 break;
2744         default:
2745                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Section Does not exist in Flash 2.x");
2746                 SectStartOffset = INVALID_OFFSET;
2747         }
2748
2749         return SectStartOffset;
2750 }
2751
2752 /*
2753  * BcmGetSectionValEndOffset - this will calculate the section's Ending offset if section val is given
2754  * @Adapter : Drivers Private Data structure
2755  * @eFlashSectionVal : Flash secion value defined in enum bcm_flash2x_section_val
2756  *
2757  * Return value:-
2758  * On success it return the end offset of the provided section val
2759  * On Failure -returns STATUS_FAILURE
2760  */
2761
2762 int BcmGetSectionValEndOffset(struct bcm_mini_adapter *Adapter, enum bcm_flash2x_section_val eFlash2xSectionVal)
2763 {
2764         int SectEndOffset = 0;
2765
2766         SectEndOffset = INVALID_OFFSET;
2767         if (IsSectionExistInVendorInfo(Adapter, eFlash2xSectionVal))
2768                 return Adapter->psFlash2xVendorInfo->VendorSection[eFlash2xSectionVal].OffsetFromZeroForSectionEnd;
2769
2770         switch (eFlash2xSectionVal) {
2771         case ISO_IMAGE1:
2772                 if ((Adapter->psFlash2xCSInfo->OffsetISOImage1Part1End != UNINIT_PTR_IN_CS) &&
2773                         (IsNonCDLessDevice(Adapter) == FALSE))
2774                         SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage1Part1End);
2775                 break;
2776         case ISO_IMAGE2:
2777                 if ((Adapter->psFlash2xCSInfo->OffsetISOImage2Part1End != UNINIT_PTR_IN_CS) &&
2778                         (IsNonCDLessDevice(Adapter) == FALSE))
2779                         SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage2Part1End);
2780                 break;
2781         case DSD0:
2782                 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSDEnd != UNINIT_PTR_IN_CS)
2783                         SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSDEnd);
2784                 break;
2785         case DSD1:
2786                 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD1End != UNINIT_PTR_IN_CS)
2787                         SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD1End);
2788                 break;
2789         case DSD2:
2790                 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD2End != UNINIT_PTR_IN_CS)
2791                         SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD2End);
2792                 break;
2793         case VSA0:
2794                 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSAEnd != UNINIT_PTR_IN_CS)
2795                         SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSAEnd);
2796                 break;
2797         case VSA1:
2798                 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA1End != UNINIT_PTR_IN_CS)
2799                         SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA1End);
2800                 break;
2801         case VSA2:
2802                 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA2End != UNINIT_PTR_IN_CS)
2803                         SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA2End);
2804                 break;
2805         case SCSI:
2806                 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForScsiFirmware != UNINIT_PTR_IN_CS)
2807                         SectEndOffset = ((Adapter->psFlash2xCSInfo->OffsetFromZeroForScsiFirmware) +
2808                                         (Adapter->psFlash2xCSInfo->SizeOfScsiFirmware));
2809                 break;
2810         case CONTROL_SECTION:
2811                 /* Not Clear So Putting failure. confirm and fix it. */
2812                 SectEndOffset = STATUS_FAILURE;
2813                 break;
2814         case ISO_IMAGE1_PART2:
2815                 if (Adapter->psFlash2xCSInfo->OffsetISOImage1Part2End != UNINIT_PTR_IN_CS)
2816                         SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage1Part2End);
2817                 break;
2818         case ISO_IMAGE1_PART3:
2819                 if (Adapter->psFlash2xCSInfo->OffsetISOImage1Part3End != UNINIT_PTR_IN_CS)
2820                         SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage1Part3End);
2821                 break;
2822         case ISO_IMAGE2_PART2:
2823                 if (Adapter->psFlash2xCSInfo->OffsetISOImage2Part2End != UNINIT_PTR_IN_CS)
2824                         SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage2Part2End);
2825                 break;
2826         case ISO_IMAGE2_PART3:
2827                 if (Adapter->psFlash2xCSInfo->OffsetISOImage2Part3End != UNINIT_PTR_IN_CS)
2828                         SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage2Part3End);
2829                 break;
2830         default:
2831                 SectEndOffset = INVALID_OFFSET;
2832         }
2833
2834         return SectEndOffset ;
2835 }
2836
2837 /*
2838  * BcmFlash2xBulkRead:- Read API for Flash Map 2.x .
2839  * @Adapter :Driver Private Data Structure
2840  * @pBuffer : Buffer where data has to be put after reading
2841  * @eFlashSectionVal :Flash Section Val defined in enum bcm_flash2x_section_val
2842  * @uiOffsetWithinSectionVal :- Offset with in provided section
2843  * @uiNumBytes : Number of Bytes for Read
2844  *
2845  * Return value:-
2846  * return true on success and STATUS_FAILURE on fail.
2847  */
2848
2849 int BcmFlash2xBulkRead(struct bcm_mini_adapter *Adapter,
2850                 PUINT pBuffer,
2851                 enum bcm_flash2x_section_val eFlash2xSectionVal,
2852                 unsigned int uiOffsetWithinSectionVal,
2853                 unsigned int uiNumBytes)
2854 {
2855         int Status = STATUS_SUCCESS;
2856         int SectionStartOffset = 0;
2857         unsigned int uiAbsoluteOffset = 0;
2858         unsigned int uiTemp = 0, value = 0;
2859
2860         if (!Adapter) {
2861                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Adapter structure is NULL");
2862                 return -EINVAL;
2863         }
2864         if (Adapter->device_removed) {
2865                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Device has been removed");
2866                 return -ENODEV;
2867         }
2868
2869         /* NO_SECTION_VAL means absolute offset is given. */
2870         if (eFlash2xSectionVal == NO_SECTION_VAL)
2871                 SectionStartOffset = 0;
2872         else
2873                 SectionStartOffset = BcmGetSectionValStartOffset(Adapter, eFlash2xSectionVal);
2874
2875         if (SectionStartOffset == STATUS_FAILURE) {
2876                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "This Section<%d> does not exixt in Flash 2.x Map ", eFlash2xSectionVal);
2877                 return -EINVAL;
2878         }
2879
2880         if (IsSectionExistInVendorInfo(Adapter, eFlash2xSectionVal))
2881                 return vendorextnReadSection(Adapter, (PUCHAR)pBuffer, eFlash2xSectionVal, uiOffsetWithinSectionVal, uiNumBytes);
2882
2883         /* calculating  the absolute offset from FLASH; */
2884         uiAbsoluteOffset = uiOffsetWithinSectionVal + SectionStartOffset;
2885         rdmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
2886         value = 0;
2887         wrmalt(Adapter, 0x0f000C80, &value, sizeof(value));
2888         Status = BeceemFlashBulkRead(Adapter, pBuffer, uiAbsoluteOffset, uiNumBytes);
2889         wrmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
2890         if (Status) {
2891                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Flash Read Failed with Status :%d", Status);
2892                 return Status;
2893         }
2894
2895         return Status;
2896 }
2897
2898 /*
2899  * BcmFlash2xBulkWrite :-API for Writing on the Flash Map 2.x.
2900  * @Adapter :Driver Private Data Structure
2901  * @pBuffer : Buffer From where data has to taken for writing
2902  * @eFlashSectionVal :Flash Section Val defined in enum bcm_flash2x_section_val
2903  * @uiOffsetWithinSectionVal :- Offset with in provided section
2904  * @uiNumBytes : Number of Bytes for Write
2905  *
2906  * Return value:-
2907  * return true on success and STATUS_FAILURE on fail.
2908  *
2909  */
2910
2911 int BcmFlash2xBulkWrite(struct bcm_mini_adapter *Adapter,
2912                         PUINT pBuffer,
2913                         enum bcm_flash2x_section_val eFlash2xSectVal,
2914                         unsigned int uiOffset,
2915                         unsigned int uiNumBytes,
2916                         unsigned int bVerify)
2917 {
2918         int Status = STATUS_SUCCESS;
2919         unsigned int FlashSectValStartOffset = 0;
2920         unsigned int uiTemp = 0, value = 0;
2921
2922         if (!Adapter) {
2923                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Adapter structure is NULL");
2924                 return -EINVAL;
2925         }
2926
2927         if (Adapter->device_removed) {
2928                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Device has been removed");
2929                 return -ENODEV;
2930         }
2931
2932         /* NO_SECTION_VAL means absolute offset is given. */
2933         if (eFlash2xSectVal == NO_SECTION_VAL)
2934                 FlashSectValStartOffset = 0;
2935         else
2936                 FlashSectValStartOffset = BcmGetSectionValStartOffset(Adapter, eFlash2xSectVal);
2937
2938         if (FlashSectValStartOffset == STATUS_FAILURE) {
2939                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "This Section<%d> does not exixt in Flash Map 2.x", eFlash2xSectVal);
2940                 return -EINVAL;
2941         }
2942
2943         if (IsSectionExistInVendorInfo(Adapter, eFlash2xSectVal))
2944                 return vendorextnWriteSection(Adapter, (PUCHAR)pBuffer, eFlash2xSectVal, uiOffset, uiNumBytes, bVerify);
2945
2946         /* calculating  the absolute offset from FLASH; */
2947         uiOffset = uiOffset + FlashSectValStartOffset;
2948
2949         rdmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
2950         value = 0;
2951         wrmalt(Adapter, 0x0f000C80, &value, sizeof(value));
2952
2953         Status = BeceemFlashBulkWrite(Adapter, pBuffer, uiOffset, uiNumBytes, bVerify);
2954
2955         wrmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
2956         if (Status) {
2957                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Flash Write failed with Status :%d", Status);
2958                 return Status;
2959         }
2960
2961         return Status;
2962 }
2963
2964 /*
2965  * BcmGetActiveDSD : Set the Active DSD in Adapter Structure which has to be dumped in DDR
2966  * @Adapter :-Drivers private Data Structure
2967  *
2968  * Return Value:-
2969  * Return STATUS_SUCESS if get success in setting the right DSD else negaive error code
2970  *
2971  */
2972
2973 static int BcmGetActiveDSD(struct bcm_mini_adapter *Adapter)
2974 {
2975         enum bcm_flash2x_section_val uiHighestPriDSD = 0;
2976
2977         uiHighestPriDSD = getHighestPriDSD(Adapter);
2978         Adapter->eActiveDSD = uiHighestPriDSD;
2979
2980         if (DSD0  == uiHighestPriDSD)
2981                 Adapter->ulFlashCalStart = Adapter->psFlash2xCSInfo->OffsetFromZeroForDSDStart;
2982         if (DSD1 == uiHighestPriDSD)
2983                 Adapter->ulFlashCalStart = Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD1Start;
2984         if (DSD2 == uiHighestPriDSD)
2985                 Adapter->ulFlashCalStart = Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD2Start;
2986         if (Adapter->eActiveDSD)
2987                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Active DSD :%d", Adapter->eActiveDSD);
2988         if (Adapter->eActiveDSD == 0) {
2989                 /* if No DSD gets Active, Make Active the DSD with WR  permission */
2990                 if (IsSectionWritable(Adapter, DSD2)) {
2991                         Adapter->eActiveDSD = DSD2;
2992                         Adapter->ulFlashCalStart = Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD2Start;
2993                 } else if (IsSectionWritable(Adapter, DSD1)) {
2994                         Adapter->eActiveDSD = DSD1;
2995                         Adapter->ulFlashCalStart = Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD1Start;
2996                 } else if (IsSectionWritable(Adapter, DSD0)) {
2997                         Adapter->eActiveDSD = DSD0;
2998                         Adapter->ulFlashCalStart = Adapter->psFlash2xCSInfo->OffsetFromZeroForDSDStart;
2999                 }
3000         }
3001
3002         return STATUS_SUCCESS;
3003 }
3004
3005 /*
3006  * BcmGetActiveISO :- Set the Active ISO in Adapter Data Structue
3007  * @Adapter : Driver private Data Structure
3008  *
3009  * Return Value:-
3010  * Sucsess:- STATUS_SUCESS
3011  * Failure- : negative erro code
3012  *
3013  */
3014
3015 static int BcmGetActiveISO(struct bcm_mini_adapter *Adapter)
3016 {
3017         int HighestPriISO = 0;
3018
3019         HighestPriISO = getHighestPriISO(Adapter);
3020
3021         Adapter->eActiveISO = HighestPriISO;
3022         if (Adapter->eActiveISO == ISO_IMAGE2)
3023                 Adapter->uiActiveISOOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage2Part1Start);
3024         else if (Adapter->eActiveISO == ISO_IMAGE1)
3025                 Adapter->uiActiveISOOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage1Part1Start);
3026
3027         if (Adapter->eActiveISO)
3028                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Active ISO :%x", Adapter->eActiveISO);
3029
3030         return STATUS_SUCCESS;
3031 }
3032
3033 /*
3034  * IsOffsetWritable :- it will tell the access permission of the sector having passed offset
3035  * @Adapter : Drivers Private Data Structure
3036  * @uiOffset : Offset provided in the Flash
3037  *
3038  * Return Value:-
3039  * Success:-TRUE ,  offset is writable
3040  * Failure:-FALSE, offset is RO
3041  *
3042  */
3043
3044 B_UINT8 IsOffsetWritable(struct bcm_mini_adapter *Adapter, unsigned int uiOffset)
3045 {
3046         unsigned int uiSectorNum = 0;
3047         unsigned int uiWordOfSectorPermission = 0;
3048         unsigned int uiBitofSectorePermission = 0;
3049         B_UINT32 permissionBits = 0;
3050
3051         uiSectorNum = uiOffset/Adapter->uiSectorSize;
3052
3053         /* calculating the word having this Sector Access permission from SectorAccessBitMap Array */
3054         uiWordOfSectorPermission = Adapter->psFlash2xCSInfo->SectorAccessBitMap[uiSectorNum / 16];
3055
3056         /* calculating the bit index inside the word for  this sector */
3057         uiBitofSectorePermission = 2 * (15 - uiSectorNum % 16);
3058
3059         /* Setting Access permission */
3060         permissionBits = uiWordOfSectorPermission & (0x3 << uiBitofSectorePermission);
3061         permissionBits = (permissionBits >> uiBitofSectorePermission) & 0x3;
3062         if (permissionBits == SECTOR_READWRITE_PERMISSION)
3063                 return TRUE;
3064         else
3065                 return FALSE;
3066 }
3067
3068 static int BcmDumpFlash2xSectionBitMap(struct bcm_flash2x_bitmap *psFlash2xBitMap)
3069 {
3070         struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
3071
3072         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "***************Flash 2.x Section Bitmap***************");
3073         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "ISO_IMAGE1  :0X%x", psFlash2xBitMap->ISO_IMAGE1);
3074         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "ISO_IMAGE2  :0X%x", psFlash2xBitMap->ISO_IMAGE2);
3075         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "DSD0  :0X%x", psFlash2xBitMap->DSD0);
3076         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "DSD1  :0X%x", psFlash2xBitMap->DSD1);
3077         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "DSD2  :0X%x", psFlash2xBitMap->DSD2);
3078         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "VSA0  :0X%x", psFlash2xBitMap->VSA0);
3079         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "VSA1  :0X%x", psFlash2xBitMap->VSA1);
3080         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "VSA2  :0X%x", psFlash2xBitMap->VSA2);
3081         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "SCSI  :0X%x", psFlash2xBitMap->SCSI);
3082         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "CONTROL_SECTION  :0X%x", psFlash2xBitMap->CONTROL_SECTION);
3083
3084         return STATUS_SUCCESS;
3085 }
3086
3087 /*
3088  * BcmGetFlash2xSectionalBitMap :- It will provide the bit map of all the section present in Flash
3089  * 8bit has been assigned to every section.
3090  * bit[0] :Section present or not
3091  * bit[1] :section is valid or not
3092  * bit[2] : Secton is read only or has write permission too.
3093  * bit[3] : Active Section -
3094  * bit[7...4] = Reserved .
3095  *
3096  * @Adapter:-Driver private Data Structure
3097  *
3098  * Return value:-
3099  * Success:- STATUS_SUCESS
3100  * Failure:- negative error code
3101  */
3102
3103 int BcmGetFlash2xSectionalBitMap(struct bcm_mini_adapter *Adapter, struct bcm_flash2x_bitmap *psFlash2xBitMap)
3104 {
3105         struct bcm_flash2x_cs_info *psFlash2xCSInfo = Adapter->psFlash2xCSInfo;
3106         enum bcm_flash2x_section_val uiHighestPriDSD = 0;
3107         enum bcm_flash2x_section_val uiHighestPriISO = 0;
3108         BOOLEAN SetActiveDSDDone = FALSE;
3109         BOOLEAN SetActiveISODone = FALSE;
3110
3111         /* For 1.x map all the section except DSD0 will be shown as not present
3112          * This part will be used by calibration tool to detect the number of DSD present in Flash.
3113          */
3114         if (IsFlash2x(Adapter) == FALSE) {
3115                 psFlash2xBitMap->ISO_IMAGE2 = 0;
3116                 psFlash2xBitMap->ISO_IMAGE1 = 0;
3117                 psFlash2xBitMap->DSD0 = FLASH2X_SECTION_VALID | FLASH2X_SECTION_ACT | FLASH2X_SECTION_PRESENT; /* 0xF; 0000(Reseved)1(Active)0(RW)1(valid)1(present) */
3118                 psFlash2xBitMap->DSD1  = 0;
3119                 psFlash2xBitMap->DSD2 = 0;
3120                 psFlash2xBitMap->VSA0 = 0;
3121                 psFlash2xBitMap->VSA1 = 0;
3122                 psFlash2xBitMap->VSA2 = 0;
3123                 psFlash2xBitMap->CONTROL_SECTION = 0;
3124                 psFlash2xBitMap->SCSI = 0;
3125                 psFlash2xBitMap->Reserved0 = 0;
3126                 psFlash2xBitMap->Reserved1 = 0;
3127                 psFlash2xBitMap->Reserved2 = 0;
3128
3129                 return STATUS_SUCCESS;
3130         }
3131
3132         uiHighestPriDSD = getHighestPriDSD(Adapter);
3133         uiHighestPriISO = getHighestPriISO(Adapter);
3134
3135         /*
3136          * IS0 IMAGE 2
3137          */
3138         if ((psFlash2xCSInfo->OffsetISOImage2Part1Start) != UNINIT_PTR_IN_CS) {
3139                 /* Setting the 0th Bit representing the Section is present or not. */
3140                 psFlash2xBitMap->ISO_IMAGE2 = psFlash2xBitMap->ISO_IMAGE2 | FLASH2X_SECTION_PRESENT;
3141
3142                 if (ReadISOSignature(Adapter, ISO_IMAGE2) == ISO_IMAGE_MAGIC_NUMBER)
3143                         psFlash2xBitMap->ISO_IMAGE2 |= FLASH2X_SECTION_VALID;
3144
3145                 /* Calculation for extrating the Access permission */
3146                 if (IsSectionWritable(Adapter, ISO_IMAGE2) == FALSE)
3147                         psFlash2xBitMap->ISO_IMAGE2 |= FLASH2X_SECTION_RO;
3148
3149                 if (SetActiveISODone == FALSE && uiHighestPriISO == ISO_IMAGE2) {
3150                         psFlash2xBitMap->ISO_IMAGE2 |= FLASH2X_SECTION_ACT;
3151                         SetActiveISODone = TRUE;
3152                 }
3153         }
3154
3155         /*
3156          * IS0 IMAGE 1
3157          */
3158         if ((psFlash2xCSInfo->OffsetISOImage1Part1Start) != UNINIT_PTR_IN_CS) {
3159                 /* Setting the 0th Bit representing the Section is present or not. */
3160                 psFlash2xBitMap->ISO_IMAGE1 = psFlash2xBitMap->ISO_IMAGE1 | FLASH2X_SECTION_PRESENT;
3161
3162                 if (ReadISOSignature(Adapter, ISO_IMAGE1) == ISO_IMAGE_MAGIC_NUMBER)
3163                         psFlash2xBitMap->ISO_IMAGE1 |= FLASH2X_SECTION_VALID;
3164
3165                 /* Calculation for extrating the Access permission */
3166                 if (IsSectionWritable(Adapter, ISO_IMAGE1) == FALSE)
3167                         psFlash2xBitMap->ISO_IMAGE1 |= FLASH2X_SECTION_RO;
3168
3169                 if (SetActiveISODone == FALSE && uiHighestPriISO == ISO_IMAGE1) {
3170                         psFlash2xBitMap->ISO_IMAGE1 |= FLASH2X_SECTION_ACT;
3171                         SetActiveISODone = TRUE;
3172                 }
3173         }
3174
3175         /*
3176          * DSD2
3177          */
3178         if ((psFlash2xCSInfo->OffsetFromZeroForDSD2Start) != UNINIT_PTR_IN_CS) {
3179                 /* Setting the 0th Bit representing the Section is present or not. */
3180                 psFlash2xBitMap->DSD2 = psFlash2xBitMap->DSD2 | FLASH2X_SECTION_PRESENT;
3181
3182                 if (ReadDSDSignature(Adapter, DSD2) == DSD_IMAGE_MAGIC_NUMBER)
3183                         psFlash2xBitMap->DSD2 |= FLASH2X_SECTION_VALID;
3184
3185                 /* Calculation for extrating the Access permission */
3186                 if (IsSectionWritable(Adapter, DSD2) == FALSE) {
3187                         psFlash2xBitMap->DSD2 |= FLASH2X_SECTION_RO;
3188                 } else {
3189                         /* Means section is writable */
3190                         if ((SetActiveDSDDone == FALSE) && (uiHighestPriDSD == DSD2)) {
3191                                 psFlash2xBitMap->DSD2 |= FLASH2X_SECTION_ACT;
3192                                 SetActiveDSDDone = TRUE;
3193                         }
3194                 }
3195         }
3196
3197         /*
3198          * DSD 1
3199          */
3200         if ((psFlash2xCSInfo->OffsetFromZeroForDSD1Start) != UNINIT_PTR_IN_CS) {
3201                 /* Setting the 0th Bit representing the Section is present or not. */
3202                 psFlash2xBitMap->DSD1 = psFlash2xBitMap->DSD1 | FLASH2X_SECTION_PRESENT;
3203
3204                 if (ReadDSDSignature(Adapter, DSD1) == DSD_IMAGE_MAGIC_NUMBER)
3205                         psFlash2xBitMap->DSD1 |= FLASH2X_SECTION_VALID;
3206
3207                 /* Calculation for extrating the Access permission */
3208                 if (IsSectionWritable(Adapter, DSD1) == FALSE) {
3209                         psFlash2xBitMap->DSD1 |= FLASH2X_SECTION_RO;
3210                 } else {
3211                         /* Means section is writable */
3212                         if ((SetActiveDSDDone == FALSE) && (uiHighestPriDSD == DSD1)) {
3213                                 psFlash2xBitMap->DSD1 |= FLASH2X_SECTION_ACT;
3214                                 SetActiveDSDDone = TRUE;
3215                         }
3216                 }
3217         }
3218
3219         /*
3220          * For DSD 0
3221          */
3222         if ((psFlash2xCSInfo->OffsetFromZeroForDSDStart) != UNINIT_PTR_IN_CS) {
3223                 /* Setting the 0th Bit representing the Section is present or not. */
3224                 psFlash2xBitMap->DSD0 = psFlash2xBitMap->DSD0 | FLASH2X_SECTION_PRESENT;
3225
3226                 if (ReadDSDSignature(Adapter, DSD0) == DSD_IMAGE_MAGIC_NUMBER)
3227                         psFlash2xBitMap->DSD0 |= FLASH2X_SECTION_VALID;
3228
3229                 /* Setting Access permission */
3230                 if (IsSectionWritable(Adapter, DSD0) == FALSE) {
3231                         psFlash2xBitMap->DSD0 |= FLASH2X_SECTION_RO;
3232                 } else {
3233                         /* Means section is writable */
3234                         if ((SetActiveDSDDone == FALSE) && (uiHighestPriDSD == DSD0)) {
3235                                 psFlash2xBitMap->DSD0 |= FLASH2X_SECTION_ACT;
3236                                 SetActiveDSDDone = TRUE;
3237                         }
3238                 }
3239         }
3240
3241         /*
3242          * VSA 0
3243          */
3244         if ((psFlash2xCSInfo->OffsetFromZeroForVSAStart) != UNINIT_PTR_IN_CS) {
3245                 /* Setting the 0th Bit representing the Section is present or not. */
3246                 psFlash2xBitMap->VSA0 = psFlash2xBitMap->VSA0 | FLASH2X_SECTION_PRESENT;
3247
3248                 /* Setting the Access Bit. Map is not defined hece setting it always valid */
3249                 psFlash2xBitMap->VSA0 |= FLASH2X_SECTION_VALID;
3250
3251                 /* Calculation for extrating the Access permission */
3252                 if (IsSectionWritable(Adapter, VSA0) == FALSE)
3253                         psFlash2xBitMap->VSA0 |=  FLASH2X_SECTION_RO;
3254
3255                 /* By Default section is Active */
3256                 psFlash2xBitMap->VSA0 |= FLASH2X_SECTION_ACT;
3257         }
3258
3259         /*
3260          * VSA 1
3261          */
3262         if ((psFlash2xCSInfo->OffsetFromZeroForVSA1Start) != UNINIT_PTR_IN_CS) {
3263                 /* Setting the 0th Bit representing the Section is present or not. */
3264                 psFlash2xBitMap->VSA1 = psFlash2xBitMap->VSA1 | FLASH2X_SECTION_PRESENT;
3265
3266                 /* Setting the Access Bit. Map is not defined hece setting it always valid */
3267                 psFlash2xBitMap->VSA1 |= FLASH2X_SECTION_VALID;
3268
3269                 /* Checking For Access permission */
3270                 if (IsSectionWritable(Adapter, VSA1) == FALSE)
3271                         psFlash2xBitMap->VSA1 |= FLASH2X_SECTION_RO;
3272
3273                 /* By Default section is Active */
3274                 psFlash2xBitMap->VSA1 |= FLASH2X_SECTION_ACT;
3275         }
3276
3277         /*
3278          * VSA 2
3279          */
3280         if ((psFlash2xCSInfo->OffsetFromZeroForVSA2Start) != UNINIT_PTR_IN_CS) {
3281                 /* Setting the 0th Bit representing the Section is present or not. */
3282                 psFlash2xBitMap->VSA2 = psFlash2xBitMap->VSA2 | FLASH2X_SECTION_PRESENT;
3283
3284                 /* Setting the Access Bit. Map is not defined hece setting it always valid */
3285                 psFlash2xBitMap->VSA2 |= FLASH2X_SECTION_VALID;
3286
3287                 /* Checking For Access permission */
3288                 if (IsSectionWritable(Adapter, VSA2) == FALSE)
3289                         psFlash2xBitMap->VSA2 |= FLASH2X_SECTION_RO;
3290
3291                 /* By Default section is Active */
3292                 psFlash2xBitMap->VSA2 |= FLASH2X_SECTION_ACT;
3293         }
3294
3295         /*
3296          * SCSI Section
3297          */
3298         if ((psFlash2xCSInfo->OffsetFromZeroForScsiFirmware) != UNINIT_PTR_IN_CS) {
3299                 /* Setting the 0th Bit representing the Section is present or not. */
3300                 psFlash2xBitMap->SCSI = psFlash2xBitMap->SCSI | FLASH2X_SECTION_PRESENT;
3301
3302                 /* Setting the Access Bit. Map is not defined hece setting it always valid */
3303                 psFlash2xBitMap->SCSI |= FLASH2X_SECTION_VALID;
3304
3305                 /* Checking For Access permission */
3306                 if (IsSectionWritable(Adapter, SCSI) == FALSE)
3307                         psFlash2xBitMap->SCSI |= FLASH2X_SECTION_RO;
3308
3309                 /* By Default section is Active */
3310                 psFlash2xBitMap->SCSI |= FLASH2X_SECTION_ACT;
3311         }
3312
3313         /*
3314          * Control Section
3315          */
3316         if ((psFlash2xCSInfo->OffsetFromZeroForControlSectionStart) != UNINIT_PTR_IN_CS) {
3317                 /* Setting the 0th Bit representing the Section is present or not. */
3318                 psFlash2xBitMap->CONTROL_SECTION = psFlash2xBitMap->CONTROL_SECTION | (FLASH2X_SECTION_PRESENT);
3319
3320                 /* Setting the Access Bit. Map is not defined hece setting it always valid */
3321                 psFlash2xBitMap->CONTROL_SECTION |= FLASH2X_SECTION_VALID;
3322
3323                 /* Checking For Access permission */
3324                 if (IsSectionWritable(Adapter, CONTROL_SECTION) == FALSE)
3325                         psFlash2xBitMap->CONTROL_SECTION |= FLASH2X_SECTION_RO;
3326
3327                 /* By Default section is Active */
3328                 psFlash2xBitMap->CONTROL_SECTION |= FLASH2X_SECTION_ACT;
3329         }
3330
3331         /*
3332          * For Reserved Sections
3333          */
3334         psFlash2xBitMap->Reserved0 = 0;
3335         psFlash2xBitMap->Reserved0 = 0;
3336         psFlash2xBitMap->Reserved0 = 0;
3337         BcmDumpFlash2xSectionBitMap(psFlash2xBitMap);
3338
3339         return STATUS_SUCCESS;
3340 }
3341
3342 /*
3343  * BcmSetActiveSection :- Set Active section is used to make priority field highest over other
3344  * section of same type.
3345  *
3346  * @Adapater :- Bcm Driver Private Data Structure
3347  * @eFlash2xSectionVal :- Flash section val whose priority has to be made highest.
3348  *
3349  * Return Value:- Make the priorit highest else return erorr code
3350  *
3351  */
3352
3353 int BcmSetActiveSection(struct bcm_mini_adapter *Adapter, enum bcm_flash2x_section_val eFlash2xSectVal)
3354 {
3355         unsigned int SectImagePriority = 0;
3356         int Status = STATUS_SUCCESS;
3357
3358         /* struct bcm_dsd_header sDSD = {0};
3359          * struct bcm_iso_header sISO = {0};
3360          */
3361         int HighestPriDSD = 0 ;
3362         int HighestPriISO = 0;
3363
3364         Status = IsSectionWritable(Adapter, eFlash2xSectVal);
3365         if (Status != TRUE) {
3366                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Provided Section <%d> is not writable", eFlash2xSectVal);
3367                 return STATUS_FAILURE;
3368         }
3369
3370         Adapter->bHeaderChangeAllowed = TRUE;
3371         switch (eFlash2xSectVal) {
3372         case ISO_IMAGE1:
3373         case ISO_IMAGE2:
3374                 if (ReadISOSignature(Adapter, eFlash2xSectVal) == ISO_IMAGE_MAGIC_NUMBER) {
3375                         HighestPriISO = getHighestPriISO(Adapter);
3376
3377                         if (HighestPriISO == eFlash2xSectVal) {
3378                                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Given ISO<%x> already has highest priority", eFlash2xSectVal);
3379                                 Status = STATUS_SUCCESS;
3380                                 break;
3381                         }
3382
3383                         SectImagePriority = ReadISOPriority(Adapter, HighestPriISO) + 1;
3384
3385                         if ((SectImagePriority <= 0) && IsSectionWritable(Adapter, HighestPriISO)) {
3386                                 /* This is a SPECIAL Case which will only happen if the current highest priority ISO has priority value = 0x7FFFFFFF.
3387                                  * We will write 1 to the current Highest priority ISO And then shall increase the priority of the requested ISO
3388                                  * by user
3389                                  */
3390                                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "SectImagePriority wraparound happened, eFlash2xSectVal: 0x%x\n", eFlash2xSectVal);
3391                                 SectImagePriority = htonl(0x1);
3392                                 Status = BcmFlash2xBulkWrite(Adapter,
3393                                                         &SectImagePriority,
3394                                                         HighestPriISO,
3395                                                         0 + FIELD_OFFSET_IN_HEADER(struct bcm_iso_header *, ISOImagePriority),
3396                                                         SIGNATURE_SIZE,
3397                                                         TRUE);
3398                                 if (Status) {
3399                                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Priority has not been written properly");
3400                                         Status = STATUS_FAILURE;
3401                                         break;
3402                                 }
3403
3404                                 HighestPriISO = getHighestPriISO(Adapter);
3405
3406                                 if (HighestPriISO == eFlash2xSectVal) {
3407                                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Given ISO<%x> already has highest priority", eFlash2xSectVal);
3408                                         Status = STATUS_SUCCESS;
3409                                         break;
3410                                 }
3411
3412                                 SectImagePriority = 2;
3413                         }
3414
3415                         SectImagePriority = htonl(SectImagePriority);
3416
3417                         Status = BcmFlash2xBulkWrite(Adapter,
3418                                                 &SectImagePriority,
3419                                                 eFlash2xSectVal,
3420                                                 0 + FIELD_OFFSET_IN_HEADER(struct bcm_iso_header *, ISOImagePriority),
3421                                                 SIGNATURE_SIZE,
3422                                                 TRUE);
3423                         if (Status) {
3424                                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Priority has not been written properly");
3425                                 break;
3426                         }
3427                 } else {
3428                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Signature is currupted. Hence can't increase the priority");
3429                         Status = STATUS_FAILURE;
3430                         break;
3431                 }
3432                 break;
3433         case DSD0:
3434         case DSD1:
3435         case DSD2:
3436                 if (ReadDSDSignature(Adapter, eFlash2xSectVal) == DSD_IMAGE_MAGIC_NUMBER) {
3437                         HighestPriDSD = getHighestPriDSD(Adapter);
3438                         if ((HighestPriDSD == eFlash2xSectVal)) {
3439                                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Given DSD<%x> already has highest priority", eFlash2xSectVal);
3440                                 Status = STATUS_SUCCESS;
3441                                 break;
3442                         }
3443
3444                         SectImagePriority = ReadDSDPriority(Adapter, HighestPriDSD) + 1;
3445                         if (SectImagePriority <= 0) {
3446                                 /* This is a SPECIAL Case which will only happen if the current highest priority DSD has priority value = 0x7FFFFFFF.
3447                                  * We will write 1 to the current Highest priority DSD And then shall increase the priority of the requested DSD
3448                                  * by user
3449                                  */
3450                                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, NVM_RW, DBG_LVL_ALL, "SectImagePriority wraparound happened, eFlash2xSectVal: 0x%x\n", eFlash2xSectVal);
3451                                 SectImagePriority = htonl(0x1);
3452
3453                                 Status = BcmFlash2xBulkWrite(Adapter,
3454                                                         &SectImagePriority,
3455                                                         HighestPriDSD,
3456                                                         Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader + FIELD_OFFSET_IN_HEADER(struct bcm_dsd_header *, DSDImagePriority),
3457                                                         SIGNATURE_SIZE,
3458                                                         TRUE);
3459                                 if (Status) {
3460                                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Priority has not been written properly");
3461                                         break;
3462                                 }
3463
3464                                 HighestPriDSD = getHighestPriDSD(Adapter);
3465
3466                                 if ((HighestPriDSD == eFlash2xSectVal)) {
3467                                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Made the DSD: %x highest by reducing priority of other\n", eFlash2xSectVal);
3468                                         Status = STATUS_SUCCESS;
3469                                         break;
3470                                 }
3471
3472                                 SectImagePriority = htonl(0x2);
3473                                 Status = BcmFlash2xBulkWrite(Adapter,
3474                                                         &SectImagePriority,
3475                                                         HighestPriDSD,
3476                                                         Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader + FIELD_OFFSET_IN_HEADER(struct bcm_dsd_header *, DSDImagePriority),
3477                                                         SIGNATURE_SIZE,
3478                                                         TRUE);
3479                                 if (Status) {
3480                                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Priority has not been written properly");
3481                                         break;
3482                                 }
3483
3484                                 HighestPriDSD = getHighestPriDSD(Adapter);
3485                                 if ((HighestPriDSD == eFlash2xSectVal)) {
3486                                         Status = STATUS_SUCCESS;
3487                                         break;
3488                                 }
3489
3490                                 SectImagePriority = 3;
3491                         }
3492                         SectImagePriority = htonl(SectImagePriority);
3493                         Status = BcmFlash2xBulkWrite(Adapter,
3494                                                 &SectImagePriority,
3495                                                 eFlash2xSectVal,
3496                                                 Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader + FIELD_OFFSET_IN_HEADER(struct bcm_dsd_header *, DSDImagePriority),
3497                                                 SIGNATURE_SIZE,
3498                                                 TRUE);
3499                         if (Status) {
3500                                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Priority has not been written properly");
3501                                 Status = STATUS_FAILURE;
3502                                 break;
3503                         }
3504                 } else {
3505                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Signature is currupted. Hence can't increase the priority");
3506                         Status = STATUS_FAILURE;
3507                         break;
3508                 }
3509                 break;
3510         case VSA0:
3511         case VSA1:
3512         case VSA2:
3513                 /* Has to be decided */
3514                 break;
3515         default:
3516                 Status = STATUS_FAILURE;
3517                 break;
3518         }
3519
3520         Adapter->bHeaderChangeAllowed = FALSE;
3521         return Status;
3522 }
3523
3524 /*
3525  * BcmCopyISO - Used only for copying the ISO section
3526  * @Adapater :- Bcm Driver Private Data Structure
3527  * @sCopySectStrut :- Section copy structure
3528  *
3529  * Return value:- SUCCESS if copies successfully else negative error code
3530  *
3531  */
3532
3533 int BcmCopyISO(struct bcm_mini_adapter *Adapter, struct bcm_flash2x_copy_section sCopySectStrut)
3534 {
3535         PCHAR Buff = NULL;
3536         enum bcm_flash2x_section_val eISOReadPart = 0, eISOWritePart = 0;
3537         unsigned int uiReadOffsetWithinPart = 0, uiWriteOffsetWithinPart = 0;
3538         unsigned int uiTotalDataToCopy = 0;
3539         BOOLEAN IsThisHeaderSector = FALSE;
3540         unsigned int sigOffset = 0;
3541         unsigned int ISOLength = 0;
3542         unsigned int Status = STATUS_SUCCESS;
3543         unsigned int SigBuff[MAX_RW_SIZE];
3544         unsigned int i = 0;
3545
3546         if (ReadISOSignature(Adapter, sCopySectStrut.SrcSection) != ISO_IMAGE_MAGIC_NUMBER) {
3547                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "error as Source ISO Section does not have valid signature");
3548                 return STATUS_FAILURE;
3549         }
3550
3551         Status = BcmFlash2xBulkRead(Adapter,
3552                                 &ISOLength,
3553                                 sCopySectStrut.SrcSection,
3554                                 0 + FIELD_OFFSET_IN_HEADER(struct bcm_iso_header *, ISOImageSize),
3555                                 4);
3556         if (Status) {
3557                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Read failed while copying ISO\n");
3558                 return Status;
3559         }
3560
3561         ISOLength = htonl(ISOLength);
3562         if (ISOLength % Adapter->uiSectorSize)
3563                 ISOLength = Adapter->uiSectorSize * (1 + ISOLength/Adapter->uiSectorSize);
3564
3565         sigOffset = FIELD_OFFSET_IN_HEADER(struct bcm_iso_header *, ISOImageMagicNumber);
3566
3567         Buff = kzalloc(Adapter->uiSectorSize, GFP_KERNEL);
3568
3569         if (!Buff) {
3570                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Memory allocation failed for section size");
3571                 return -ENOMEM;
3572         }
3573
3574         if (sCopySectStrut.SrcSection == ISO_IMAGE1 && sCopySectStrut.DstSection == ISO_IMAGE2) {
3575                 eISOReadPart = ISO_IMAGE1;
3576                 eISOWritePart = ISO_IMAGE2;
3577                 uiReadOffsetWithinPart =  0;
3578                 uiWriteOffsetWithinPart = 0;
3579
3580                 uiTotalDataToCopy = (Adapter->psFlash2xCSInfo->OffsetISOImage1Part1End) -
3581                         (Adapter->psFlash2xCSInfo->OffsetISOImage1Part1Start) +
3582                         (Adapter->psFlash2xCSInfo->OffsetISOImage1Part2End) -
3583                         (Adapter->psFlash2xCSInfo->OffsetISOImage1Part2Start) +
3584                         (Adapter->psFlash2xCSInfo->OffsetISOImage1Part3End) -
3585                         (Adapter->psFlash2xCSInfo->OffsetISOImage1Part3Start);
3586
3587                 if (uiTotalDataToCopy < ISOLength) {
3588                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "error as Source ISO Section does not have valid signature");
3589                         Status = STATUS_FAILURE;
3590                         goto out;
3591                 }
3592
3593                 uiTotalDataToCopy = (Adapter->psFlash2xCSInfo->OffsetISOImage2Part1End) -
3594                         (Adapter->psFlash2xCSInfo->OffsetISOImage2Part1Start) +
3595                         (Adapter->psFlash2xCSInfo->OffsetISOImage2Part2End) -
3596                         (Adapter->psFlash2xCSInfo->OffsetISOImage2Part2Start) +
3597                         (Adapter->psFlash2xCSInfo->OffsetISOImage2Part3End) -
3598                         (Adapter->psFlash2xCSInfo->OffsetISOImage2Part3Start);
3599
3600                 if (uiTotalDataToCopy < ISOLength) {
3601                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "error as Dest ISO Section does not have enough section size");
3602                         Status = STATUS_FAILURE;
3603                         goto out;
3604                 }
3605
3606                 uiTotalDataToCopy = ISOLength;
3607
3608                 CorruptISOSig(Adapter, ISO_IMAGE2);
3609                 while (uiTotalDataToCopy) {
3610                         if (uiTotalDataToCopy == Adapter->uiSectorSize) {
3611                                 /* Setting for write of first sector. First sector is assumed to be written in last */
3612                                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Writing the signature sector");
3613                                 eISOReadPart = ISO_IMAGE1;
3614                                 uiReadOffsetWithinPart = 0;
3615                                 eISOWritePart = ISO_IMAGE2;
3616                                 uiWriteOffsetWithinPart = 0;
3617                                 IsThisHeaderSector = TRUE;
3618                         } else {
3619                                 uiReadOffsetWithinPart = uiReadOffsetWithinPart + Adapter->uiSectorSize;
3620                                 uiWriteOffsetWithinPart = uiWriteOffsetWithinPart + Adapter->uiSectorSize;
3621
3622                                 if ((eISOReadPart == ISO_IMAGE1) && (uiReadOffsetWithinPart == (Adapter->psFlash2xCSInfo->OffsetISOImage1Part1End - Adapter->psFlash2xCSInfo->OffsetISOImage1Part1Start))) {
3623                                         eISOReadPart = ISO_IMAGE1_PART2;
3624                                         uiReadOffsetWithinPart = 0;
3625                                 }
3626
3627                                 if ((eISOReadPart == ISO_IMAGE1_PART2) && (uiReadOffsetWithinPart == (Adapter->psFlash2xCSInfo->OffsetISOImage1Part2End - Adapter->psFlash2xCSInfo->OffsetISOImage1Part2Start))) {
3628                                         eISOReadPart = ISO_IMAGE1_PART3;
3629                                         uiReadOffsetWithinPart = 0;
3630                                 }
3631
3632                                 if ((eISOWritePart == ISO_IMAGE2) && (uiWriteOffsetWithinPart == (Adapter->psFlash2xCSInfo->OffsetISOImage2Part1End - Adapter->psFlash2xCSInfo->OffsetISOImage2Part1Start))) {
3633                                         eISOWritePart = ISO_IMAGE2_PART2;
3634                                         uiWriteOffsetWithinPart = 0;
3635                                 }
3636
3637                                 if ((eISOWritePart == ISO_IMAGE2_PART2) && (uiWriteOffsetWithinPart == (Adapter->psFlash2xCSInfo->OffsetISOImage2Part2End - Adapter->psFlash2xCSInfo->OffsetISOImage2Part2Start))) {
3638                                         eISOWritePart = ISO_IMAGE2_PART3;
3639                                         uiWriteOffsetWithinPart = 0;
3640                                 }
3641                         }
3642
3643                         Status = BcmFlash2xBulkRead(Adapter,
3644                                                 (PUINT)Buff,
3645                                                 eISOReadPart,
3646                                                 uiReadOffsetWithinPart,
3647                                                 Adapter->uiSectorSize);
3648                         if (Status) {
3649                                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Read failed while copying ISO: Part: %x, OffsetWithinPart: %x\n", eISOReadPart, uiReadOffsetWithinPart);
3650                                 break;
3651                         }
3652
3653                         if (IsThisHeaderSector == TRUE) {
3654                                 /* If this is header sector write 0xFFFFFFFF at the sig time and in last write sig */
3655                                 memcpy(SigBuff, Buff + sigOffset, MAX_RW_SIZE);
3656
3657                                 for (i = 0; i < MAX_RW_SIZE; i++)
3658                                         *(Buff + sigOffset + i) = 0xFF;
3659                         }
3660                         Adapter->bHeaderChangeAllowed = TRUE;
3661                         Status = BcmFlash2xBulkWrite(Adapter,
3662                                                 (PUINT)Buff,
3663                                                 eISOWritePart,
3664                                                 uiWriteOffsetWithinPart,
3665                                                 Adapter->uiSectorSize,
3666                                                 TRUE);
3667                         if (Status) {
3668                                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Write failed while copying ISO: Part: %x, OffsetWithinPart: %x\n", eISOWritePart, uiWriteOffsetWithinPart);
3669                                 break;
3670                         }
3671
3672                         Adapter->bHeaderChangeAllowed = FALSE;
3673                         if (IsThisHeaderSector == TRUE) {
3674                                 WriteToFlashWithoutSectorErase(Adapter,
3675                                                         SigBuff,
3676                                                         eISOWritePart,
3677                                                         sigOffset,
3678                                                         MAX_RW_SIZE);
3679                                 IsThisHeaderSector = FALSE;
3680                         }
3681                         /* subtracting the written Data */
3682                         uiTotalDataToCopy = uiTotalDataToCopy - Adapter->uiSectorSize;
3683                 }
3684         }
3685
3686         if (sCopySectStrut.SrcSection == ISO_IMAGE2 && sCopySectStrut.DstSection == ISO_IMAGE1) {
3687                 eISOReadPart = ISO_IMAGE2;
3688                 eISOWritePart = ISO_IMAGE1;
3689                 uiReadOffsetWithinPart = 0;
3690                 uiWriteOffsetWithinPart = 0;
3691
3692                 uiTotalDataToCopy = (Adapter->psFlash2xCSInfo->OffsetISOImage2Part1End) -
3693                         (Adapter->psFlash2xCSInfo->OffsetISOImage2Part1Start) +
3694                         (Adapter->psFlash2xCSInfo->OffsetISOImage2Part2End) -
3695                         (Adapter->psFlash2xCSInfo->OffsetISOImage2Part2Start) +
3696                         (Adapter->psFlash2xCSInfo->OffsetISOImage2Part3End) -
3697                         (Adapter->psFlash2xCSInfo->OffsetISOImage2Part3Start);
3698
3699                 if (uiTotalDataToCopy < ISOLength) {
3700                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "error as Source ISO Section does not have valid signature");
3701                         Status = STATUS_FAILURE;
3702                         goto out;
3703                 }
3704
3705                 uiTotalDataToCopy = (Adapter->psFlash2xCSInfo->OffsetISOImage1Part1End) -
3706                         (Adapter->psFlash2xCSInfo->OffsetISOImage1Part1Start) +
3707                         (Adapter->psFlash2xCSInfo->OffsetISOImage1Part2End) -
3708                         (Adapter->psFlash2xCSInfo->OffsetISOImage1Part2Start) +
3709                         (Adapter->psFlash2xCSInfo->OffsetISOImage1Part3End) -
3710                         (Adapter->psFlash2xCSInfo->OffsetISOImage1Part3Start);
3711
3712                 if (uiTotalDataToCopy < ISOLength) {
3713                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "error as Dest ISO Section does not have enough section size");
3714                         Status = STATUS_FAILURE;
3715                         goto out;
3716                 }
3717
3718                 uiTotalDataToCopy = ISOLength;
3719
3720                 CorruptISOSig(Adapter, ISO_IMAGE1);
3721
3722                 while (uiTotalDataToCopy) {
3723                         if (uiTotalDataToCopy == Adapter->uiSectorSize) {
3724                                 /* Setting for write of first sector. First sector is assumed to be written in last */
3725                                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Writing the signature sector");
3726                                 eISOReadPart = ISO_IMAGE2;
3727                                 uiReadOffsetWithinPart = 0;
3728                                 eISOWritePart = ISO_IMAGE1;
3729                                 uiWriteOffsetWithinPart = 0;
3730                                 IsThisHeaderSector = TRUE;
3731                         } else {
3732                                 uiReadOffsetWithinPart = uiReadOffsetWithinPart + Adapter->uiSectorSize;
3733                                 uiWriteOffsetWithinPart = uiWriteOffsetWithinPart + Adapter->uiSectorSize;
3734
3735                                 if ((eISOReadPart == ISO_IMAGE2) && (uiReadOffsetWithinPart == (Adapter->psFlash2xCSInfo->OffsetISOImage2Part1End - Adapter->psFlash2xCSInfo->OffsetISOImage2Part1Start))) {
3736                                         eISOReadPart = ISO_IMAGE2_PART2;
3737                                         uiReadOffsetWithinPart = 0;
3738                                 }
3739
3740                                 if ((eISOReadPart == ISO_IMAGE2_PART2) && (uiReadOffsetWithinPart == (Adapter->psFlash2xCSInfo->OffsetISOImage2Part2End - Adapter->psFlash2xCSInfo->OffsetISOImage2Part2Start))) {
3741                                         eISOReadPart = ISO_IMAGE2_PART3;
3742                                         uiReadOffsetWithinPart = 0;
3743                                 }
3744
3745                                 if ((eISOWritePart == ISO_IMAGE1) && (uiWriteOffsetWithinPart == (Adapter->psFlash2xCSInfo->OffsetISOImage1Part1End - Adapter->psFlash2xCSInfo->OffsetISOImage1Part1Start))) {
3746                                         eISOWritePart = ISO_IMAGE1_PART2;
3747                                         uiWriteOffsetWithinPart = 0;
3748                                 }
3749
3750                                 if ((eISOWritePart == ISO_IMAGE1_PART2) && (uiWriteOffsetWithinPart == (Adapter->psFlash2xCSInfo->OffsetISOImage1Part2End - Adapter->psFlash2xCSInfo->OffsetISOImage1Part2Start))) {
3751                                         eISOWritePart = ISO_IMAGE1_PART3;
3752                                         uiWriteOffsetWithinPart = 0;
3753                                 }
3754                         }
3755
3756                         Status = BcmFlash2xBulkRead(Adapter,
3757                                                 (PUINT)Buff,
3758                                                 eISOReadPart,
3759                                                 uiReadOffsetWithinPart,
3760                                                 Adapter->uiSectorSize);
3761                         if (Status) {
3762                                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Read failed while copying ISO: Part: %x, OffsetWithinPart: %x\n", eISOReadPart, uiReadOffsetWithinPart);
3763                                 break;
3764                         }
3765
3766                         if (IsThisHeaderSector == TRUE) {
3767                                 /* If this is header sector write 0xFFFFFFFF at the sig time and in last write sig */
3768                                 memcpy(SigBuff, Buff + sigOffset, MAX_RW_SIZE);
3769
3770                                 for (i = 0; i < MAX_RW_SIZE; i++)
3771                                         *(Buff + sigOffset + i) = 0xFF;
3772                         }
3773                         Adapter->bHeaderChangeAllowed = TRUE;
3774                         Status = BcmFlash2xBulkWrite(Adapter,
3775                                                 (PUINT)Buff,
3776                                                 eISOWritePart,
3777                                                 uiWriteOffsetWithinPart,
3778                                                 Adapter->uiSectorSize,
3779                                                 TRUE);
3780                         if (Status) {
3781                                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Write failed while copying ISO: Part: %x, OffsetWithinPart: %x\n", eISOWritePart, uiWriteOffsetWithinPart);
3782                                 break;
3783                         }
3784
3785                         Adapter->bHeaderChangeAllowed = FALSE;
3786                         if (IsThisHeaderSector == TRUE) {
3787                                 WriteToFlashWithoutSectorErase(Adapter,
3788                                                         SigBuff,
3789                                                         eISOWritePart,
3790                                                         sigOffset,
3791                                                         MAX_RW_SIZE);
3792
3793                                 IsThisHeaderSector = FALSE;
3794                         }
3795
3796                         /* subtracting the written Data */
3797                         uiTotalDataToCopy = uiTotalDataToCopy - Adapter->uiSectorSize;
3798                 }
3799         }
3800 out:
3801         kfree(Buff);
3802
3803         return Status;
3804 }
3805
3806 /*
3807  * BcmFlash2xCorruptSig : this API is used to corrupt the written sig in Bcm Header present in flash section.
3808  * It will corrupt the sig, if Section is writable, by making first bytes as zero.
3809  * @Adapater :- Bcm Driver Private Data Structure
3810  * @eFlash2xSectionVal :- Flash section val which has header
3811  *
3812  * Return Value :-
3813  *      Success :- If Section is present and writable, corrupt the sig and return STATUS_SUCCESS
3814  *      Failure :-Return negative error code
3815  */
3816
3817 int BcmFlash2xCorruptSig(struct bcm_mini_adapter *Adapter, enum bcm_flash2x_section_val eFlash2xSectionVal)
3818 {
3819         int Status = STATUS_SUCCESS;
3820
3821         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Section Value :%x\n", eFlash2xSectionVal);
3822
3823         if ((eFlash2xSectionVal == DSD0) || (eFlash2xSectionVal == DSD1) || (eFlash2xSectionVal == DSD2)) {
3824                 Status = CorruptDSDSig(Adapter, eFlash2xSectionVal);
3825         } else if (eFlash2xSectionVal == ISO_IMAGE1 || eFlash2xSectionVal == ISO_IMAGE2) {
3826                 Status = CorruptISOSig(Adapter, eFlash2xSectionVal);
3827         } else {
3828                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Given Section <%d>does not have Header", eFlash2xSectionVal);
3829                 return STATUS_SUCCESS;
3830         }
3831         return Status;
3832 }
3833
3834 /*
3835  *BcmFlash2xWriteSig :-this API is used to Write the sig if requested Section has
3836  *                                        header and  Write Permission.
3837  * @Adapater :- Bcm Driver Private Data Structure
3838  * @eFlashSectionVal :- Flash section val which has header
3839  *
3840  * Return Value :-
3841  *      Success :- If Section is present and writable write the sig and return STATUS_SUCCESS
3842  *      Failure :-Return negative error code
3843  */
3844
3845 int BcmFlash2xWriteSig(struct bcm_mini_adapter *Adapter, enum bcm_flash2x_section_val eFlashSectionVal)
3846 {
3847         unsigned int uiSignature = 0;
3848         unsigned int uiOffset = 0;
3849
3850         /* struct bcm_dsd_header dsdHeader = {0}; */
3851         if (Adapter->bSigCorrupted == FALSE) {
3852                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Signature is not corrupted by driver, hence not restoring\n");
3853                 return STATUS_SUCCESS;
3854         }
3855
3856         if (Adapter->bAllDSDWriteAllow == FALSE) {
3857                 if (IsSectionWritable(Adapter, eFlashSectionVal) == FALSE) {
3858                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Section is not Writable...Hence can't Write signature");
3859                         return SECTOR_IS_NOT_WRITABLE;
3860                 }
3861         }
3862
3863         if ((eFlashSectionVal == DSD0) || (eFlashSectionVal == DSD1) || (eFlashSectionVal == DSD2)) {
3864                 uiSignature = htonl(DSD_IMAGE_MAGIC_NUMBER);
3865                 uiOffset = Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader;
3866
3867                 uiOffset += FIELD_OFFSET_IN_HEADER(struct bcm_dsd_header *, DSDImageMagicNumber);
3868
3869                 if ((ReadDSDSignature(Adapter, eFlashSectionVal) & 0xFF000000) != CORRUPTED_PATTERN) {
3870                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Corrupted Pattern is not there. Hence won't write sig");
3871                         return STATUS_FAILURE;
3872                 }
3873         } else if ((eFlashSectionVal == ISO_IMAGE1) || (eFlashSectionVal == ISO_IMAGE2)) {
3874                 uiSignature = htonl(ISO_IMAGE_MAGIC_NUMBER);
3875                 /* uiOffset = 0; */
3876                 uiOffset = FIELD_OFFSET_IN_HEADER(struct bcm_iso_header *, ISOImageMagicNumber);
3877                 if ((ReadISOSignature(Adapter, eFlashSectionVal) & 0xFF000000) != CORRUPTED_PATTERN) {
3878                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Currupted Pattern is not there. Hence won't write sig");
3879                         return STATUS_FAILURE;
3880                 }
3881         } else {
3882                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "GIVEN SECTION< %d > IS NOT VALID FOR SIG WRITE...", eFlashSectionVal);
3883                 return STATUS_FAILURE;
3884         }
3885
3886         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Restoring the signature");
3887
3888         Adapter->bHeaderChangeAllowed = TRUE;
3889         Adapter->bSigCorrupted = FALSE;
3890         BcmFlash2xBulkWrite(Adapter, &uiSignature, eFlashSectionVal, uiOffset, SIGNATURE_SIZE, TRUE);
3891         Adapter->bHeaderChangeAllowed = FALSE;
3892
3893         return STATUS_SUCCESS;
3894 }
3895
3896 /*
3897  * validateFlash2xReadWrite :- This API is used to validate the user request for Read/Write.
3898  *                                                    if requested Bytes goes beyond the Requested section, it reports error.
3899  * @Adapater :- Bcm Driver Private Data Structure
3900  * @psFlash2xReadWrite :-Flash2x Read/write structure pointer
3901  *
3902  * Return values:-Return TRUE is request is valid else FALSE.
3903  */
3904
3905 int validateFlash2xReadWrite(struct bcm_mini_adapter *Adapter, struct bcm_flash2x_readwrite *psFlash2xReadWrite)
3906 {
3907         unsigned int uiNumOfBytes = 0;
3908         unsigned int uiSectStartOffset = 0;
3909         unsigned int uiSectEndOffset = 0;
3910
3911         uiNumOfBytes = psFlash2xReadWrite->numOfBytes;
3912
3913         if (IsSectionExistInFlash(Adapter, psFlash2xReadWrite->Section) != TRUE) {
3914                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Section<%x> does not exixt in Flash", psFlash2xReadWrite->Section);
3915                 return FALSE;
3916         }
3917         uiSectStartOffset = BcmGetSectionValStartOffset(Adapter, psFlash2xReadWrite->Section);
3918         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Start offset :%x ,section :%d\n", uiSectStartOffset, psFlash2xReadWrite->Section);
3919         if ((psFlash2xReadWrite->Section == ISO_IMAGE1) || (psFlash2xReadWrite->Section == ISO_IMAGE2)) {
3920                 if (psFlash2xReadWrite->Section == ISO_IMAGE1) {
3921                         uiSectEndOffset = BcmGetSectionValEndOffset(Adapter, ISO_IMAGE1) -
3922                                 BcmGetSectionValStartOffset(Adapter, ISO_IMAGE1) +
3923                                 BcmGetSectionValEndOffset(Adapter, ISO_IMAGE1_PART2) -
3924                                 BcmGetSectionValStartOffset(Adapter, ISO_IMAGE1_PART2) +
3925                                 BcmGetSectionValEndOffset(Adapter, ISO_IMAGE1_PART3) -
3926                                 BcmGetSectionValStartOffset(Adapter, ISO_IMAGE1_PART3);
3927                 } else if (psFlash2xReadWrite->Section == ISO_IMAGE2) {
3928                         uiSectEndOffset = BcmGetSectionValEndOffset(Adapter, ISO_IMAGE2) -
3929                                 BcmGetSectionValStartOffset(Adapter, ISO_IMAGE2) +
3930                                 BcmGetSectionValEndOffset(Adapter, ISO_IMAGE2_PART2) -
3931                                 BcmGetSectionValStartOffset(Adapter, ISO_IMAGE2_PART2) +
3932                                 BcmGetSectionValEndOffset(Adapter, ISO_IMAGE2_PART3) -
3933                                 BcmGetSectionValStartOffset(Adapter, ISO_IMAGE2_PART3);
3934                 }
3935
3936                 /* since this uiSectEndoffset is the size of iso Image. hence for calculating the virtual endoffset
3937                  * it should be added in startoffset. so that check done in last of this function can be valued.
3938                  */
3939                 uiSectEndOffset = uiSectStartOffset + uiSectEndOffset;
3940
3941                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Total size of the ISO Image :%x", uiSectEndOffset);
3942         } else
3943                 uiSectEndOffset = BcmGetSectionValEndOffset(Adapter, psFlash2xReadWrite->Section);
3944
3945         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "End offset :%x\n", uiSectEndOffset);
3946
3947         /* Checking the boundary condition */
3948         if ((uiSectStartOffset + psFlash2xReadWrite->offset + uiNumOfBytes) <= uiSectEndOffset)
3949                 return TRUE;
3950         else {
3951                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Invalid Request....");
3952                 return FALSE;
3953         }
3954 }
3955
3956 /*
3957  * IsFlash2x :- check for Flash 2.x
3958  * Adapater :- Bcm Driver Private Data Structure
3959  *
3960  * Return value:-
3961  *      return TRUE if flah2.x of hgher version else return false.
3962  */
3963
3964 int IsFlash2x(struct bcm_mini_adapter *Adapter)
3965 {
3966         if (Adapter->uiFlashLayoutMajorVersion >= FLASH_2X_MAJOR_NUMBER)
3967                 return TRUE;
3968         else
3969                 return FALSE;
3970 }
3971
3972 /*
3973  * GetFlashBaseAddr :- Calculate the Flash Base address
3974  * @Adapater :- Bcm Driver Private Data Structure
3975  *
3976  * Return Value:-
3977  *      Success :- Base Address of the Flash
3978  */
3979
3980 static int GetFlashBaseAddr(struct bcm_mini_adapter *Adapter)
3981 {
3982         unsigned int uiBaseAddr = 0;
3983
3984         if (Adapter->bDDRInitDone) {
3985                 /*
3986                  * For All Valid Flash Versions... except 1.1, take the value from FlashBaseAddr
3987                  * In case of Raw Read... use the default value
3988                  */
3989                 if (Adapter->uiFlashLayoutMajorVersion && (Adapter->bFlashRawRead == FALSE) &&
3990                         !((Adapter->uiFlashLayoutMajorVersion == 1) && (Adapter->uiFlashLayoutMinorVersion == 1)))
3991                         uiBaseAddr = Adapter->uiFlashBaseAdd;
3992                 else
3993                         uiBaseAddr = FLASH_CONTIGIOUS_START_ADDR_AFTER_INIT;
3994         } else {
3995                 /*
3996                  * For All Valid Flash Versions... except 1.1, take the value from FlashBaseAddr
3997                  * In case of Raw Read... use the default value
3998                  */
3999                 if (Adapter->uiFlashLayoutMajorVersion && (Adapter->bFlashRawRead == FALSE) &&
4000                         !((Adapter->uiFlashLayoutMajorVersion == 1) && (Adapter->uiFlashLayoutMinorVersion == 1)))
4001                         uiBaseAddr = Adapter->uiFlashBaseAdd | FLASH_CONTIGIOUS_START_ADDR_BEFORE_INIT;
4002                 else
4003                         uiBaseAddr = FLASH_CONTIGIOUS_START_ADDR_BEFORE_INIT;
4004         }
4005
4006         return uiBaseAddr;
4007 }
4008
4009 /*
4010  * BcmCopySection :- This API is used to copy the One section in another. Both section should
4011  *                                  be contiuous and of same size. Hence this Will not be applicabe to copy ISO.
4012  *
4013  * @Adapater :- Bcm Driver Private Data Structure
4014  * @SrcSection :- Source section From where data has to be copied
4015  * @DstSection :- Destination section to which data has to be copied
4016  * @offset :- Offset from/to  where data has to be copied from one section to another.
4017  * @numOfBytes :- number of byes that has to be copyed from one section to another at given offset.
4018  *                           in case of numofBytes  equal zero complete section will be copied.
4019  * Return Values-
4020  *      Success : Return STATUS_SUCCESS
4021  *      Faillure :- return negative error code
4022  */
4023
4024 int BcmCopySection(struct bcm_mini_adapter *Adapter,
4025                 enum bcm_flash2x_section_val SrcSection,
4026                 enum bcm_flash2x_section_val DstSection,
4027                 unsigned int offset,
4028                 unsigned int numOfBytes)
4029 {
4030         unsigned int BuffSize = 0;
4031         unsigned int BytesToBeCopied = 0;
4032         PUCHAR pBuff = NULL;
4033         int Status = STATUS_SUCCESS;
4034
4035         if (SrcSection == DstSection) {
4036                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Source and Destination should be different ...try again");
4037                 return -EINVAL;
4038         }
4039
4040         if ((SrcSection != DSD0) && (SrcSection != DSD1) && (SrcSection != DSD2)) {
4041                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Source should be DSD subsection");
4042                 return -EINVAL;
4043         }
4044
4045         if ((DstSection != DSD0) && (DstSection != DSD1) && (DstSection != DSD2)) {
4046                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Destination should be DSD subsection");
4047                 return -EINVAL;
4048         }
4049
4050         /* if offset zero means have to copy complete secton */
4051         if (numOfBytes == 0) {
4052                 numOfBytes = BcmGetSectionValEndOffset(Adapter, SrcSection)
4053                         - BcmGetSectionValStartOffset(Adapter, SrcSection);
4054
4055                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Section Size :0x%x", numOfBytes);
4056         }
4057
4058         if ((offset + numOfBytes) > BcmGetSectionValEndOffset(Adapter, SrcSection)
4059                 - BcmGetSectionValStartOffset(Adapter, SrcSection)) {
4060                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, " Input parameters going beyond the section offS: %x numB: %x of Source Section\n",
4061                                 offset, numOfBytes);
4062                 return -EINVAL;
4063         }
4064
4065         if ((offset + numOfBytes) > BcmGetSectionValEndOffset(Adapter, DstSection)
4066                 - BcmGetSectionValStartOffset(Adapter, DstSection)) {
4067                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Input parameters going beyond the section offS: %x numB: %x of Destination Section\n",
4068                                 offset, numOfBytes);
4069                 return -EINVAL;
4070         }
4071
4072         if (numOfBytes > Adapter->uiSectorSize)
4073                 BuffSize = Adapter->uiSectorSize;
4074         else
4075                 BuffSize = numOfBytes;
4076
4077         pBuff = (PCHAR)kzalloc(BuffSize, GFP_KERNEL);
4078         if (!pBuff) {
4079                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Memory allocation failed.. ");
4080                 return -ENOMEM;
4081         }
4082
4083         BytesToBeCopied = Adapter->uiSectorSize;
4084         if (offset % Adapter->uiSectorSize)
4085                 BytesToBeCopied = Adapter->uiSectorSize - (offset % Adapter->uiSectorSize);
4086         if (BytesToBeCopied > numOfBytes)
4087                 BytesToBeCopied = numOfBytes;
4088
4089         Adapter->bHeaderChangeAllowed = TRUE;
4090
4091         do {
4092                 Status = BcmFlash2xBulkRead(Adapter, (PUINT)pBuff, SrcSection , offset, BytesToBeCopied);
4093                 if (Status) {
4094                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Read failed at offset :%d for NOB :%d", SrcSection, BytesToBeCopied);
4095                         break;
4096                 }
4097                 Status = BcmFlash2xBulkWrite(Adapter, (PUINT)pBuff, DstSection, offset, BytesToBeCopied, FALSE);
4098                 if (Status) {
4099                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Write failed at offset :%d for NOB :%d", DstSection, BytesToBeCopied);
4100                         break;
4101                 }
4102                 offset = offset + BytesToBeCopied;
4103                 numOfBytes = numOfBytes - BytesToBeCopied;
4104                 if (numOfBytes) {
4105                         if (numOfBytes > Adapter->uiSectorSize)
4106                                 BytesToBeCopied = Adapter->uiSectorSize;
4107                         else
4108                                 BytesToBeCopied = numOfBytes;
4109                 }
4110         } while (numOfBytes > 0);
4111
4112         kfree(pBuff);
4113         Adapter->bHeaderChangeAllowed = FALSE;
4114
4115         return Status;
4116 }
4117
4118 /*
4119  * SaveHeaderIfPresent :- This API is use to Protect the Header in case of Header Sector write
4120  * @Adapater :- Bcm Driver Private Data Structure
4121  * @pBuff :- Data buffer that has to be written in sector having the header map.
4122  * @uiOffset :- Flash offset that has to be written.
4123  *
4124  * Return value :-
4125  *      Success :- On success return STATUS_SUCCESS
4126  *      Faillure :- Return negative error code
4127  */
4128
4129 int SaveHeaderIfPresent(struct bcm_mini_adapter *Adapter, PUCHAR pBuff, unsigned int uiOffset)
4130 {
4131         unsigned int offsetToProtect = 0, HeaderSizeToProtect = 0;
4132         BOOLEAN bHasHeader = FALSE;
4133         PUCHAR pTempBuff = NULL;
4134         unsigned int uiSectAlignAddr = 0;
4135         unsigned int sig = 0;
4136
4137         /* making the offset sector aligned */
4138         uiSectAlignAddr = uiOffset & ~(Adapter->uiSectorSize - 1);
4139
4140         if ((uiSectAlignAddr == BcmGetSectionValEndOffset(Adapter, DSD2) - Adapter->uiSectorSize) ||
4141                 (uiSectAlignAddr == BcmGetSectionValEndOffset(Adapter, DSD1) - Adapter->uiSectorSize) ||
4142                 (uiSectAlignAddr == BcmGetSectionValEndOffset(Adapter, DSD0) - Adapter->uiSectorSize)) {
4143                 /* offset from the sector boundary having the header map */
4144                 offsetToProtect = Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader % Adapter->uiSectorSize;
4145                 HeaderSizeToProtect = sizeof(struct bcm_dsd_header);
4146                 bHasHeader = TRUE;
4147         }
4148
4149         if (uiSectAlignAddr == BcmGetSectionValStartOffset(Adapter, ISO_IMAGE1) ||
4150                 uiSectAlignAddr == BcmGetSectionValStartOffset(Adapter, ISO_IMAGE2)) {
4151                 offsetToProtect = 0;
4152                 HeaderSizeToProtect = sizeof(struct bcm_iso_header);
4153                 bHasHeader = TRUE;
4154         }
4155         /* If Header is present overwrite passed buffer with this */
4156         if (bHasHeader && (Adapter->bHeaderChangeAllowed == FALSE)) {
4157                 pTempBuff = (PUCHAR)kzalloc(HeaderSizeToProtect, GFP_KERNEL);
4158                 if (!pTempBuff) {
4159                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Memory allocation failed");
4160                         return -ENOMEM;
4161                 }
4162                 /* Read header */
4163                 BeceemFlashBulkRead(Adapter, (PUINT)pTempBuff, (uiSectAlignAddr + offsetToProtect), HeaderSizeToProtect);
4164                 BCM_DEBUG_PRINT_BUFFER(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, pTempBuff, HeaderSizeToProtect);
4165                 /* Replace Buffer content with Header */
4166                 memcpy(pBuff + offsetToProtect, pTempBuff, HeaderSizeToProtect);
4167
4168                 kfree(pTempBuff);
4169         }
4170         if (bHasHeader && Adapter->bSigCorrupted) {
4171                 sig = *((PUINT)(pBuff + offsetToProtect + FIELD_OFFSET_IN_HEADER(struct bcm_dsd_header *, DSDImageMagicNumber)));
4172                 sig = ntohl(sig);
4173                 if ((sig & 0xFF000000) != CORRUPTED_PATTERN) {
4174                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Desired pattern is not at sig offset. Hence won't restore");
4175                         Adapter->bSigCorrupted = FALSE;
4176                         return STATUS_SUCCESS;
4177                 }
4178                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, " Corrupted sig is :%X", sig);
4179                 *((PUINT)(pBuff + offsetToProtect + FIELD_OFFSET_IN_HEADER(struct bcm_dsd_header *, DSDImageMagicNumber))) = htonl(DSD_IMAGE_MAGIC_NUMBER);
4180                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Restoring the signature in Header Write only");
4181                 Adapter->bSigCorrupted = FALSE;
4182         }
4183
4184         return STATUS_SUCCESS;
4185 }
4186
4187 /*
4188  * BcmDoChipSelect : This will selcet the appropriate chip for writing.
4189  * @Adapater :- Bcm Driver Private Data Structure
4190  *
4191  * OutPut:-
4192  *      Select the Appropriate chip and retrn status Success
4193  */
4194 static int BcmDoChipSelect(struct bcm_mini_adapter *Adapter, unsigned int offset)
4195 {
4196         unsigned int FlashConfig = 0;
4197         int ChipNum = 0;
4198         unsigned int GPIOConfig = 0;
4199         unsigned int PartNum = 0;
4200
4201         ChipNum = offset / FLASH_PART_SIZE;
4202
4203         /*
4204          * Chip Select mapping to enable flash0.
4205          * To select flash 0, we have to OR with (0<<12).
4206          * ORing 0 will have no impact so not doing that part.
4207          * In future if Chip select value changes from 0 to non zero,
4208          * That needs be taken care with backward comaptibility. No worries for now.
4209          */
4210
4211         /*
4212          * SelectedChip Variable is the selection that the host is 100% Sure the same as what the register will hold. This can be ONLY ensured
4213          * if the Chip doesn't goes to low power mode while the flash operation is in progress (NVMRdmWrmLock is taken)
4214          * Before every new Flash Write operation, we reset the variable. This is to ensure that after any wake-up from
4215          * power down modes (Idle mode/shutdown mode), the values in the register will be different.
4216          */
4217
4218         if (Adapter->SelectedChip == ChipNum)
4219                 return STATUS_SUCCESS;
4220
4221         /* BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Selected Chip :%x", ChipNum); */
4222         Adapter->SelectedChip = ChipNum;
4223
4224         /* bit[13..12]  will select the appropriate chip */
4225         rdmalt(Adapter, FLASH_CONFIG_REG, &FlashConfig, 4);
4226         rdmalt(Adapter, FLASH_GPIO_CONFIG_REG, &GPIOConfig, 4);
4227         {
4228                 switch (ChipNum) {
4229                 case 0:
4230                         PartNum = 0;
4231                         break;
4232                 case 1:
4233                         PartNum = 3;
4234                         GPIOConfig |= (0x4 << CHIP_SELECT_BIT12);
4235                         break;
4236                 case 2:
4237                         PartNum = 1;
4238                         GPIOConfig |= (0x1 << CHIP_SELECT_BIT12);
4239                         break;
4240                 case 3:
4241                         PartNum = 2;
4242                         GPIOConfig |= (0x2 << CHIP_SELECT_BIT12);
4243                         break;
4244                 }
4245         }
4246         /* In case the bits already written in the FLASH_CONFIG_REG is same as what the user desired,
4247          * nothing to do... can return immediately.
4248          * ASSUMPTION: FLASH_GPIO_CONFIG_REG will be in sync with FLASH_CONFIG_REG.
4249          * Even if the chip goes to low power mode, it should wake with values in each register in sync with each other.
4250          * These values are not written by host other than during CHIP_SELECT.
4251          */
4252         if (PartNum == ((FlashConfig >> CHIP_SELECT_BIT12) & 0x3))
4253                 return STATUS_SUCCESS;
4254
4255         /* clearing the bit[13..12] */
4256         FlashConfig &= 0xFFFFCFFF;
4257         FlashConfig = (FlashConfig | (PartNum<<CHIP_SELECT_BIT12)); /* 00 */
4258
4259         wrmalt(Adapter, FLASH_GPIO_CONFIG_REG, &GPIOConfig, 4);
4260         udelay(100);
4261
4262         wrmalt(Adapter, FLASH_CONFIG_REG, &FlashConfig, 4);
4263         udelay(100);
4264
4265         return STATUS_SUCCESS;
4266 }
4267
4268 int ReadDSDSignature(struct bcm_mini_adapter *Adapter, enum bcm_flash2x_section_val dsd)
4269 {
4270         unsigned int uiDSDsig = 0;
4271         /* unsigned int sigoffsetInMap = 0;
4272          * struct bcm_dsd_header dsdHeader = {0};
4273          */
4274
4275         /* sigoffsetInMap =(PUCHAR)&(dsdHeader.DSDImageMagicNumber) -(PUCHAR)&dsdHeader; */
4276
4277         if (dsd != DSD0 && dsd != DSD1 && dsd != DSD2) {
4278                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "passed section value is not for DSDs");
4279                 return STATUS_FAILURE;
4280         }
4281         BcmFlash2xBulkRead(Adapter,
4282                         &uiDSDsig,
4283                         dsd,
4284                         Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader + FIELD_OFFSET_IN_HEADER(struct bcm_dsd_header *, DSDImageMagicNumber),
4285                         SIGNATURE_SIZE);
4286
4287         uiDSDsig = ntohl(uiDSDsig);
4288         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "DSD SIG :%x", uiDSDsig);
4289
4290         return uiDSDsig;
4291 }
4292
4293 int ReadDSDPriority(struct bcm_mini_adapter *Adapter, enum bcm_flash2x_section_val dsd)
4294 {
4295         /* unsigned int priOffsetInMap = 0 ; */
4296         unsigned int uiDSDPri = STATUS_FAILURE;
4297         /* struct bcm_dsd_header dsdHeader = {0};
4298          * priOffsetInMap = (PUCHAR)&(dsdHeader.DSDImagePriority) -(PUCHAR)&dsdHeader;
4299          */
4300         if (IsSectionWritable(Adapter, dsd)) {
4301                 if (ReadDSDSignature(Adapter, dsd) == DSD_IMAGE_MAGIC_NUMBER) {
4302                         BcmFlash2xBulkRead(Adapter,
4303                                         &uiDSDPri,
4304                                         dsd,
4305                                         Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader + FIELD_OFFSET_IN_HEADER(struct bcm_dsd_header *, DSDImagePriority),
4306                                         4);
4307
4308                         uiDSDPri = ntohl(uiDSDPri);
4309                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "DSD<%x> Priority :%x", dsd, uiDSDPri);
4310                 }
4311         }
4312
4313         return uiDSDPri;
4314 }
4315
4316 enum bcm_flash2x_section_val getHighestPriDSD(struct bcm_mini_adapter *Adapter)
4317 {
4318         int DSDHighestPri = STATUS_FAILURE;
4319         int DsdPri = 0;
4320         enum bcm_flash2x_section_val HighestPriDSD = 0;
4321
4322         if (IsSectionWritable(Adapter, DSD2)) {
4323                 DSDHighestPri = ReadDSDPriority(Adapter, DSD2);
4324                 HighestPriDSD = DSD2;
4325         }
4326
4327         if (IsSectionWritable(Adapter, DSD1)) {
4328                 DsdPri = ReadDSDPriority(Adapter, DSD1);
4329                 if (DSDHighestPri  < DsdPri) {
4330                         DSDHighestPri = DsdPri;
4331                         HighestPriDSD = DSD1;
4332                 }
4333         }
4334
4335         if (IsSectionWritable(Adapter, DSD0)) {
4336                 DsdPri = ReadDSDPriority(Adapter, DSD0);
4337                 if (DSDHighestPri  < DsdPri) {
4338                         DSDHighestPri = DsdPri;
4339                         HighestPriDSD = DSD0;
4340                 }
4341         }
4342         if (HighestPriDSD)
4343                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Highest DSD :%x , and its  Pri :%x", HighestPriDSD, DSDHighestPri);
4344
4345         return  HighestPriDSD;
4346 }
4347
4348 int ReadISOSignature(struct bcm_mini_adapter *Adapter, enum bcm_flash2x_section_val iso)
4349 {
4350         unsigned int uiISOsig = 0;
4351         /* unsigned int sigoffsetInMap = 0;
4352          * struct bcm_iso_header ISOHeader = {0};
4353          * sigoffsetInMap =(PUCHAR)&(ISOHeader.ISOImageMagicNumber) -(PUCHAR)&ISOHeader;
4354          */
4355         if (iso != ISO_IMAGE1 && iso != ISO_IMAGE2) {
4356                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "passed section value is not for ISOs");
4357                 return STATUS_FAILURE;
4358         }
4359         BcmFlash2xBulkRead(Adapter,
4360                         &uiISOsig,
4361                         iso,
4362                         0 + FIELD_OFFSET_IN_HEADER(struct bcm_iso_header *, ISOImageMagicNumber),
4363                         SIGNATURE_SIZE);
4364
4365         uiISOsig = ntohl(uiISOsig);
4366         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "ISO SIG :%x", uiISOsig);
4367
4368         return uiISOsig;
4369 }
4370
4371 int ReadISOPriority(struct bcm_mini_adapter *Adapter, enum bcm_flash2x_section_val iso)
4372 {
4373         unsigned int ISOPri = STATUS_FAILURE;
4374         if (IsSectionWritable(Adapter, iso)) {
4375                 if (ReadISOSignature(Adapter, iso) == ISO_IMAGE_MAGIC_NUMBER) {
4376                         BcmFlash2xBulkRead(Adapter,
4377                                         &ISOPri,
4378                                         iso,
4379                                         0 + FIELD_OFFSET_IN_HEADER(struct bcm_iso_header *, ISOImagePriority),
4380                                         4);
4381
4382                         ISOPri = ntohl(ISOPri);
4383                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "ISO<%x> Priority :%x", iso, ISOPri);
4384                 }
4385         }
4386
4387         return ISOPri;
4388 }
4389
4390 enum bcm_flash2x_section_val getHighestPriISO(struct bcm_mini_adapter *Adapter)
4391 {
4392         int ISOHighestPri = STATUS_FAILURE;
4393         int ISOPri = 0;
4394         enum bcm_flash2x_section_val HighestPriISO = NO_SECTION_VAL;
4395
4396         if (IsSectionWritable(Adapter, ISO_IMAGE2)) {
4397                 ISOHighestPri = ReadISOPriority(Adapter, ISO_IMAGE2);
4398                 HighestPriISO = ISO_IMAGE2;
4399         }
4400
4401         if (IsSectionWritable(Adapter, ISO_IMAGE1)) {
4402                 ISOPri = ReadISOPriority(Adapter, ISO_IMAGE1);
4403                 if (ISOHighestPri  < ISOPri) {
4404                         ISOHighestPri = ISOPri;
4405                         HighestPriISO = ISO_IMAGE1;
4406                 }
4407         }
4408         if (HighestPriISO)
4409                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Highest ISO :%x and its Pri :%x", HighestPriISO, ISOHighestPri);
4410
4411         return HighestPriISO;
4412 }
4413
4414 int WriteToFlashWithoutSectorErase(struct bcm_mini_adapter *Adapter,
4415                                 PUINT pBuff,
4416                                 enum bcm_flash2x_section_val eFlash2xSectionVal,
4417                                 unsigned int uiOffset,
4418                                 unsigned int uiNumBytes)
4419 {
4420         #if !defined(BCM_SHM_INTERFACE) || defined(FLASH_DIRECT_ACCESS)
4421                 unsigned int uiTemp = 0, value = 0;
4422                 unsigned int i = 0;
4423                 unsigned int uiPartOffset = 0;
4424         #endif
4425         unsigned int uiStartOffset = 0;
4426         /* Adding section start address */
4427         int Status = STATUS_SUCCESS;
4428         PUCHAR pcBuff = (PUCHAR)pBuff;
4429
4430         if (uiNumBytes % Adapter->ulFlashWriteSize) {
4431                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Writing without Sector Erase for non-FlashWriteSize number of bytes 0x%x\n", uiNumBytes);
4432                 return STATUS_FAILURE;
4433         }
4434
4435         uiStartOffset = BcmGetSectionValStartOffset(Adapter, eFlash2xSectionVal);
4436
4437         if (IsSectionExistInVendorInfo(Adapter, eFlash2xSectionVal))
4438                 return vendorextnWriteSectionWithoutErase(Adapter, pcBuff, eFlash2xSectionVal, uiOffset, uiNumBytes);
4439
4440         uiOffset = uiOffset + uiStartOffset;
4441
4442         #if defined(BCM_SHM_INTERFACE) && !defined(FLASH_DIRECT_ACCESS)
4443                 Status = bcmflash_raw_writenoerase((uiOffset / FLASH_PART_SIZE), (uiOffset % FLASH_PART_SIZE), pcBuff, uiNumBytes);
4444         #else
4445                 rdmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
4446                 value = 0;
4447                 wrmalt(Adapter, 0x0f000C80, &value, sizeof(value));
4448
4449                 Adapter->SelectedChip = RESET_CHIP_SELECT;
4450                 BcmDoChipSelect(Adapter, uiOffset);
4451                 uiPartOffset = (uiOffset & (FLASH_PART_SIZE - 1)) + GetFlashBaseAddr(Adapter);
4452
4453                 for (i = 0 ; i < uiNumBytes; i += Adapter->ulFlashWriteSize) {
4454                         if (Adapter->ulFlashWriteSize == BYTE_WRITE_SUPPORT)
4455                                 Status = flashByteWrite(Adapter, uiPartOffset, pcBuff);
4456                         else
4457                                 Status = flashWrite(Adapter, uiPartOffset, pcBuff);
4458
4459                         if (Status != STATUS_SUCCESS)
4460                                 break;
4461
4462                         pcBuff = pcBuff + Adapter->ulFlashWriteSize;
4463                         uiPartOffset = uiPartOffset +  Adapter->ulFlashWriteSize;
4464                 }
4465                 wrmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
4466                 Adapter->SelectedChip = RESET_CHIP_SELECT;
4467         #endif
4468
4469         return Status;
4470 }
4471
4472 BOOLEAN IsSectionExistInFlash(struct bcm_mini_adapter *Adapter, enum bcm_flash2x_section_val section)
4473 {
4474         BOOLEAN SectionPresent = FALSE;
4475
4476         switch (section) {
4477         case ISO_IMAGE1:
4478                 if ((Adapter->psFlash2xCSInfo->OffsetISOImage1Part1Start != UNINIT_PTR_IN_CS) &&
4479                         (IsNonCDLessDevice(Adapter) == FALSE))
4480                         SectionPresent = TRUE;
4481                 break;
4482         case ISO_IMAGE2:
4483                 if ((Adapter->psFlash2xCSInfo->OffsetISOImage2Part1Start != UNINIT_PTR_IN_CS) &&
4484                         (IsNonCDLessDevice(Adapter) == FALSE))
4485                         SectionPresent = TRUE;
4486                 break;
4487         case DSD0:
4488                 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSDStart != UNINIT_PTR_IN_CS)
4489                         SectionPresent = TRUE;
4490                 break;
4491         case DSD1:
4492                 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD1Start != UNINIT_PTR_IN_CS)
4493                         SectionPresent = TRUE;
4494                 break;
4495         case DSD2:
4496                 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD2Start != UNINIT_PTR_IN_CS)
4497                         SectionPresent = TRUE;
4498                 break;
4499         case VSA0:
4500                 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSAStart != UNINIT_PTR_IN_CS)
4501                         SectionPresent = TRUE;
4502                 break;
4503         case VSA1:
4504                 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA1Start != UNINIT_PTR_IN_CS)
4505                         SectionPresent = TRUE;
4506                 break;
4507         case VSA2:
4508                 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA2Start != UNINIT_PTR_IN_CS)
4509                         SectionPresent = TRUE;
4510                 break;
4511         case SCSI:
4512                 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForScsiFirmware != UNINIT_PTR_IN_CS)
4513                         SectionPresent = TRUE;
4514                 break;
4515         case CONTROL_SECTION:
4516                 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForControlSectionStart != UNINIT_PTR_IN_CS)
4517                         SectionPresent = TRUE;
4518                 break;
4519         default:
4520                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Section Does not exist in Flash 2.x");
4521                 SectionPresent =  FALSE;
4522         }
4523
4524         return SectionPresent;
4525 }
4526
4527 int IsSectionWritable(struct bcm_mini_adapter *Adapter, enum bcm_flash2x_section_val Section)
4528 {
4529         int offset = STATUS_FAILURE;
4530         int Status = FALSE;
4531
4532         if (IsSectionExistInFlash(Adapter, Section) == FALSE) {
4533                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Section <%d> does not exixt", Section);
4534                 return FALSE;
4535         }
4536
4537         offset = BcmGetSectionValStartOffset(Adapter, Section);
4538         if (offset == INVALID_OFFSET) {
4539                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Section<%d> does not exixt", Section);
4540                 return FALSE;
4541         }
4542
4543         if (IsSectionExistInVendorInfo(Adapter, Section))
4544                 return !(Adapter->psFlash2xVendorInfo->VendorSection[Section].AccessFlags & FLASH2X_SECTION_RO);
4545
4546         Status = IsOffsetWritable(Adapter, offset);
4547         return Status;
4548 }
4549
4550 static int CorruptDSDSig(struct bcm_mini_adapter *Adapter, enum bcm_flash2x_section_val eFlash2xSectionVal)
4551 {
4552         PUCHAR pBuff = NULL;
4553         unsigned int sig = 0;
4554         unsigned int uiOffset = 0;
4555         unsigned int BlockStatus = 0;
4556         unsigned int uiSectAlignAddr = 0;
4557
4558         Adapter->bSigCorrupted = FALSE;
4559         if (Adapter->bAllDSDWriteAllow == FALSE) {
4560                 if (IsSectionWritable(Adapter, eFlash2xSectionVal) != TRUE) {
4561                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Section is not Writable...Hence can't Corrupt signature");
4562                         return SECTOR_IS_NOT_WRITABLE;
4563                 }
4564         }
4565
4566         pBuff = (PUCHAR)kzalloc(MAX_RW_SIZE, GFP_KERNEL);
4567         if (!pBuff) {
4568                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Can't allocate memorey");
4569                 return -ENOMEM;
4570         }
4571
4572         uiOffset = Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader + sizeof(struct bcm_dsd_header);
4573         uiOffset -= MAX_RW_SIZE;
4574
4575         BcmFlash2xBulkRead(Adapter, (PUINT)pBuff, eFlash2xSectionVal, uiOffset, MAX_RW_SIZE);
4576
4577         sig = *((PUINT)(pBuff + 12));
4578         sig = ntohl(sig);
4579         BCM_DEBUG_PRINT_BUFFER(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, pBuff, MAX_RW_SIZE);
4580         /* Now corrupting the sig by corrupting 4th last Byte. */
4581         *(pBuff + 12) = 0;
4582
4583         if (sig == DSD_IMAGE_MAGIC_NUMBER) {
4584                 Adapter->bSigCorrupted = TRUE;
4585                 if (Adapter->ulFlashWriteSize == BYTE_WRITE_SUPPORT) {
4586                         uiSectAlignAddr = uiOffset & ~(Adapter->uiSectorSize - 1);
4587                         BlockStatus = BcmFlashUnProtectBlock(Adapter, uiSectAlignAddr, Adapter->uiSectorSize);
4588
4589                         WriteToFlashWithoutSectorErase(Adapter, (PUINT)(pBuff + 12), eFlash2xSectionVal,
4590                                                 (uiOffset + 12), BYTE_WRITE_SUPPORT);
4591                         if (BlockStatus) {
4592                                 BcmRestoreBlockProtectStatus(Adapter, BlockStatus);
4593                                 BlockStatus = 0;
4594                         }
4595                 } else {
4596                         WriteToFlashWithoutSectorErase(Adapter, (PUINT)pBuff, eFlash2xSectionVal,
4597                                                 uiOffset, MAX_RW_SIZE);
4598                 }
4599         } else {
4600                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "BCM Signature is not present in header");
4601                 kfree(pBuff);
4602
4603                 return STATUS_FAILURE;
4604         }
4605
4606         kfree(pBuff);
4607         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Corrupted the signature");
4608
4609         return STATUS_SUCCESS;
4610 }
4611
4612 static int CorruptISOSig(struct bcm_mini_adapter *Adapter, enum bcm_flash2x_section_val eFlash2xSectionVal)
4613 {
4614         PUCHAR pBuff = NULL;
4615         unsigned int sig = 0;
4616         unsigned int uiOffset = 0;
4617
4618         Adapter->bSigCorrupted = FALSE;
4619
4620         if (IsSectionWritable(Adapter, eFlash2xSectionVal) != TRUE) {
4621                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Section is not Writable...Hence can't Corrupt signature");
4622                 return SECTOR_IS_NOT_WRITABLE;
4623         }
4624
4625         pBuff = (PUCHAR)kzalloc(MAX_RW_SIZE, GFP_KERNEL);
4626         if (!pBuff) {
4627                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Can't allocate memorey");
4628                 return -ENOMEM;
4629         }
4630
4631         uiOffset = 0;
4632
4633         BcmFlash2xBulkRead(Adapter, (PUINT)pBuff, eFlash2xSectionVal, uiOffset, MAX_RW_SIZE);
4634
4635         sig = *((PUINT)pBuff);
4636         sig = ntohl(sig);
4637
4638         /* corrupt signature */
4639         *pBuff = 0;
4640
4641         if (sig == ISO_IMAGE_MAGIC_NUMBER) {
4642                 Adapter->bSigCorrupted = TRUE;
4643                 WriteToFlashWithoutSectorErase(Adapter, (PUINT)pBuff, eFlash2xSectionVal,
4644                                         uiOffset, Adapter->ulFlashWriteSize);
4645         } else {
4646                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "BCM Signature is not present in header");
4647                 kfree(pBuff);
4648
4649                 return STATUS_FAILURE;
4650         }
4651
4652         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Corrupted the signature");
4653         BCM_DEBUG_PRINT_BUFFER(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, pBuff, MAX_RW_SIZE);
4654
4655         kfree(pBuff);
4656         return STATUS_SUCCESS;
4657 }
4658
4659 BOOLEAN IsNonCDLessDevice(struct bcm_mini_adapter *Adapter)
4660 {
4661         if (Adapter->psFlash2xCSInfo->IsCDLessDeviceBootSig == NON_CDLESS_DEVICE_BOOT_SIG)
4662                 return TRUE;
4663         else
4664                 return FALSE;
4665 }