3 #define DWORD unsigned int
10 static unsigned int BcmGetFlashSectorSize(
struct bcm_mini_adapter *
Adapter,
unsigned int FlashSectorSizeSig,
unsigned int FlashSectorSize);
33 unsigned int uiOffset,
unsigned int uiNumBytes);
37 static int BeceemFlashBulkRead(
40 unsigned int uiOffset,
41 unsigned int uiNumBytes);
43 static int BeceemFlashBulkWrite(
46 unsigned int uiOffset,
47 unsigned int uiNumBytes,
67 unsigned int uiStatus = 0;
68 unsigned int value = 0;
69 unsigned int value1 = 0;
75 while (dwRetries != 0) {
92 uiData = (
UCHAR)value;
104 if (!(dwRetries%RETRIES_PER_DELAY))
132 unsigned int uiStatus = 0;
133 unsigned int value = 0;
134 unsigned int value1 = 0;
150 while (dwRetries != 0) {
162 if (dwNumWords == 4) {
169 }
else if (dwNumWords == 1) {
170 if ((uiStatus & EEPROM_READ_DATA_AVAIL) != 0) {
174 if (Adapter->
chip_id == 0xBECE0210)
187 if (dwRetries == 0) {
197 if (!(dwRetries%RETRIES_PER_DELAY))
201 for (dwIndex = 0; dwIndex < dwNumWords; dwIndex++) {
203 pvalue = (
PUCHAR)(pdwData + dwIndex);
248 unsigned int uiData[8] = {0};
249 unsigned int uiByteOffset = 0;
250 unsigned int uiTempOffset = 0;
254 uiTempOffset = uiOffset - (uiOffset %
MAX_RW_SIZE);
255 uiByteOffset = uiOffset - uiTempOffset;
262 if (uiByteOffset > 12)
273 unsigned char puMacAddr[6];
276 (
PUINT)&puMacAddr[0],
304 unsigned int uiOffset,
305 unsigned int uiNumBytes)
307 unsigned int uiData[4] = {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;
317 uiTempOffset = uiOffset - (uiOffset %
MAX_RW_SIZE);
318 uiExtraBytes = uiOffset - uiTempOffset;
320 if (uiBytesRemaining >= (
MAX_RW_SIZE - uiExtraBytes)) {
326 memcpy(pBuffer, (((
PUCHAR)&uiData[0]) + uiExtraBytes), uiBytesRemaining);
327 uiIndex += uiBytesRemaining;
328 uiOffset += uiBytesRemaining;
329 uiBytesRemaining = 0;
333 while (uiBytesRemaining && uiFailureRetries != 128) {
351 }
else if (uiBytesRemaining >= 4) {
353 memcpy(pcBuff + uiIndex, &uiData[0], 4);
355 uiBytesRemaining -= 4;
364 pCharBuff += uiIndex;
366 memcpy(pCharBuff, &uiData[0], uiBytesRemaining);
367 uiBytesRemaining = 0;
396 unsigned int uiOffset,
397 unsigned int uiNumBytes)
399 unsigned int uiIndex = 0;
400 unsigned int uiBytesToRead = uiNumBytes;
402 unsigned int uiPartOffset = 0;
413 #if defined(BCM_SHM_INTERFACE) && !defined(FLASH_DIRECT_ACCESS)
421 BcmDoChipSelect(Adapter, uiOffset);
422 uiPartOffset = (uiOffset & (FLASH_PART_SIZE - 1)) + GetFlashBaseAddr(Adapter);
424 uiBytesToRead = MAX_RW_SIZE - (uiOffset %
MAX_RW_SIZE);
425 uiBytesToRead =
MIN(uiNumBytes, uiBytesToRead);
427 bytes =
rdm(Adapter, uiPartOffset, (
PCHAR)pBuffer + uiIndex, uiBytesToRead);
434 uiIndex += uiBytesToRead;
435 uiOffset += uiBytesToRead;
436 uiNumBytes -= uiBytesToRead;
440 BcmDoChipSelect(Adapter, uiOffset);
441 uiPartOffset = (uiOffset & (FLASH_PART_SIZE - 1)) + GetFlashBaseAddr(Adapter);
443 uiBytesToRead =
MIN(uiNumBytes, MAX_RW_SIZE);
445 bytes =
rdm(Adapter, uiPartOffset, (
PCHAR)pBuffer + uiIndex, uiBytesToRead);
451 uiIndex += uiBytesToRead;
452 uiOffset += uiBytesToRead;
453 uiNumBytes -= uiBytesToRead;
495 unsigned int uiData = 0;
496 unsigned int uiIndex = 0;
507 if (uiData ==
BECM) {
508 for (uiIndex = 2; uiIndex <= 256; uiIndex *= 2) {
511 return uiIndex * 1024;
520 for (uiIndex = 2; uiIndex <= 256; uiIndex *= 2) {
522 if (uiData == 0xBABEFACE)
523 return uiIndex * 1024;
547 unsigned int numOfSectors)
549 unsigned int iIndex = 0, iRetries = 0;
550 unsigned int uiStatus = 0;
554 for (iIndex = 0; iIndex < numOfSectors; iIndex++) {
558 value = (0xd8000000 | (addr & 0xFFFFFF));
581 }
while ((uiStatus & 0x1) && (iRetries < 400));
583 if (uiStatus & 0x1) {
607 unsigned int uiOffset,
610 unsigned int uiStatus = 0;
634 value = (0x02000000 | (uiOffset & 0xFFFFFF));
656 if (iRetries && ((iRetries % FLASH_PER_RETRIES_DELAY) == 0))
659 }
while ((uiStatus & 0x1) && (iRetries > 0));
661 if (uiStatus & 0x1) {
684 unsigned int uiOffset,
691 unsigned int uiStatus = 0;
694 unsigned int uiErasePattern[4] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
700 if (!
memcmp(pData, uiErasePattern, MAX_RW_SIZE))
710 if (
wrm(Adapter, uiOffset, (
PCHAR)pData, MAX_RW_SIZE) < 0) {
736 if (iRetries && ((iRetries % FLASH_PER_RETRIES_DELAY) == 0))
738 }
while ((uiStatus & 0x1) && (iRetries > 0));
740 if (uiStatus & 0x1) {
762 unsigned int uiOffset,
765 unsigned int uiStatus = 0;
790 value = (0x02000000 | (uiOffset & 0xFFFFFF));
813 if (iRetries && ((iRetries % FLASH_PER_RETRIES_DELAY) == 0))
816 }
while ((uiStatus & 0x1) && (iRetries > 0));
818 if (uiStatus & 0x1) {
840 unsigned int uiOffset,
843 unsigned int uiStatus = 0;
847 unsigned int uiErasePattern[4] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
854 if (!
memcmp(pData, uiErasePattern, MAX_RW_SIZE))
863 if (
wrm(Adapter, uiOffset, (
PCHAR)pData, MAX_RW_SIZE) < 0) {
888 if (iRetries && ((iRetries % FLASH_PER_RETRIES_DELAY) == 0))
891 }
while ((uiStatus & 0x1) && (iRetries > 0));
893 if (uiStatus & 0x1) {
939 static ULONG BcmFlashUnProtectBlock(
struct bcm_mini_adapter *Adapter,
unsigned int uiOffset,
unsigned int uiLength)
942 ULONG ulWriteStatus = 0;
945 uiOffset = uiOffset&0x000FFFFF;
961 ulWriteStatus = ulStatus;
970 if ((uiOffset+uiLength) <= 0x80000) {
975 ulWriteStatus |= (0x4<<2);
976 ulWriteStatus &= ~(0x3<<2);
977 }
else if ((uiOffset + uiLength) <= 0xC0000) {
982 ulWriteStatus |= (0x3<<2);
983 ulWriteStatus &= ~(0x1<<4);
984 }
else if ((uiOffset + uiLength) <= 0xE0000) {
989 ulWriteStatus |= (0x1<<3);
990 ulWriteStatus &= ~(0x5<<2);
991 }
else if ((uiOffset + uiLength) <= 0xF0000) {
996 ulWriteStatus |= (0x1<<2);
997 ulWriteStatus &= ~(0x3<<3);
1003 ulWriteStatus &= ~(0x7<<2);
1035 unsigned int uiOffset,
1036 unsigned int uiNumBytes,
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};
1050 unsigned int uiTemp = 0;
1051 unsigned int index = 0;
1052 unsigned int uiPartOffset = 0;
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);
1059 uiOffsetFromSectStart = uiOffset & ~(Adapter->
uiSectorSize - 1);
1065 uiSectAlignAddr = uiOffset & ~(Adapter->
uiSectorSize - 1);
1066 uiCurrSectOffsetAddr = uiOffset & (Adapter->
uiSectorSize - 1);
1067 uiSectBoundary = uiSectAlignAddr + Adapter->
uiSectorSize;
1071 goto BeceemFlashBulkWrite_EXIT;
1075 if (uiOffset+uiNumBytes < uiSectBoundary) {
1076 uiNumSectTobeRead = 1;
1079 uiNumSectTobeRead = (uiCurrSectOffsetAddr + uiNumBytes) / Adapter->
uiSectorSize;
1081 uiNumSectTobeRead++;
1089 uiTemp = uiNumSectTobeRead;
1091 if (IsOffsetWritable(Adapter, uiOffsetFromSectStart + index * Adapter->
uiSectorSize) ==
FALSE) {
1093 (uiOffsetFromSectStart + index * Adapter->
uiSectorSize));
1095 goto BeceemFlashBulkWrite_EXIT;
1097 uiTemp = uiTemp - 1;
1102 while (uiNumSectTobeRead) {
1106 uiPartOffset = (uiSectAlignAddr & (FLASH_PART_SIZE - 1)) + GetFlashBaseAddr(Adapter);
1108 BcmDoChipSelect(Adapter, uiSectAlignAddr);
1110 if (0 != BeceemFlashBulkRead(Adapter,
1112 uiOffsetFromSectStart,
1115 goto BeceemFlashBulkWrite_EXIT;
1121 ulStatus = BcmFlashUnProtectBlock(Adapter, uiSectAlignAddr, Adapter->
uiSectorSize);
1123 if (uiNumSectTobeRead > 1) {
1124 memcpy(&pTempBuff[uiCurrSectOffsetAddr], pcBuffer, uiSectBoundary - (uiSectAlignAddr + uiCurrSectOffsetAddr));
1125 pcBuffer += ((uiSectBoundary - (uiSectAlignAddr + uiCurrSectOffsetAddr)));
1126 uiNumBytes -= (uiSectBoundary - (uiSectAlignAddr + uiCurrSectOffsetAddr));
1128 memcpy(&pTempBuff[uiCurrSectOffsetAddr], pcBuffer, uiNumBytes);
1132 SaveHeaderIfPresent(Adapter, (
PUCHAR)pTempBuff, uiOffsetFromSectStart);
1134 FlashSectorErase(Adapter, uiPartOffset, 1);
1141 goto BeceemFlashBulkWrite_EXIT;
1146 goto BeceemFlashBulkWrite_EXIT;
1154 if (
STATUS_SUCCESS == BeceemFlashBulkRead(Adapter, (
PUINT)ucReadBk, uiOffsetFromSectStart + uiIndex, MAX_RW_SIZE)) {
1156 unsigned int uiReadIndex = 0;
1157 for (uiReadIndex = 0; uiReadIndex < 16; uiReadIndex++) {
1158 if (ucReadBk[uiReadIndex] != pTempBuff[uiIndex + uiReadIndex]) {
1161 goto BeceemFlashBulkWrite_EXIT;
1166 if (
memcmp(ucReadBk, &pTempBuff[uiIndex], MAX_RW_SIZE)) {
1169 goto BeceemFlashBulkWrite_EXIT;
1179 BcmRestoreBlockProtectStatus(Adapter, ulStatus);
1183 uiCurrSectOffsetAddr = 0;
1184 uiSectAlignAddr = uiSectBoundary;
1187 uiNumSectTobeRead--;
1195 BeceemFlashBulkWrite_EXIT:
1197 BcmRestoreBlockProtectStatus(Adapter, ulStatus);
1223 unsigned int uiOffset,
1224 unsigned int uiNumBytes,
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};
1238 unsigned int uiTemp = 0;
1239 unsigned int index = 0;
1240 unsigned int uiPartOffset = 0;
1242 uiOffsetFromSectStart = uiOffset & ~(Adapter->
uiSectorSize - 1);
1248 uiSectAlignAddr = uiOffset & ~(Adapter->
uiSectorSize - 1);
1249 uiCurrSectOffsetAddr = uiOffset & (Adapter->
uiSectorSize - 1);
1250 uiSectBoundary = uiSectAlignAddr + Adapter->
uiSectorSize;
1254 goto BeceemFlashBulkWriteStatus_EXIT;
1259 if (uiOffset+uiNumBytes < uiSectBoundary) {
1260 uiNumSectTobeRead = 1;
1263 uiNumSectTobeRead = (uiCurrSectOffsetAddr + uiNumBytes) / Adapter->
uiSectorSize;
1265 uiNumSectTobeRead++;
1270 uiTemp = uiNumSectTobeRead;
1272 if (IsOffsetWritable(Adapter, uiOffsetFromSectStart + index * Adapter->
uiSectorSize) ==
FALSE) {
1274 (uiOffsetFromSectStart + index * Adapter->
uiSectorSize));
1276 goto BeceemFlashBulkWriteStatus_EXIT;
1278 uiTemp = uiTemp - 1;
1284 while (uiNumSectTobeRead) {
1285 uiPartOffset = (uiSectAlignAddr & (FLASH_PART_SIZE - 1)) + GetFlashBaseAddr(Adapter);
1287 BcmDoChipSelect(Adapter, uiSectAlignAddr);
1288 if (0 != BeceemFlashBulkRead(Adapter,
1290 uiOffsetFromSectStart,
1293 goto BeceemFlashBulkWriteStatus_EXIT;
1296 ulStatus = BcmFlashUnProtectBlock(Adapter, uiOffsetFromSectStart, Adapter->
uiSectorSize);
1298 if (uiNumSectTobeRead > 1) {
1299 memcpy(&pTempBuff[uiCurrSectOffsetAddr], pcBuffer, uiSectBoundary - (uiSectAlignAddr + uiCurrSectOffsetAddr));
1300 pcBuffer += ((uiSectBoundary - (uiSectAlignAddr + uiCurrSectOffsetAddr)));
1301 uiNumBytes -= (uiSectBoundary - (uiSectAlignAddr + uiCurrSectOffsetAddr));
1303 memcpy(&pTempBuff[uiCurrSectOffsetAddr], pcBuffer, uiNumBytes);
1307 SaveHeaderIfPresent(Adapter, (
PUCHAR)pTempBuff, uiOffsetFromSectStart);
1309 FlashSectorErase(Adapter, uiPartOffset, 1);
1314 goto BeceemFlashBulkWriteStatus_EXIT;
1319 goto BeceemFlashBulkWriteStatus_EXIT;
1325 if (
STATUS_SUCCESS == BeceemFlashBulkRead(Adapter, (
PUINT)ucReadBk, uiOffsetFromSectStart + uiIndex, MAX_RW_SIZE)) {
1326 if (
memcmp(ucReadBk, &pTempBuff[uiIndex], MAX_RW_SIZE)) {
1328 goto BeceemFlashBulkWriteStatus_EXIT;
1335 BcmRestoreBlockProtectStatus(Adapter, ulStatus);
1339 uiCurrSectOffsetAddr = 0;
1340 uiSectAlignAddr = uiSectBoundary;
1343 uiNumSectTobeRead--;
1348 BeceemFlashBulkWriteStatus_EXIT:
1350 BcmRestoreBlockProtectStatus(Adapter, ulStatus);
1372 unsigned int uiEepromSize = 0;
1373 unsigned int uiIndex = 0;
1374 unsigned int uiBytesToCopy = 0;
1388 uiEepromSize >>= 16;
1389 if (uiEepromSize > 1024 * 1024) {
1396 while (uiBytesToCopy) {
1401 wrm(Adapter, uiMemoryLoc, (
PCHAR)(((
PULONG)pBuff) + uiIndex), uiBytesToCopy);
1402 uiMemoryLoc += uiBytesToCopy;
1403 uiEepromSize -= uiBytesToCopy;
1404 uiCalStartAddr += uiBytesToCopy;
1405 uiIndex += uiBytesToCopy / 4;
1433 unsigned int uiEepromSize = 0;
1434 unsigned int uiBytesToCopy = 0;
1452 uiEepromSize =
ntohl(uiEepromSize);
1453 uiEepromSize >>= 16;
1460 if (uiEepromSize > 1024 * 1024)
1476 while (uiBytesToCopy) {
1477 Status =
wrm(Adapter, uiMemoryLoc, (
PCHAR)pPtr, uiBytesToCopy);
1483 pPtr += uiBytesToCopy;
1484 uiEepromSize -= uiBytesToCopy;
1485 uiMemoryLoc += uiBytesToCopy;
1510 unsigned int uiOffset,
1511 unsigned int uiNumBytes)
1513 unsigned int uiRdbk = 0;
1514 unsigned int uiIndex = 0;
1515 unsigned int uiData = 0;
1516 unsigned int auiData[4] = {0};
1518 while (uiNumBytes) {
1522 if (uiNumBytes >= MAX_RW_SIZE) {
1526 if (
memcmp(&pBuffer[uiIndex], &auiData[0], MAX_RW_SIZE)) {
1532 if (
memcmp(&pBuffer[uiIndex], &auiData[0], MAX_RW_SIZE))
1538 }
else if (uiNumBytes >= 4) {
1540 if (uiData != pBuffer[uiIndex]) {
1545 if (uiData != pBuffer[uiIndex])
1554 memcpy(&uiData, ((
PUCHAR)pBuffer) + (uiIndex *
sizeof(
unsigned int)), uiNumBytes);
1557 if (
memcmp(&uiData, &uiRdbk, uiNumBytes))
1567 static VOID BcmSwapWord(
unsigned int *ptr1)
1569 unsigned int tempval = (
unsigned int)*ptr1;
1570 char *ptr2 = (
char *)&tempval;
1571 char *
ptr = (
char *)ptr1;
1593 static int BeceemEEPROMWritePage(
struct bcm_mini_adapter *Adapter,
unsigned int uiData[],
unsigned int uiOffset)
1596 unsigned int uiStatus = 0;
1597 UCHAR uiEpromStatus = 0;
1598 unsigned int value = 0;
1623 BcmSwapWord(&value);
1627 BcmSwapWord(&value);
1631 BcmSwapWord(&value);
1635 BcmSwapWord(&value);
1654 if (uiRetries == 0) {
1659 if (!(uiRetries%RETRIES_PER_DELAY))
1670 if (uiRetries != 0) {
1684 while (uiRetries != 0) {
1685 uiEpromStatus = ReadEEPROMStatusRegister(Adapter);
1695 if (uiRetries == 0) {
1700 if (!(uiRetries%RETRIES_PER_DELAY))
1725 unsigned int uiOffset,
1726 unsigned int uiNumBytes,
1729 unsigned int uiBytesToCopy = uiNumBytes;
1731 unsigned int uiData[4] = {0};
1732 unsigned int uiIndex = 0;
1733 unsigned int uiTempOffset = 0;
1734 unsigned int uiExtraBytes = 0;
1739 if (uiOffset % MAX_RW_SIZE && uiBytesToCopy) {
1740 uiTempOffset = uiOffset - (uiOffset %
MAX_RW_SIZE);
1741 uiExtraBytes = uiOffset - uiTempOffset;
1745 if (uiBytesToCopy >= (16 - uiExtraBytes)) {
1746 memcpy((((
PUCHAR)&uiData[0]) + uiExtraBytes), pBuffer, MAX_RW_SIZE - uiExtraBytes);
1748 if (
STATUS_FAILURE == BeceemEEPROMWritePage(Adapter, uiData, uiTempOffset))
1751 uiBytesToCopy -= (MAX_RW_SIZE - uiExtraBytes);
1752 uiIndex += (MAX_RW_SIZE - uiExtraBytes);
1753 uiOffset += (MAX_RW_SIZE - uiExtraBytes);
1755 memcpy((((
PUCHAR)&uiData[0]) + uiExtraBytes), pBuffer, uiBytesToCopy);
1757 if (
STATUS_FAILURE == BeceemEEPROMWritePage(Adapter, uiData, uiTempOffset))
1760 uiIndex += uiBytesToCopy;
1761 uiOffset += uiBytesToCopy;
1766 while (uiBytesToCopy) {
1770 if (uiBytesToCopy >= MAX_RW_SIZE) {
1771 if (
STATUS_FAILURE == BeceemEEPROMWritePage(Adapter, (
PUINT) &pBuffer[uiIndex], uiOffset))
1782 memcpy(&uiData[0], pBuffer + uiIndex, uiBytesToCopy);
1784 if (
STATUS_FAILURE == BeceemEEPROMWritePage(Adapter, uiData, uiOffset))
1812 unsigned int uiOffset,
1813 unsigned int uiNumBytes)
1817 #if !defined(BCM_SHM_INTERFACE) || defined(FLASH_DIRECT_ACCESS)
1818 unsigned int uiTemp = 0,
value;
1823 if (IsSectionExistInVendorInfo(Adapter, Adapter->
eActiveDSD))
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);
1832 rdmalt(Adapter, 0x0f000C80, &uiTemp,
sizeof(uiTemp));
1834 wrmalt(Adapter, 0x0f000C80, &value,
sizeof(value));
1835 Status = BeceemFlashBulkRead(Adapter,
1839 wrmalt(Adapter, 0x0f000C80, &uiTemp,
sizeof(uiTemp));
1871 unsigned int uiOffset,
1872 unsigned int uiNumBytes,
1876 unsigned int uiTemp = 0;
1878 unsigned int uiIndex = 0;
1880 #if !defined(BCM_SHM_INTERFACE) || defined(FLASH_DIRECT_ACCESS)
1884 unsigned int uiFlashOffset = 0;
1887 if (IsSectionExistInVendorInfo(Adapter, Adapter->
eActiveDSD))
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);
1895 rdmalt(Adapter, 0x0f000C80, &uiTemp,
sizeof(uiTemp));
1897 wrmalt(Adapter, 0x0f000C80, &value,
sizeof(value));
1900 Status = BeceemFlashBulkWriteStatus(Adapter,
1907 Status = BeceemFlashBulkWrite(Adapter,
1917 while (uiNumBytes) {
1919 wrm(Adapter, (uiMemoryLoc+uiIndex), (
PCHAR)(pBuffer + (uiIndex / 4)),
BUFFER_4K);
1923 wrm(Adapter, uiMemoryLoc+uiIndex, (
PCHAR)(pBuffer + (uiIndex / 4)), uiNumBytes);
1930 ULONG ulBytesTobeSkipped = 0;
1935 while (uiNumBytes) {
1937 wrm(Adapter, uiMemoryLoc + uiIndex, (
PCHAR)&pcBuffer[ulBytesTobeSkipped + uiIndex],
BUFFER_4K);
1941 wrm(Adapter, uiMemoryLoc + uiIndex, (
PCHAR)&pcBuffer[ulBytesTobeSkipped + uiIndex], uiNumBytes);
1949 wrmalt(Adapter, 0x0f000C80, &uiTemp,
sizeof(uiTemp));
1957 Status = BeceemEEPROMReadBackandVerify(Adapter, (
PUINT)pBuffer, uiOffset, uiNumBytes);
1982 unsigned int uiTemp = 0;
1983 unsigned int uiSectorSig = 0;
1984 unsigned int uiCurrentSectorSize = 0;
1987 rdmalt(Adapter, 0x0f000C80, &uiTemp,
sizeof(uiTemp));
1989 wrmalt(Adapter, 0x0f000C80, &value,
sizeof(value));
1995 uiSectorSig =
ntohl(sFlashCsInfo.FlashSectorSizeSig);
1996 uiCurrentSectorSize =
ntohl(sFlashCsInfo.FlashSectorSize);
2000 if (uiSectorSize == uiCurrentSectorSize) {
2009 sFlashCsInfo.FlashSectorSize =
htonl(uiSectorSize);
2012 Status = BeceemFlashBulkWrite(Adapter,
2013 (
PUINT)&sFlashCsInfo,
2015 sizeof(sFlashCsInfo),
2021 wrmalt(Adapter, 0x0f000C80, &uiTemp,
sizeof(uiTemp));
2039 static unsigned int BcmGetFlashSectorSize(
struct bcm_mini_adapter *Adapter,
unsigned int FlashSectorSizeSig,
unsigned int FlashSectorSize)
2041 unsigned int uiSectorSize = 0;
2042 unsigned int uiSectorSig = 0;
2049 uiSectorSig = FlashSectorSizeSig;
2052 uiSectorSize = FlashSectorSize;
2056 if (uiSectorSize <= MAX_SECTOR_SIZE && uiSectorSize >=
MIN_SECTOR_SIZE) {
2094 unsigned int value = 0;
2131 BcmValidateNvmType(ps_adapter);
2132 BcmInitEEPROMQueues(ps_adapter);
2135 ps_adapter->
eNVMType = BcmGetNvmType(ps_adapter);
2139 BcmGetFlashCSInfo(ps_adapter);
2142 BcmGetNvmSize(ps_adapter);
2186 Adapter->
chip_id < 0xBECE3300)
2269 unsigned int Index = 0;
2329 unsigned int Index = 0;
2384 static int ConvertEndianOfCSStructure(
PFLASH_CS_INFO psFlashCSInfo)
2426 unsigned int uiSizeSection = 0;
2437 while (i < TOTAL_SECTIONS) {
2514 #if !defined(BCM_SHM_INTERFACE) || defined(FLASH_DIRECT_ACCESS)
2518 unsigned int uiFlashLayoutMajorVersion;
2530 wrmalt(Adapter, 0xAF00A080, &value,
sizeof(value));
2548 uiFlashLayoutMajorVersion = 0;
2602 UpdateVendorInfo(Adapter);
2604 BcmGetActiveDSD(Adapter);
2605 BcmGetActiveISO(Adapter);
2613 Adapter->
ulFlashID = BcmReadFlashRDID(Adapter);
2634 unsigned int uiData = 0;
2643 BcmGetFlashCSInfo(Adapter);
2645 BeceemFlashBulkRead(Adapter, &uiData, 0x0 + Adapter->
ulFlashCalStart, 4);
2653 if (BcmGetEEPROMSize(Adapter))
2678 int SectStartOffset = 0;
2682 if (IsSectionExistInVendorInfo(Adapter, eFlashSectionVal))
2685 switch (eFlashSectionVal) {
2749 return SectStartOffset;
2764 int SectEndOffset = 0;
2767 if (IsSectionExistInVendorInfo(Adapter, eFlash2xSectionVal))
2770 switch (eFlash2xSectionVal) {
2833 return SectEndOffset ;
2851 unsigned int uiOffsetWithinSectionVal,
2852 unsigned int uiNumBytes)
2855 int SectionStartOffset = 0;
2856 unsigned int uiAbsoluteOffset = 0;
2857 unsigned int uiTemp = 0, value = 0;
2870 SectionStartOffset = 0;
2879 if (IsSectionExistInVendorInfo(Adapter, eFlash2xSectionVal))
2883 uiAbsoluteOffset = uiOffsetWithinSectionVal + SectionStartOffset;
2884 rdmalt(Adapter, 0x0f000C80, &uiTemp,
sizeof(uiTemp));
2886 wrmalt(Adapter, 0x0f000C80, &value,
sizeof(value));
2887 Status = BeceemFlashBulkRead(Adapter, pBuffer, uiAbsoluteOffset, uiNumBytes);
2888 wrmalt(Adapter, 0x0f000C80, &uiTemp,
sizeof(uiTemp));
2913 unsigned int uiOffset,
2914 unsigned int uiNumBytes,
2915 unsigned int bVerify)
2918 unsigned int FlashSectValStartOffset = 0;
2919 unsigned int uiTemp = 0, value = 0;
2933 FlashSectValStartOffset = 0;
2942 if (IsSectionExistInVendorInfo(Adapter, eFlash2xSectVal))
2946 uiOffset = uiOffset + FlashSectValStartOffset;
2948 rdmalt(Adapter, 0x0f000C80, &uiTemp,
sizeof(uiTemp));
2950 wrmalt(Adapter, 0x0f000C80, &value,
sizeof(value));
2952 Status = BeceemFlashBulkWrite(Adapter, pBuffer, uiOffset, uiNumBytes, bVerify);
2954 wrmalt(Adapter, 0x0f000C80, &uiTemp,
sizeof(uiTemp));
2976 uiHighestPriDSD = getHighestPriDSD(Adapter);
2979 if (
DSD0 == uiHighestPriDSD)
2981 if (
DSD1 == uiHighestPriDSD)
2983 if (
DSD2 == uiHighestPriDSD)
2989 if (IsSectionWritable(Adapter,
DSD2)) {
2992 }
else if (IsSectionWritable(Adapter,
DSD1)) {
2995 }
else if (IsSectionWritable(Adapter,
DSD0)) {
3016 int HighestPriISO = 0;
3018 HighestPriISO = getHighestPriISO(Adapter);
3045 unsigned int uiSectorNum = 0;
3046 unsigned int uiWordOfSectorPermission = 0;
3047 unsigned int uiBitofSectorePermission = 0;
3056 uiBitofSectorePermission = 2 * (15 - uiSectorNum % 16);
3059 permissionBits = uiWordOfSectorPermission & (0x3 << uiBitofSectorePermission);
3060 permissionBits = (permissionBits >> uiBitofSectorePermission) & 0x3;
3067 static int BcmDumpFlash2xSectionBitMap(
PFLASH2X_BITMAP psFlash2xBitMap)
3117 psFlash2xBitMap->
DSD1 = 0;
3118 psFlash2xBitMap->
DSD2 = 0;
3119 psFlash2xBitMap->
VSA0 = 0;
3120 psFlash2xBitMap->
VSA1 = 0;
3121 psFlash2xBitMap->
VSA2 = 0;
3123 psFlash2xBitMap->
SCSI = 0;
3131 uiHighestPriDSD = getHighestPriDSD(Adapter);
3132 uiHighestPriISO = getHighestPriISO(Adapter);
3150 SetActiveISODone =
TRUE;
3170 SetActiveISODone =
TRUE;
3185 if (IsSectionWritable(Adapter,
DSD2) ==
FALSE) {
3189 if ((SetActiveDSDDone ==
FALSE) && (uiHighestPriDSD ==
DSD2)) {
3191 SetActiveDSDDone =
TRUE;
3207 if (IsSectionWritable(Adapter,
DSD1) ==
FALSE) {
3211 if ((SetActiveDSDDone ==
FALSE) && (uiHighestPriDSD ==
DSD1)) {
3213 SetActiveDSDDone =
TRUE;
3229 if (IsSectionWritable(Adapter,
DSD0) ==
FALSE) {
3233 if ((SetActiveDSDDone ==
FALSE) && (uiHighestPriDSD ==
DSD0)) {
3235 SetActiveDSDDone =
TRUE;
3251 if (IsSectionWritable(Adapter,
VSA0) ==
FALSE)
3269 if (IsSectionWritable(Adapter,
VSA1) ==
FALSE)
3287 if (IsSectionWritable(Adapter,
VSA2) ==
FALSE)
3305 if (IsSectionWritable(Adapter,
SCSI) ==
FALSE)
3336 BcmDumpFlash2xSectionBitMap(psFlash2xBitMap);
3354 unsigned int SectImagePriority = 0;
3360 int HighestPriDSD = 0 ;
3361 int HighestPriISO = 0;
3363 Status = IsSectionWritable(Adapter, eFlash2xSectVal);
3364 if (Status !=
TRUE) {
3370 switch (eFlash2xSectVal) {
3374 HighestPriISO = getHighestPriISO(Adapter);
3376 if (HighestPriISO == eFlash2xSectVal) {
3382 SectImagePriority = ReadISOPriority(Adapter, HighestPriISO) + 1;
3384 if ((SectImagePriority <= 0) && IsSectionWritable(Adapter, HighestPriISO)) {
3390 SectImagePriority =
htonl(0x1);
3403 HighestPriISO = getHighestPriISO(Adapter);
3405 if (HighestPriISO == eFlash2xSectVal) {
3411 SectImagePriority = 2;
3414 SectImagePriority =
htonl(SectImagePriority);
3436 HighestPriDSD = getHighestPriDSD(Adapter);
3437 if ((HighestPriDSD == eFlash2xSectVal)) {
3443 SectImagePriority = ReadDSDPriority(Adapter, HighestPriDSD) + 1;
3444 if (SectImagePriority <= 0) {
3450 SectImagePriority =
htonl(0x1);
3463 HighestPriDSD = getHighestPriDSD(Adapter);
3465 if ((HighestPriDSD == eFlash2xSectVal)) {
3471 SectImagePriority =
htonl(0x2);
3483 HighestPriDSD = getHighestPriDSD(Adapter);
3484 if ((HighestPriDSD == eFlash2xSectVal)) {
3489 SectImagePriority = 3;
3491 SectImagePriority =
htonl(SectImagePriority);
3536 unsigned int uiReadOffsetWithinPart = 0, uiWriteOffsetWithinPart = 0;
3537 unsigned int uiTotalDataToCopy = 0;
3539 unsigned int sigOffset = 0;
3540 unsigned int ISOLength = 0;
3560 ISOLength =
htonl(ISOLength);
3576 uiReadOffsetWithinPart = 0;
3577 uiWriteOffsetWithinPart = 0;
3586 if (uiTotalDataToCopy < ISOLength) {
3599 if (uiTotalDataToCopy < ISOLength) {
3605 uiTotalDataToCopy = ISOLength;
3608 while (uiTotalDataToCopy) {
3613 uiReadOffsetWithinPart = 0;
3615 uiWriteOffsetWithinPart = 0;
3616 IsThisHeaderSector =
TRUE;
3618 uiReadOffsetWithinPart = uiReadOffsetWithinPart + Adapter->
uiSectorSize;
3619 uiWriteOffsetWithinPart = uiWriteOffsetWithinPart + Adapter->
uiSectorSize;
3623 uiReadOffsetWithinPart = 0;
3628 uiReadOffsetWithinPart = 0;
3633 uiWriteOffsetWithinPart = 0;
3638 uiWriteOffsetWithinPart = 0;
3645 uiReadOffsetWithinPart,
3648 BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_PRINTK, 0, 0,
"Read failed while copying ISO: Part: %x, OffsetWithinPart: %x\n", eISOReadPart, uiReadOffsetWithinPart);
3652 if (IsThisHeaderSector ==
TRUE) {
3654 memcpy(SigBuff, Buff + sigOffset, MAX_RW_SIZE);
3657 *(Buff + sigOffset + i) = 0xFF;
3663 uiWriteOffsetWithinPart,
3667 BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_PRINTK, 0, 0,
"Write failed while copying ISO: Part: %x, OffsetWithinPart: %x\n", eISOWritePart, uiWriteOffsetWithinPart);
3672 if (IsThisHeaderSector ==
TRUE) {
3673 WriteToFlashWithoutSectorErase(Adapter,
3678 IsThisHeaderSector =
FALSE;
3681 uiTotalDataToCopy = uiTotalDataToCopy - Adapter->
uiSectorSize;
3688 uiReadOffsetWithinPart = 0;
3689 uiWriteOffsetWithinPart = 0;
3698 if (uiTotalDataToCopy < ISOLength) {
3711 if (uiTotalDataToCopy < ISOLength) {
3717 uiTotalDataToCopy = ISOLength;
3721 while (uiTotalDataToCopy) {
3726 uiReadOffsetWithinPart = 0;
3728 uiWriteOffsetWithinPart = 0;
3729 IsThisHeaderSector =
TRUE;
3731 uiReadOffsetWithinPart = uiReadOffsetWithinPart + Adapter->
uiSectorSize;
3732 uiWriteOffsetWithinPart = uiWriteOffsetWithinPart + Adapter->
uiSectorSize;
3736 uiReadOffsetWithinPart = 0;
3741 uiReadOffsetWithinPart = 0;
3746 uiWriteOffsetWithinPart = 0;
3751 uiWriteOffsetWithinPart = 0;
3758 uiReadOffsetWithinPart,
3761 BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_PRINTK, 0, 0,
"Read failed while copying ISO: Part: %x, OffsetWithinPart: %x\n", eISOReadPart, uiReadOffsetWithinPart);
3765 if (IsThisHeaderSector ==
TRUE) {
3767 memcpy(SigBuff, Buff + sigOffset, MAX_RW_SIZE);
3770 *(Buff + sigOffset + i) = 0xFF;
3776 uiWriteOffsetWithinPart,
3780 BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_PRINTK, 0, 0,
"Write failed while copying ISO: Part: %x, OffsetWithinPart: %x\n", eISOWritePart, uiWriteOffsetWithinPart);
3785 if (IsThisHeaderSector ==
TRUE) {
3786 WriteToFlashWithoutSectorErase(Adapter,
3792 IsThisHeaderSector =
FALSE;
3796 uiTotalDataToCopy = uiTotalDataToCopy - Adapter->
uiSectorSize;
3822 if ((eFlash2xSectionVal ==
DSD0) || (eFlash2xSectionVal ==
DSD1) || (eFlash2xSectionVal ==
DSD2)) {
3823 Status = CorruptDSDSig(Adapter, eFlash2xSectionVal);
3825 Status = CorruptISOSig(Adapter, eFlash2xSectionVal);
3846 unsigned int uiSignature = 0;
3847 unsigned int uiOffset = 0;
3856 if (IsSectionWritable(Adapter, eFlashSectionVal) ==
FALSE) {
3862 if ((eFlashSectionVal ==
DSD0) || (eFlashSectionVal ==
DSD1) || (eFlashSectionVal ==
DSD2)) {
3868 if ((ReadDSDSignature(Adapter, eFlashSectionVal) & 0xFF000000) !=
CORRUPTED_PATTERN) {
3876 if ((ReadISOSignature(Adapter, eFlashSectionVal) & 0xFF000000) !=
CORRUPTED_PATTERN) {
3906 unsigned int uiNumOfBytes = 0;
3907 unsigned int uiSectStartOffset = 0;
3908 unsigned int uiSectEndOffset = 0;
3910 uiNumOfBytes = psFlash2xReadWrite->
numOfBytes;
3920 uiSectEndOffset = BcmGetSectionValEndOffset(Adapter,
ISO_IMAGE1) -
3927 uiSectEndOffset = BcmGetSectionValEndOffset(Adapter,
ISO_IMAGE2) -
3938 uiSectEndOffset = uiSectStartOffset + uiSectEndOffset;
3942 uiSectEndOffset = BcmGetSectionValEndOffset(Adapter, psFlash2xReadWrite->
Section);
3947 if ((uiSectStartOffset + psFlash2xReadWrite->
offset + uiNumOfBytes) <= uiSectEndOffset)
3981 unsigned int uiBaseAddr = 0;
4029 unsigned int BuffSize = 0;
4030 unsigned int BytesToBeCopied = 0;
4034 if (SrcSection == DstSection) {
4039 if ((SrcSection !=
DSD0) && (SrcSection !=
DSD1) && (SrcSection !=
DSD2)) {
4044 if ((DstSection !=
DSD0) && (DstSection !=
DSD1) && (DstSection !=
DSD2)) {
4050 if (numOfBytes == 0) {
4051 numOfBytes = BcmGetSectionValEndOffset(Adapter, SrcSection)
4057 if ((offset + numOfBytes) > BcmGetSectionValEndOffset(Adapter, SrcSection)
4060 offset, numOfBytes);
4064 if ((offset + numOfBytes) > BcmGetSectionValEndOffset(Adapter, DstSection)
4067 offset, numOfBytes);
4085 if (BytesToBeCopied > numOfBytes)
4101 offset = offset + BytesToBeCopied;
4102 numOfBytes = numOfBytes - BytesToBeCopied;
4109 }
while (numOfBytes > 0);
4130 unsigned int offsetToProtect = 0, HeaderSizeToProtect = 0;
4133 unsigned int uiSectAlignAddr = 0;
4134 unsigned int sig = 0;
4137 uiSectAlignAddr = uiOffset & ~(Adapter->
uiSectorSize - 1);
4139 if ((uiSectAlignAddr == BcmGetSectionValEndOffset(Adapter,
DSD2) - Adapter->
uiSectorSize) ||
4140 (uiSectAlignAddr == BcmGetSectionValEndOffset(Adapter,
DSD1) - Adapter->
uiSectorSize) ||
4141 (uiSectAlignAddr == BcmGetSectionValEndOffset(Adapter,
DSD0) - Adapter->
uiSectorSize)) {
4150 offsetToProtect = 0;
4162 BeceemFlashBulkRead(Adapter, (
PUINT)pTempBuff, (uiSectAlignAddr + offsetToProtect), HeaderSizeToProtect);
4165 memcpy(pBuff + offsetToProtect, pTempBuff, HeaderSizeToProtect);
4195 unsigned int FlashConfig = 0;
4197 unsigned int GPIOConfig = 0;
4198 unsigned int PartNum = 0;
4255 FlashConfig &= 0xFFFFCFFF;
4269 unsigned int uiDSDsig = 0;
4286 uiDSDsig =
ntohl(uiDSDsig);
4299 if (IsSectionWritable(Adapter, dsd)) {
4307 uiDSDPri =
ntohl(uiDSDPri);
4321 if (IsSectionWritable(Adapter,
DSD2)) {
4322 DSDHighestPri = ReadDSDPriority(Adapter,
DSD2);
4323 HighestPriDSD =
DSD2;
4326 if (IsSectionWritable(Adapter,
DSD1)) {
4327 DsdPri = ReadDSDPriority(Adapter,
DSD1);
4328 if (DSDHighestPri < DsdPri) {
4329 DSDHighestPri = DsdPri;
4330 HighestPriDSD =
DSD1;
4334 if (IsSectionWritable(Adapter,
DSD0)) {
4335 DsdPri = ReadDSDPriority(Adapter,
DSD0);
4336 if (DSDHighestPri < DsdPri) {
4337 DSDHighestPri = DsdPri;
4338 HighestPriDSD =
DSD0;
4344 return HighestPriDSD;
4349 unsigned int uiISOsig = 0;
4364 uiISOsig =
ntohl(uiISOsig);
4373 if (IsSectionWritable(Adapter, iso)) {
4381 ISOPri =
ntohl(ISOPri);
4395 if (IsSectionWritable(Adapter,
ISO_IMAGE2)) {
4396 ISOHighestPri = ReadISOPriority(Adapter,
ISO_IMAGE2);
4400 if (IsSectionWritable(Adapter,
ISO_IMAGE1)) {
4401 ISOPri = ReadISOPriority(Adapter,
ISO_IMAGE1);
4402 if (ISOHighestPri < ISOPri) {
4403 ISOHighestPri = ISOPri;
4410 return HighestPriISO;
4416 unsigned int uiOffset,
4417 unsigned int uiNumBytes)
4419 #if !defined(BCM_SHM_INTERFACE) || defined(FLASH_DIRECT_ACCESS)
4420 unsigned int uiTemp = 0, value = 0;
4422 unsigned int uiPartOffset = 0;
4424 unsigned int uiStartOffset = 0;
4436 if (IsSectionExistInVendorInfo(Adapter, eFlash2xSectionVal))
4439 uiOffset = uiOffset + uiStartOffset;
4441 #if defined(BCM_SHM_INTERFACE) && !defined(FLASH_DIRECT_ACCESS)
4442 Status = bcmflash_raw_writenoerase((uiOffset / FLASH_PART_SIZE), (uiOffset % FLASH_PART_SIZE), pcBuff, uiNumBytes);
4444 rdmalt(Adapter, 0x0f000C80, &uiTemp,
sizeof(uiTemp));
4446 wrmalt(Adapter, 0x0f000C80, &value,
sizeof(value));
4449 BcmDoChipSelect(Adapter, uiOffset);
4450 uiPartOffset = (uiOffset & (FLASH_PART_SIZE - 1)) + GetFlashBaseAddr(Adapter);
4454 Status = flashByteWrite(Adapter, uiPartOffset, pcBuff);
4456 Status = flashWrite(Adapter, uiPartOffset, pcBuff);
4464 wrmalt(Adapter, 0x0f000C80, &uiTemp,
sizeof(uiTemp));
4479 SectionPresent =
TRUE;
4484 SectionPresent =
TRUE;
4488 SectionPresent =
TRUE;
4492 SectionPresent =
TRUE;
4496 SectionPresent =
TRUE;
4500 SectionPresent =
TRUE;
4504 SectionPresent =
TRUE;
4508 SectionPresent =
TRUE;
4512 SectionPresent =
TRUE;
4516 SectionPresent =
TRUE;
4520 SectionPresent =
FALSE;
4523 return SectionPresent;
4542 if (IsSectionExistInVendorInfo(Adapter, Section))
4545 Status = IsOffsetWritable(Adapter, offset);
4552 unsigned int sig = 0;
4553 unsigned int uiOffset = 0;
4554 unsigned int BlockStatus = 0;
4555 unsigned int uiSectAlignAddr = 0;
4559 if (IsSectionWritable(Adapter, eFlash2xSectionVal) !=
TRUE) {
4576 sig = *((
PUINT)(pBuff + 12));
4585 uiSectAlignAddr = uiOffset & ~(Adapter->
uiSectorSize - 1);
4586 BlockStatus = BcmFlashUnProtectBlock(Adapter, uiSectAlignAddr, Adapter->
uiSectorSize);
4588 WriteToFlashWithoutSectorErase(Adapter, (
PUINT)(pBuff + 12), eFlash2xSectionVal,
4591 BcmRestoreBlockProtectStatus(Adapter, BlockStatus);
4595 WriteToFlashWithoutSectorErase(Adapter, (
PUINT)pBuff, eFlash2xSectionVal,
4596 uiOffset, MAX_RW_SIZE);
4614 unsigned int sig = 0;
4615 unsigned int uiOffset = 0;
4619 if (IsSectionWritable(Adapter, eFlash2xSectionVal) !=
TRUE) {
4634 sig = *((
PUINT)pBuff);
4642 WriteToFlashWithoutSectorErase(Adapter, (
PUINT)pBuff, eFlash2xSectionVal,