?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jmorris...
[linux/fpc-iii.git] / drivers / staging / bcm / nvm.c
blobfca164f51f4b117623e23e48b02d35007c3c3e81
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 bool 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 bool 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 bool 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: PropagateCalParamsFromFlashToMemory
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 PropagateCalParamsFromFlashToMemory(struct bcm_mini_adapter *Adapter)
1370 {
1371 PCHAR pBuff, pPtr;
1372 unsigned int uiEepromSize = 0;
1373 unsigned int uiBytesToCopy = 0;
1374 /* unsigned int uiIndex = 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 /*
1381 * Write the signature first. This will ensure firmware does not access EEPROM.
1382 */
1383 value = 0xbeadbead;
1384 wrmalt(Adapter, EEPROM_CAL_DATA_INTERNAL_LOC - 4, &value, sizeof(value));
1385 value = 0xbeadbead;
1386 wrmalt(Adapter, EEPROM_CAL_DATA_INTERNAL_LOC - 8, &value, sizeof(value));
1387
1388 if (0 != BeceemNVMRead(Adapter, &uiEepromSize, EEPROM_SIZE_OFFSET, 4))
1389 return -1;
1390
1391 uiEepromSize = ntohl(uiEepromSize);
1392 uiEepromSize >>= 16;
1393
1394 /*
1395 * subtract the auto init section size
1396 */
1397 uiEepromSize -= EEPROM_CALPARAM_START;
1398
1399 if (uiEepromSize > 1024 * 1024)
1400 return -1;
1401
1402 pBuff = kmalloc(uiEepromSize, GFP_KERNEL);
1403 if (pBuff == NULL)
1404 return -ENOMEM;
1405
1406 if (0 != BeceemNVMRead(Adapter, (PUINT)pBuff, uiCalStartAddr, uiEepromSize)) {
1407 kfree(pBuff);
1408 return -1;
1409 }
1410
1411 pPtr = pBuff;
1412
1413 uiBytesToCopy = MIN(BUFFER_4K, uiEepromSize);
1414
1415 while (uiBytesToCopy) {
1416 Status = wrm(Adapter, uiMemoryLoc, (PCHAR)pPtr, uiBytesToCopy);
1417 if (Status) {
1418 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "wrm failed with status :%d", Status);
1419 break;
1420 }
1421
1422 pPtr += uiBytesToCopy;
1423 uiEepromSize -= uiBytesToCopy;
1424 uiMemoryLoc += uiBytesToCopy;
1425 uiBytesToCopy = MIN(BUFFER_4K, uiEepromSize);
1426 }
1427
1428 kfree(pBuff);
1429 return Status;
1430 }
1431
1432 /*
1433 * Procedure: BeceemEEPROMReadBackandVerify
1434 *
1435 * Description: Read back the data written and verifies.
1436 *
1437 * Arguments:
1438 * Adapter - ptr to Adapter object instance
1439 * pBuffer - Data to be written.
1440 * uiOffset - Offset of the flash where data needs to be written to.
1441 * uiNumBytes - Number of bytes to be written.
1442 * Returns:
1443 * OSAL_STATUS_CODE
1444 *
1445 */
1446
1447 static int BeceemEEPROMReadBackandVerify(struct bcm_mini_adapter *Adapter,
1448 PUINT pBuffer,
1449 unsigned int uiOffset,
1450 unsigned int uiNumBytes)
1451 {
1452 unsigned int uiRdbk = 0;
1453 unsigned int uiIndex = 0;
1454 unsigned int uiData = 0;
1455 unsigned int auiData[4] = {0};
1456
1457 while (uiNumBytes) {
1458 if (Adapter->device_removed)
1459 return -1;
1460
1461 if (uiNumBytes >= MAX_RW_SIZE) {
1462 /* for the requests more than or equal to MAX_RW_SIZE bytes, use bulk read function to make the access faster. */
1463 BeceemEEPROMBulkRead(Adapter, &auiData[0], uiOffset, MAX_RW_SIZE);
1464
1465 if (memcmp(&pBuffer[uiIndex], &auiData[0], MAX_RW_SIZE)) {
1466 /* re-write */
1467 BeceemEEPROMBulkWrite(Adapter, (PUCHAR)(pBuffer + uiIndex), uiOffset, MAX_RW_SIZE, false);
1468 mdelay(3);
1469 BeceemEEPROMBulkRead(Adapter, &auiData[0], uiOffset, MAX_RW_SIZE);
1470
1471 if (memcmp(&pBuffer[uiIndex], &auiData[0], MAX_RW_SIZE))
1472 return -1;
1473 }
1474 uiOffset += MAX_RW_SIZE;
1475 uiNumBytes -= MAX_RW_SIZE;
1476 uiIndex += 4;
1477 } else if (uiNumBytes >= 4) {
1478 BeceemEEPROMBulkRead(Adapter, &uiData, uiOffset, 4);
1479 if (uiData != pBuffer[uiIndex]) {
1480 /* re-write */
1481 BeceemEEPROMBulkWrite(Adapter, (PUCHAR)(pBuffer + uiIndex), uiOffset, 4, false);
1482 mdelay(3);
1483 BeceemEEPROMBulkRead(Adapter, &uiData, uiOffset, 4);
1484 if (uiData != pBuffer[uiIndex])
1485 return -1;
1486 }
1487 uiOffset += 4;
1488 uiNumBytes -= 4;
1489 uiIndex++;
1490 } else {
1491 /* Handle the reads less than 4 bytes... */
1492 uiData = 0;
1493 memcpy(&uiData, ((PUCHAR)pBuffer) + (uiIndex * sizeof(unsigned int)), uiNumBytes);
1494 BeceemEEPROMBulkRead(Adapter, &uiRdbk, uiOffset, 4);
1495
1496 if (memcmp(&uiData, &uiRdbk, uiNumBytes))
1497 return -1;
1498
1499 uiNumBytes = 0;
1500 }
1501 }
1502
1503 return 0;
1504 }
1505
1506 static VOID BcmSwapWord(unsigned int *ptr1)
1507 {
1508 unsigned int tempval = (unsigned int)*ptr1;
1509 char *ptr2 = (char *)&tempval;
1510 char *ptr = (char *)ptr1;
1511
1512 ptr[0] = ptr2[3];
1513 ptr[1] = ptr2[2];
1514 ptr[2] = ptr2[1];
1515 ptr[3] = ptr2[0];
1516 }
1517
1518 /*
1519 * Procedure: BeceemEEPROMWritePage
1520 *
1521 * Description: Performs page write (16bytes) to the EEPROM
1522 *
1523 * Arguments:
1524 * Adapter - ptr to Adapter object instance
1525 * uiData - Data to be written.
1526 * uiOffset - Offset of the EEPROM where data needs to be written to.
1527 * Returns:
1528 * OSAL_STATUS_CODE
1529 *
1530 */
1531
1532 static int BeceemEEPROMWritePage(struct bcm_mini_adapter *Adapter, unsigned int uiData[], unsigned int uiOffset)
1533 {
1534 unsigned int uiRetries = MAX_EEPROM_RETRIES * RETRIES_PER_DELAY;
1535 unsigned int uiStatus = 0;
1536 UCHAR uiEpromStatus = 0;
1537 unsigned int value = 0;
1538
1539 /* Flush the Write/Read/Cmd queues. */
1540 value = (EEPROM_WRITE_QUEUE_FLUSH | EEPROM_CMD_QUEUE_FLUSH | EEPROM_READ_QUEUE_FLUSH);
1541 wrmalt(Adapter, SPI_FLUSH_REG, &value, sizeof(value));
1542 value = 0;
1543 wrmalt(Adapter, SPI_FLUSH_REG, &value, sizeof(value));
1544
1545 /* Clear the Empty/Avail/Full bits. After this it has been confirmed
1546 * that the bit was cleared by reading back the register. See NOTE below.
1547 * We also clear the Read queues as we do a EEPROM status register read
1548 * later.
1549 */
1550 value = (EEPROM_WRITE_QUEUE_EMPTY | EEPROM_WRITE_QUEUE_AVAIL | EEPROM_WRITE_QUEUE_FULL | EEPROM_READ_DATA_AVAIL | EEPROM_READ_DATA_FULL);
1551 wrmalt(Adapter, EEPROM_SPI_Q_STATUS1_REG, &value, sizeof(value));
1552
1553 /* Enable write */
1554 value = EEPROM_WRITE_ENABLE;
1555 wrmalt(Adapter, EEPROM_CMDQ_SPI_REG, &value, sizeof(value));
1556
1557 /* We can write back to back 8bits * 16 into the queue and as we have
1558 * checked for the queue to be empty we can write in a burst.
1559 */
1560
1561 value = uiData[0];
1562 BcmSwapWord(&value);
1563 wrm(Adapter, EEPROM_WRITE_DATAQ_REG, (PUCHAR)&value, 4);
1564
1565 value = uiData[1];
1566 BcmSwapWord(&value);
1567 wrm(Adapter, EEPROM_WRITE_DATAQ_REG, (PUCHAR)&value, 4);
1568
1569 value = uiData[2];
1570 BcmSwapWord(&value);
1571 wrm(Adapter, EEPROM_WRITE_DATAQ_REG, (PUCHAR)&value, 4);
1572
1573 value = uiData[3];
1574 BcmSwapWord(&value);
1575 wrm(Adapter, EEPROM_WRITE_DATAQ_REG, (PUCHAR)&value, 4);
1576
1577 /* NOTE : After this write, on readback of EEPROM_SPI_Q_STATUS1_REG
1578 * shows that we see 7 for the EEPROM data write. Which means that
1579 * queue got full, also space is available as well as the queue is empty.
1580 * This may happen in sequence.
1581 */
1582 value = EEPROM_16_BYTE_PAGE_WRITE | uiOffset;
1583 wrmalt(Adapter, EEPROM_CMDQ_SPI_REG, &value, sizeof(value));
1584
1585 /* Ideally we should loop here without tries and eventually succeed.
1586 * What we are checking if the previous write has completed, and this
1587 * may take time. We should wait till the Empty bit is set.
1588 */
1589 uiStatus = 0;
1590 rdmalt(Adapter, EEPROM_SPI_Q_STATUS1_REG, &uiStatus, sizeof(uiStatus));
1591 while ((uiStatus & EEPROM_WRITE_QUEUE_EMPTY) == 0) {
1592 uiRetries--;
1593 if (uiRetries == 0) {
1594 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "0x0f003004 = %x, %d retries failed.\n", uiStatus, MAX_EEPROM_RETRIES * RETRIES_PER_DELAY);
1595 return STATUS_FAILURE;
1596 }
1597
1598 if (!(uiRetries%RETRIES_PER_DELAY))
1599 udelay(1000);
1600
1601 uiStatus = 0;
1602 rdmalt(Adapter, EEPROM_SPI_Q_STATUS1_REG, &uiStatus, sizeof(uiStatus));
1603 if (Adapter->device_removed == TRUE) {
1604 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Modem got removed hence exiting from loop....");
1605 return -ENODEV;
1606 }
1607 }
1608
1609 if (uiRetries != 0) {
1610 /* Clear the ones that are set - either, Empty/Full/Avail bits */
1611 value = (uiStatus & (EEPROM_WRITE_QUEUE_EMPTY | EEPROM_WRITE_QUEUE_AVAIL | EEPROM_WRITE_QUEUE_FULL));
1612 wrmalt(Adapter, EEPROM_SPI_Q_STATUS1_REG, &value, sizeof(value));
1613 }
1614
1615 /* Here we should check if the EEPROM status register is correct before
1616 * proceeding. Bit 0 in the EEPROM Status register should be 0 before
1617 * we proceed further. A 1 at Bit 0 indicates that the EEPROM is busy
1618 * with the previous write. Note also that issuing this read finally
1619 * means the previous write to the EEPROM has completed.
1620 */
1621 uiRetries = MAX_EEPROM_RETRIES * RETRIES_PER_DELAY;
1622 uiEpromStatus = 0;
1623 while (uiRetries != 0) {
1624 uiEpromStatus = ReadEEPROMStatusRegister(Adapter);
1625 if (Adapter->device_removed == TRUE) {
1626 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Modem has got removed hence exiting from loop...");
1627 return -ENODEV;
1628 }
1629 if ((EEPROM_STATUS_REG_WRITE_BUSY & uiEpromStatus) == 0) {
1630 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "EEPROM status register = %x tries = %d\n", uiEpromStatus, (MAX_EEPROM_RETRIES * RETRIES_PER_DELAY - uiRetries));
1631 return STATUS_SUCCESS;
1632 }
1633 uiRetries--;
1634 if (uiRetries == 0) {
1635 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);
1636 return STATUS_FAILURE;
1637 }
1638 uiEpromStatus = 0;
1639 if (!(uiRetries%RETRIES_PER_DELAY))
1640 udelay(1000);
1641 }
1642
1643 return STATUS_SUCCESS;
1644 } /* BeceemEEPROMWritePage */
1645
1646 /*
1647 * Procedure: BeceemEEPROMBulkWrite
1648 *
1649 * Description: Performs write to the EEPROM
1650 *
1651 * Arguments:
1652 * Adapter - ptr to Adapter object instance
1653 * pBuffer - Data to be written.
1654 * uiOffset - Offset of the EEPROM where data needs to be written to.
1655 * uiNumBytes - Number of bytes to be written.
1656 * bVerify - read verify flag.
1657 * Returns:
1658 * OSAL_STATUS_CODE
1659 *
1660 */
1661
1662 int BeceemEEPROMBulkWrite(struct bcm_mini_adapter *Adapter,
1663 PUCHAR pBuffer,
1664 unsigned int uiOffset,
1665 unsigned int uiNumBytes,
1666 bool bVerify)
1667 {
1668 unsigned int uiBytesToCopy = uiNumBytes;
1669 /* unsigned int uiRdbk = 0; */
1670 unsigned int uiData[4] = {0};
1671 unsigned int uiIndex = 0;
1672 unsigned int uiTempOffset = 0;
1673 unsigned int uiExtraBytes = 0;
1674 /* PUINT puiBuffer = (PUINT)pBuffer;
1675 * int value;
1676 */
1677
1678 if (uiOffset % MAX_RW_SIZE && uiBytesToCopy) {
1679 uiTempOffset = uiOffset - (uiOffset % MAX_RW_SIZE);
1680 uiExtraBytes = uiOffset - uiTempOffset;
1681
1682 BeceemEEPROMBulkRead(Adapter, &uiData[0], uiTempOffset, MAX_RW_SIZE);
1683
1684 if (uiBytesToCopy >= (16 - uiExtraBytes)) {
1685 memcpy((((PUCHAR)&uiData[0]) + uiExtraBytes), pBuffer, MAX_RW_SIZE - uiExtraBytes);
1686
1687 if (STATUS_FAILURE == BeceemEEPROMWritePage(Adapter, uiData, uiTempOffset))
1688 return STATUS_FAILURE;
1689
1690 uiBytesToCopy -= (MAX_RW_SIZE - uiExtraBytes);
1691 uiIndex += (MAX_RW_SIZE - uiExtraBytes);
1692 uiOffset += (MAX_RW_SIZE - uiExtraBytes);
1693 } else {
1694 memcpy((((PUCHAR)&uiData[0]) + uiExtraBytes), pBuffer, uiBytesToCopy);
1695
1696 if (STATUS_FAILURE == BeceemEEPROMWritePage(Adapter, uiData, uiTempOffset))
1697 return STATUS_FAILURE;
1698
1699 uiIndex += uiBytesToCopy;
1700 uiOffset += uiBytesToCopy;
1701 uiBytesToCopy = 0;
1702 }
1703 }
1704
1705 while (uiBytesToCopy) {
1706 if (Adapter->device_removed)
1707 return -1;
1708
1709 if (uiBytesToCopy >= MAX_RW_SIZE) {
1710 if (STATUS_FAILURE == BeceemEEPROMWritePage(Adapter, (PUINT) &pBuffer[uiIndex], uiOffset))
1711 return STATUS_FAILURE;
1712
1713 uiIndex += MAX_RW_SIZE;
1714 uiOffset += MAX_RW_SIZE;
1715 uiBytesToCopy -= MAX_RW_SIZE;
1716 } else {
1717 /*
1718 * To program non 16byte aligned data, read 16byte and then update.
1719 */
1720 BeceemEEPROMBulkRead(Adapter, &uiData[0], uiOffset, 16);
1721 memcpy(&uiData[0], pBuffer + uiIndex, uiBytesToCopy);
1722
1723 if (STATUS_FAILURE == BeceemEEPROMWritePage(Adapter, uiData, uiOffset))
1724 return STATUS_FAILURE;
1725
1726 uiBytesToCopy = 0;
1727 }
1728 }
1729
1730 return 0;
1731 }
1732
1733 /*
1734 * Procedure: BeceemNVMRead
1735 *
1736 * Description: Reads n number of bytes from NVM.
1737 *
1738 * Arguments:
1739 * Adapter - ptr to Adapter object instance
1740 * pBuffer - Buffer to store the data read from NVM
1741 * uiOffset - Offset of NVM from where data should be read
1742 * uiNumBytes - Number of bytes to be read from the NVM.
1743 *
1744 * Returns:
1745 * OSAL_STATUS_SUCCESS - if NVM read is successful.
1746 * <FAILURE> - if failed.
1747 */
1748
1749 int BeceemNVMRead(struct bcm_mini_adapter *Adapter,
1750 PUINT pBuffer,
1751 unsigned int uiOffset,
1752 unsigned int uiNumBytes)
1753 {
1754 int Status = 0;
1755
1756 #if !defined(BCM_SHM_INTERFACE) || defined(FLASH_DIRECT_ACCESS)
1757 unsigned int uiTemp = 0, value;
1758 #endif
1759
1760 if (Adapter->eNVMType == NVM_FLASH) {
1761 if (Adapter->bFlashRawRead == false) {
1762 if (IsSectionExistInVendorInfo(Adapter, Adapter->eActiveDSD))
1763 return vendorextnReadSection(Adapter, (PUCHAR)pBuffer, Adapter->eActiveDSD, uiOffset, uiNumBytes);
1764
1765 uiOffset = uiOffset + Adapter->ulFlashCalStart;
1766 }
1767
1768 #if defined(BCM_SHM_INTERFACE) && !defined(FLASH_DIRECT_ACCESS)
1769 Status = bcmflash_raw_read((uiOffset / FLASH_PART_SIZE), (uiOffset % FLASH_PART_SIZE), (unsigned char *)pBuffer, uiNumBytes);
1770 #else
1771 rdmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
1772 value = 0;
1773 wrmalt(Adapter, 0x0f000C80, &value, sizeof(value));
1774 Status = BeceemFlashBulkRead(Adapter,
1775 pBuffer,
1776 uiOffset,
1777 uiNumBytes);
1778 wrmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
1779 #endif
1780 } else if (Adapter->eNVMType == NVM_EEPROM) {
1781 Status = BeceemEEPROMBulkRead(Adapter,
1782 pBuffer,
1783 uiOffset,
1784 uiNumBytes);
1785 } else {
1786 Status = -1;
1787 }
1788
1789 return Status;
1790 }
1791
1792 /*
1793 * Procedure: BeceemNVMWrite
1794 *
1795 * Description: Writes n number of bytes to NVM.
1796 *
1797 * Arguments:
1798 * Adapter - ptr to Adapter object instance
1799 * pBuffer - Buffer contains the data to be written.
1800 * uiOffset - Offset of NVM where data to be written to.
1801 * uiNumBytes - Number of bytes to be written..
1802 *
1803 * Returns:
1804 * OSAL_STATUS_SUCCESS - if NVM write is successful.
1805 * <FAILURE> - if failed.
1806 */
1807
1808 int BeceemNVMWrite(struct bcm_mini_adapter *Adapter,
1809 PUINT pBuffer,
1810 unsigned int uiOffset,
1811 unsigned int uiNumBytes,
1812 bool bVerify)
1813 {
1814 int Status = 0;
1815 unsigned int uiTemp = 0;
1816 unsigned int uiMemoryLoc = EEPROM_CAL_DATA_INTERNAL_LOC;
1817 unsigned int uiIndex = 0;
1818
1819 #if !defined(BCM_SHM_INTERFACE) || defined(FLASH_DIRECT_ACCESS)
1820 unsigned int value;
1821 #endif
1822
1823 unsigned int uiFlashOffset = 0;
1824
1825 if (Adapter->eNVMType == NVM_FLASH) {
1826 if (IsSectionExistInVendorInfo(Adapter, Adapter->eActiveDSD))
1827 Status = vendorextnWriteSection(Adapter, (PUCHAR)pBuffer, Adapter->eActiveDSD, uiOffset, uiNumBytes, bVerify);
1828 else {
1829 uiFlashOffset = uiOffset + Adapter->ulFlashCalStart;
1830
1831 #if defined(BCM_SHM_INTERFACE) && !defined(FLASH_DIRECT_ACCESS)
1832 Status = bcmflash_raw_write((uiFlashOffset / FLASH_PART_SIZE), (uiFlashOffset % FLASH_PART_SIZE), (unsigned char *)pBuffer, uiNumBytes);
1833 #else
1834 rdmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
1835 value = 0;
1836 wrmalt(Adapter, 0x0f000C80, &value, sizeof(value));
1837
1838 if (Adapter->bStatusWrite == TRUE)
1839 Status = BeceemFlashBulkWriteStatus(Adapter,
1840 pBuffer,
1841 uiFlashOffset,
1842 uiNumBytes ,
1843 bVerify);
1844 else
1845
1846 Status = BeceemFlashBulkWrite(Adapter,
1847 pBuffer,
1848 uiFlashOffset,
1849 uiNumBytes,
1850 bVerify);
1851 #endif
1852 }
1853
1854 if (uiOffset >= EEPROM_CALPARAM_START) {
1855 uiMemoryLoc += (uiOffset - EEPROM_CALPARAM_START);
1856 while (uiNumBytes) {
1857 if (uiNumBytes > BUFFER_4K) {
1858 wrm(Adapter, (uiMemoryLoc+uiIndex), (PCHAR)(pBuffer + (uiIndex / 4)), BUFFER_4K);
1859 uiNumBytes -= BUFFER_4K;
1860 uiIndex += BUFFER_4K;
1861 } else {
1862 wrm(Adapter, uiMemoryLoc+uiIndex, (PCHAR)(pBuffer + (uiIndex / 4)), uiNumBytes);
1863 uiNumBytes = 0;
1864 break;
1865 }
1866 }
1867 } else {
1868 if ((uiOffset + uiNumBytes) > EEPROM_CALPARAM_START) {
1869 ULONG ulBytesTobeSkipped = 0;
1870 PUCHAR pcBuffer = (PUCHAR)pBuffer; /* char pointer to take care of odd byte cases. */
1871 uiNumBytes -= (EEPROM_CALPARAM_START - uiOffset);
1872 ulBytesTobeSkipped += (EEPROM_CALPARAM_START - uiOffset);
1873 uiOffset += (EEPROM_CALPARAM_START - uiOffset);
1874 while (uiNumBytes) {
1875 if (uiNumBytes > BUFFER_4K) {
1876 wrm(Adapter, uiMemoryLoc + uiIndex, (PCHAR)&pcBuffer[ulBytesTobeSkipped + uiIndex], BUFFER_4K);
1877 uiNumBytes -= BUFFER_4K;
1878 uiIndex += BUFFER_4K;
1879 } else {
1880 wrm(Adapter, uiMemoryLoc + uiIndex, (PCHAR)&pcBuffer[ulBytesTobeSkipped + uiIndex], uiNumBytes);
1881 uiNumBytes = 0;
1882 break;
1883 }
1884 }
1885 }
1886 }
1887 /* restore the values. */
1888 wrmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
1889 } else if (Adapter->eNVMType == NVM_EEPROM) {
1890 Status = BeceemEEPROMBulkWrite(Adapter,
1891 (PUCHAR)pBuffer,
1892 uiOffset,
1893 uiNumBytes,
1894 bVerify);
1895 if (bVerify)
1896 Status = BeceemEEPROMReadBackandVerify(Adapter, (PUINT)pBuffer, uiOffset, uiNumBytes);
1897 } else {
1898 Status = -1;
1899 }
1900 return Status;
1901 }
1902
1903 /*
1904 * Procedure: BcmUpdateSectorSize
1905 *
1906 * Description: Updates the sector size to FLASH.
1907 *
1908 * Arguments:
1909 * Adapter - ptr to Adapter object instance
1910 * uiSectorSize - sector size
1911 *
1912 * Returns:
1913 * OSAL_STATUS_SUCCESS - if NVM write is successful.
1914 * <FAILURE> - if failed.
1915 */
1916
1917 int BcmUpdateSectorSize(struct bcm_mini_adapter *Adapter, unsigned int uiSectorSize)
1918 {
1919 int Status = -1;
1920 struct bcm_flash_cs_info sFlashCsInfo = {0};
1921 unsigned int uiTemp = 0;
1922 unsigned int uiSectorSig = 0;
1923 unsigned int uiCurrentSectorSize = 0;
1924 unsigned int value;
1925
1926 rdmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
1927 value = 0;
1928 wrmalt(Adapter, 0x0f000C80, &value, sizeof(value));
1929
1930 /*
1931 * Before updating the sector size in the reserved area, check if already present.
1932 */
1933 BeceemFlashBulkRead(Adapter, (PUINT)&sFlashCsInfo, Adapter->ulFlashControlSectionStart, sizeof(sFlashCsInfo));
1934 uiSectorSig = ntohl(sFlashCsInfo.FlashSectorSizeSig);
1935 uiCurrentSectorSize = ntohl(sFlashCsInfo.FlashSectorSize);
1936
1937 if (uiSectorSig == FLASH_SECTOR_SIZE_SIG) {
1938 if ((uiCurrentSectorSize <= MAX_SECTOR_SIZE) && (uiCurrentSectorSize >= MIN_SECTOR_SIZE)) {
1939 if (uiSectorSize == uiCurrentSectorSize) {
1940 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Provided sector size is same as programmed in Flash");
1941 Status = STATUS_SUCCESS;
1942 goto Restore;
1943 }
1944 }
1945 }
1946
1947 if ((uiSectorSize <= MAX_SECTOR_SIZE) && (uiSectorSize >= MIN_SECTOR_SIZE)) {
1948 sFlashCsInfo.FlashSectorSize = htonl(uiSectorSize);
1949 sFlashCsInfo.FlashSectorSizeSig = htonl(FLASH_SECTOR_SIZE_SIG);
1950
1951 Status = BeceemFlashBulkWrite(Adapter,
1952 (PUINT)&sFlashCsInfo,
1953 Adapter->ulFlashControlSectionStart,
1954 sizeof(sFlashCsInfo),
1955 TRUE);
1956 }
1957
1958 Restore:
1959 /* restore the values. */
1960 wrmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
1961
1962 return Status;
1963 }
1964
1965 /*
1966 * Procedure: BcmGetFlashSectorSize
1967 *
1968 * Description: Finds the sector size of the FLASH.
1969 *
1970 * Arguments:
1971 * Adapter - ptr to Adapter object instance
1972 *
1973 * Returns:
1974 * unsigned int - sector size.
1975 *
1976 */
1977
1978 static unsigned int BcmGetFlashSectorSize(struct bcm_mini_adapter *Adapter, unsigned int FlashSectorSizeSig, unsigned int FlashSectorSize)
1979 {
1980 unsigned int uiSectorSize = 0;
1981 unsigned int uiSectorSig = 0;
1982
1983 if (Adapter->bSectorSizeOverride &&
1984 (Adapter->uiSectorSizeInCFG <= MAX_SECTOR_SIZE &&
1985 Adapter->uiSectorSizeInCFG >= MIN_SECTOR_SIZE)) {
1986 Adapter->uiSectorSize = Adapter->uiSectorSizeInCFG;
1987 } else {
1988 uiSectorSig = FlashSectorSizeSig;
1989
1990 if (uiSectorSig == FLASH_SECTOR_SIZE_SIG) {
1991 uiSectorSize = FlashSectorSize;
1992 /*
1993 * If the sector size stored in the FLASH makes sense then use it.
1994 */
1995 if (uiSectorSize <= MAX_SECTOR_SIZE && uiSectorSize >= MIN_SECTOR_SIZE) {
1996 Adapter->uiSectorSize = uiSectorSize;
1997 } else if (Adapter->uiSectorSizeInCFG <= MAX_SECTOR_SIZE &&
1998 Adapter->uiSectorSizeInCFG >= MIN_SECTOR_SIZE) {
1999 /* No valid size in FLASH, check if Config file has it. */
2000 Adapter->uiSectorSize = Adapter->uiSectorSizeInCFG;
2001 } else {
2002 /* Init to Default, if none of the above works. */
2003 Adapter->uiSectorSize = DEFAULT_SECTOR_SIZE;
2004 }
2005 } else {
2006 if (Adapter->uiSectorSizeInCFG <= MAX_SECTOR_SIZE &&
2007 Adapter->uiSectorSizeInCFG >= MIN_SECTOR_SIZE)
2008 Adapter->uiSectorSize = Adapter->uiSectorSizeInCFG;
2009 else
2010 Adapter->uiSectorSize = DEFAULT_SECTOR_SIZE;
2011 }
2012 }
2013
2014 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Sector size :%x\n", Adapter->uiSectorSize);
2015
2016 return Adapter->uiSectorSize;
2017 }
2018
2019 /*
2020 * Procedure: BcmInitEEPROMQueues
2021 *
2022 * Description: Initialization of EEPROM queues.
2023 *
2024 * Arguments:
2025 * Adapter - ptr to Adapter object instance
2026 *
2027 * Returns:
2028 * <OSAL_STATUS_CODE>
2029 */
2030
2031 static int BcmInitEEPROMQueues(struct bcm_mini_adapter *Adapter)
2032 {
2033 unsigned int value = 0;
2034 /* CHIP Bug : Clear the Avail bits on the Read queue. The default
2035 * value on this register is supposed to be 0x00001102.
2036 * But we get 0x00001122.
2037 */
2038 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Fixing reset value on 0x0f003004 register\n");
2039 value = EEPROM_READ_DATA_AVAIL;
2040 wrmalt(Adapter, EEPROM_SPI_Q_STATUS1_REG, &value, sizeof(value));
2041
2042 /* Flush the all the EEPROM queues. */
2043 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, " Flushing the queues\n");
2044 value = EEPROM_ALL_QUEUE_FLUSH;
2045 wrmalt(Adapter, SPI_FLUSH_REG, &value, sizeof(value));
2046
2047 value = 0;
2048 wrmalt(Adapter, SPI_FLUSH_REG, &value, sizeof(value));
2049
2050 /* Read the EEPROM Status Register. Just to see, no real purpose. */
2051 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "EEPROM Status register value = %x\n", ReadEEPROMStatusRegister(Adapter));
2052
2053 return STATUS_SUCCESS;
2054 } /* BcmInitEEPROMQueues() */
2055
2056 /*
2057 * Procedure: BcmInitNVM
2058 *
2059 * Description: Initialization of NVM, EEPROM size,FLASH size, sector size etc.
2060 *
2061 * Arguments:
2062 * Adapter - ptr to Adapter object instance
2063 *
2064 * Returns:
2065 * <OSAL_STATUS_CODE>
2066 */
2067
2068 int BcmInitNVM(struct bcm_mini_adapter *ps_adapter)
2069 {
2070 BcmValidateNvmType(ps_adapter);
2071 BcmInitEEPROMQueues(ps_adapter);
2072
2073 if (ps_adapter->eNVMType == NVM_AUTODETECT) {
2074 ps_adapter->eNVMType = BcmGetNvmType(ps_adapter);
2075 if (ps_adapter->eNVMType == NVM_UNKNOWN)
2076 BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_PRINTK, 0, 0, "NVM Type is unknown!!\n");
2077 } else if (ps_adapter->eNVMType == NVM_FLASH) {
2078 BcmGetFlashCSInfo(ps_adapter);
2079 }
2080
2081 BcmGetNvmSize(ps_adapter);
2082
2083 return STATUS_SUCCESS;
2084 }
2085
2086 /* BcmGetNvmSize : set the EEPROM or flash size in Adapter.
2087 *
2088 * Input Parameter:
2089 * Adapter data structure
2090 * Return Value :
2091 * 0. means success;
2092 */
2093
2094 static int BcmGetNvmSize(struct bcm_mini_adapter *Adapter)
2095 {
2096 if (Adapter->eNVMType == NVM_EEPROM)
2097 Adapter->uiNVMDSDSize = BcmGetEEPROMSize(Adapter);
2098 else if (Adapter->eNVMType == NVM_FLASH)
2099 Adapter->uiNVMDSDSize = BcmGetFlashSize(Adapter);
2100
2101 return 0;
2102 }
2103
2104 /*
2105 * Procedure: BcmValidateNvm
2106 *
2107 * Description: Validates the NVM Type option selected against the device
2108 *
2109 * Arguments:
2110 * Adapter - ptr to Adapter object instance
2111 *
2112 * Returns:
2113 * <VOID>
2114 */
2115
2116 static VOID BcmValidateNvmType(struct bcm_mini_adapter *Adapter)
2117 {
2118 /*
2119 * if forcing the FLASH through CFG file, we should ensure device really has a FLASH.
2120 * Accessing the FLASH address without the FLASH being present can cause hang/freeze etc.
2121 * So if NVM_FLASH is selected for older chipsets, change it to AUTODETECT where EEPROM is 1st choice.
2122 */
2123
2124 if (Adapter->eNVMType == NVM_FLASH &&
2125 Adapter->chip_id < 0xBECE3300)
2126 Adapter->eNVMType = NVM_AUTODETECT;
2127 }
2128
2129 /*
2130 * Procedure: BcmReadFlashRDID
2131 *
2132 * Description: Reads ID from Serial Flash
2133 *
2134 * Arguments:
2135 * Adapter - ptr to Adapter object instance
2136 *
2137 * Returns:
2138 * Flash ID
2139 */
2140
2141 static ULONG BcmReadFlashRDID(struct bcm_mini_adapter *Adapter)
2142 {
2143 ULONG ulRDID = 0;
2144 unsigned int value;
2145
2146 /*
2147 * Read ID Instruction.
2148 */
2149 value = (FLASH_CMD_READ_ID << 24);
2150 wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value));
2151
2152 /* Delay */
2153 udelay(10);
2154
2155 /*
2156 * Read SPI READQ REG. The output will be WWXXYYZZ.
2157 * The ID is 3Bytes long and is WWXXYY. ZZ needs to be Ignored.
2158 */
2159 rdmalt(Adapter, FLASH_SPI_READQ_REG, (PUINT)&ulRDID, sizeof(ulRDID));
2160
2161 return ulRDID >> 8;
2162 }
2163
2164 int BcmAllocFlashCSStructure(struct bcm_mini_adapter *psAdapter)
2165 {
2166 if (!psAdapter) {
2167 BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_PRINTK, 0, 0, "Adapter structure point is NULL");
2168 return -EINVAL;
2169 }
2170 psAdapter->psFlashCSInfo = kzalloc(sizeof(struct bcm_flash_cs_info), GFP_KERNEL);
2171 if (psAdapter->psFlashCSInfo == NULL) {
2172 BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_PRINTK, 0, 0, "Can't Allocate memory for Flash 1.x");
2173 return -ENOMEM;
2174 }
2175
2176 psAdapter->psFlash2xCSInfo = kzalloc(sizeof(struct bcm_flash2x_cs_info), GFP_KERNEL);
2177 if (!psAdapter->psFlash2xCSInfo) {
2178 BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_PRINTK, 0, 0, "Can't Allocate memory for Flash 2.x");
2179 kfree(psAdapter->psFlashCSInfo);
2180 return -ENOMEM;
2181 }
2182
2183 psAdapter->psFlash2xVendorInfo = kzalloc(sizeof(struct bcm_flash2x_vendor_info), GFP_KERNEL);
2184 if (!psAdapter->psFlash2xVendorInfo) {
2185 BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_PRINTK, 0, 0, "Can't Allocate Vendor Info Memory for Flash 2.x");
2186 kfree(psAdapter->psFlashCSInfo);
2187 kfree(psAdapter->psFlash2xCSInfo);
2188 return -ENOMEM;
2189 }
2190
2191 return STATUS_SUCCESS;
2192 }
2193
2194 int BcmDeAllocFlashCSStructure(struct bcm_mini_adapter *psAdapter)
2195 {
2196 if (!psAdapter) {
2197 BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_PRINTK, 0, 0, "Adapter structure point is NULL");
2198 return -EINVAL;
2199 }
2200 kfree(psAdapter->psFlashCSInfo);
2201 kfree(psAdapter->psFlash2xCSInfo);
2202 kfree(psAdapter->psFlash2xVendorInfo);
2203 return STATUS_SUCCESS;
2204 }
2205
2206 static int BcmDumpFlash2XCSStructure(struct bcm_flash2x_cs_info *psFlash2xCSInfo, struct bcm_mini_adapter *Adapter)
2207 {
2208 unsigned int Index = 0;
2209
2210 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "**********************FLASH2X CS Structure *******************");
2211 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Signature is :%x", (psFlash2xCSInfo->MagicNumber));
2212 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Flash Major Version :%d", MAJOR_VERSION(psFlash2xCSInfo->FlashLayoutVersion));
2213 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Flash Minor Version :%d", MINOR_VERSION(psFlash2xCSInfo->FlashLayoutVersion));
2214 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, " ISOImageMajorVersion:0x%x", (psFlash2xCSInfo->ISOImageVersion));
2215 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "SCSIFirmwareMajorVersion :0x%x", (psFlash2xCSInfo->SCSIFirmwareVersion));
2216 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForPart1ISOImage :0x%x", (psFlash2xCSInfo->OffsetFromZeroForPart1ISOImage));
2217 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForScsiFirmware :0x%x", (psFlash2xCSInfo->OffsetFromZeroForScsiFirmware));
2218 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "SizeOfScsiFirmware :0x%x", (psFlash2xCSInfo->SizeOfScsiFirmware));
2219 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForPart2ISOImage :0x%x", (psFlash2xCSInfo->OffsetFromZeroForPart2ISOImage));
2220 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForDSDStart :0x%x", (psFlash2xCSInfo->OffsetFromZeroForDSDStart));
2221 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForDSDEnd :0x%x", (psFlash2xCSInfo->OffsetFromZeroForDSDEnd));
2222 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForVSAStart :0x%x", (psFlash2xCSInfo->OffsetFromZeroForVSAStart));
2223 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForVSAEnd :0x%x", (psFlash2xCSInfo->OffsetFromZeroForVSAEnd));
2224 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForControlSectionStart :0x%x", (psFlash2xCSInfo->OffsetFromZeroForControlSectionStart));
2225 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForControlSectionData :0x%x", (psFlash2xCSInfo->OffsetFromZeroForControlSectionData));
2226 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "CDLessInactivityTimeout :0x%x", (psFlash2xCSInfo->CDLessInactivityTimeout));
2227 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "NewImageSignature :0x%x", (psFlash2xCSInfo->NewImageSignature));
2228 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "FlashSectorSizeSig :0x%x", (psFlash2xCSInfo->FlashSectorSizeSig));
2229 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "FlashSectorSize :0x%x", (psFlash2xCSInfo->FlashSectorSize));
2230 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "FlashWriteSupportSize :0x%x", (psFlash2xCSInfo->FlashWriteSupportSize));
2231 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "TotalFlashSize :0x%X", (psFlash2xCSInfo->TotalFlashSize));
2232 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "FlashBaseAddr :0x%x", (psFlash2xCSInfo->FlashBaseAddr));
2233 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "FlashPartMaxSize :0x%x", (psFlash2xCSInfo->FlashPartMaxSize));
2234 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "IsCDLessDeviceBootSig :0x%x", (psFlash2xCSInfo->IsCDLessDeviceBootSig));
2235 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "MassStorageTimeout :0x%x", (psFlash2xCSInfo->MassStorageTimeout));
2236 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage1Part1Start :0x%x", (psFlash2xCSInfo->OffsetISOImage1Part1Start));
2237 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage1Part1End :0x%x", (psFlash2xCSInfo->OffsetISOImage1Part1End));
2238 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage1Part2Start :0x%x", (psFlash2xCSInfo->OffsetISOImage1Part2Start));
2239 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage1Part2End :0x%x", (psFlash2xCSInfo->OffsetISOImage1Part2End));
2240 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage1Part3Start :0x%x", (psFlash2xCSInfo->OffsetISOImage1Part3Start));
2241 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage1Part3End :0x%x", (psFlash2xCSInfo->OffsetISOImage1Part3End));
2242 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage2Part1Start :0x%x", (psFlash2xCSInfo->OffsetISOImage2Part1Start));
2243 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage2Part1End :0x%x", (psFlash2xCSInfo->OffsetISOImage2Part1End));
2244 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage2Part2Start :0x%x", (psFlash2xCSInfo->OffsetISOImage2Part2Start));
2245 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage2Part2End :0x%x", (psFlash2xCSInfo->OffsetISOImage2Part2End));
2246 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage2Part3Start :0x%x", (psFlash2xCSInfo->OffsetISOImage2Part3Start));
2247 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage2Part3End :0x%x", (psFlash2xCSInfo->OffsetISOImage2Part3End));
2248 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromDSDStartForDSDHeader :0x%x", (psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader));
2249 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForDSD1Start :0x%x", (psFlash2xCSInfo->OffsetFromZeroForDSD1Start));
2250 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForDSD1End :0x%x", (psFlash2xCSInfo->OffsetFromZeroForDSD1End));
2251 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForDSD2Start :0x%x", (psFlash2xCSInfo->OffsetFromZeroForDSD2Start));
2252 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForDSD2End :0x%x", (psFlash2xCSInfo->OffsetFromZeroForDSD2End));
2253 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForVSA1Start :0x%x", (psFlash2xCSInfo->OffsetFromZeroForVSA1Start));
2254 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForVSA1End :0x%x", (psFlash2xCSInfo->OffsetFromZeroForVSA1End));
2255 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForVSA2Start :0x%x", (psFlash2xCSInfo->OffsetFromZeroForVSA2Start));
2256 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForVSA2End :0x%x", (psFlash2xCSInfo->OffsetFromZeroForVSA2End));
2257 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Sector Access Bit Map is Defined as :");
2258
2259 for (Index = 0; Index < (FLASH2X_TOTAL_SIZE / (DEFAULT_SECTOR_SIZE * 16)); Index++)
2260 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "SectorAccessBitMap[%d] :0x%x", Index,
2261 (psFlash2xCSInfo->SectorAccessBitMap[Index]));
2262
2263 return STATUS_SUCCESS;
2264 }
2265
2266 static int ConvertEndianOf2XCSStructure(struct bcm_flash2x_cs_info *psFlash2xCSInfo)
2267 {
2268 unsigned int Index = 0;
2269
2270 psFlash2xCSInfo->MagicNumber = ntohl(psFlash2xCSInfo->MagicNumber);
2271 psFlash2xCSInfo->FlashLayoutVersion = ntohl(psFlash2xCSInfo->FlashLayoutVersion);
2272 /* psFlash2xCSInfo->FlashLayoutMinorVersion = ntohs(psFlash2xCSInfo->FlashLayoutMinorVersion); */
2273 psFlash2xCSInfo->ISOImageVersion = ntohl(psFlash2xCSInfo->ISOImageVersion);
2274 psFlash2xCSInfo->SCSIFirmwareVersion = ntohl(psFlash2xCSInfo->SCSIFirmwareVersion);
2275 psFlash2xCSInfo->OffsetFromZeroForPart1ISOImage = ntohl(psFlash2xCSInfo->OffsetFromZeroForPart1ISOImage);
2276 psFlash2xCSInfo->OffsetFromZeroForScsiFirmware = ntohl(psFlash2xCSInfo->OffsetFromZeroForScsiFirmware);
2277 psFlash2xCSInfo->SizeOfScsiFirmware = ntohl(psFlash2xCSInfo->SizeOfScsiFirmware);
2278 psFlash2xCSInfo->OffsetFromZeroForPart2ISOImage = ntohl(psFlash2xCSInfo->OffsetFromZeroForPart2ISOImage);
2279 psFlash2xCSInfo->OffsetFromZeroForDSDStart = ntohl(psFlash2xCSInfo->OffsetFromZeroForDSDStart);
2280 psFlash2xCSInfo->OffsetFromZeroForDSDEnd = ntohl(psFlash2xCSInfo->OffsetFromZeroForDSDEnd);
2281 psFlash2xCSInfo->OffsetFromZeroForVSAStart = ntohl(psFlash2xCSInfo->OffsetFromZeroForVSAStart);
2282 psFlash2xCSInfo->OffsetFromZeroForVSAEnd = ntohl(psFlash2xCSInfo->OffsetFromZeroForVSAEnd);
2283 psFlash2xCSInfo->OffsetFromZeroForControlSectionStart = ntohl(psFlash2xCSInfo->OffsetFromZeroForControlSectionStart);
2284 psFlash2xCSInfo->OffsetFromZeroForControlSectionData = ntohl(psFlash2xCSInfo->OffsetFromZeroForControlSectionData);
2285 psFlash2xCSInfo->CDLessInactivityTimeout = ntohl(psFlash2xCSInfo->CDLessInactivityTimeout);
2286 psFlash2xCSInfo->NewImageSignature = ntohl(psFlash2xCSInfo->NewImageSignature);
2287 psFlash2xCSInfo->FlashSectorSizeSig = ntohl(psFlash2xCSInfo->FlashSectorSizeSig);
2288 psFlash2xCSInfo->FlashSectorSize = ntohl(psFlash2xCSInfo->FlashSectorSize);
2289 psFlash2xCSInfo->FlashWriteSupportSize = ntohl(psFlash2xCSInfo->FlashWriteSupportSize);
2290 psFlash2xCSInfo->TotalFlashSize = ntohl(psFlash2xCSInfo->TotalFlashSize);
2291 psFlash2xCSInfo->FlashBaseAddr = ntohl(psFlash2xCSInfo->FlashBaseAddr);
2292 psFlash2xCSInfo->FlashPartMaxSize = ntohl(psFlash2xCSInfo->FlashPartMaxSize);
2293 psFlash2xCSInfo->IsCDLessDeviceBootSig = ntohl(psFlash2xCSInfo->IsCDLessDeviceBootSig);
2294 psFlash2xCSInfo->MassStorageTimeout = ntohl(psFlash2xCSInfo->MassStorageTimeout);
2295 psFlash2xCSInfo->OffsetISOImage1Part1Start = ntohl(psFlash2xCSInfo->OffsetISOImage1Part1Start);
2296 psFlash2xCSInfo->OffsetISOImage1Part1End = ntohl(psFlash2xCSInfo->OffsetISOImage1Part1End);
2297 psFlash2xCSInfo->OffsetISOImage1Part2Start = ntohl(psFlash2xCSInfo->OffsetISOImage1Part2Start);
2298 psFlash2xCSInfo->OffsetISOImage1Part2End = ntohl(psFlash2xCSInfo->OffsetISOImage1Part2End);
2299 psFlash2xCSInfo->OffsetISOImage1Part3Start = ntohl(psFlash2xCSInfo->OffsetISOImage1Part3Start);
2300 psFlash2xCSInfo->OffsetISOImage1Part3End = ntohl(psFlash2xCSInfo->OffsetISOImage1Part3End);
2301 psFlash2xCSInfo->OffsetISOImage2Part1Start = ntohl(psFlash2xCSInfo->OffsetISOImage2Part1Start);
2302 psFlash2xCSInfo->OffsetISOImage2Part1End = ntohl(psFlash2xCSInfo->OffsetISOImage2Part1End);
2303 psFlash2xCSInfo->OffsetISOImage2Part2Start = ntohl(psFlash2xCSInfo->OffsetISOImage2Part2Start);
2304 psFlash2xCSInfo->OffsetISOImage2Part2End = ntohl(psFlash2xCSInfo->OffsetISOImage2Part2End);
2305 psFlash2xCSInfo->OffsetISOImage2Part3Start = ntohl(psFlash2xCSInfo->OffsetISOImage2Part3Start);
2306 psFlash2xCSInfo->OffsetISOImage2Part3End = ntohl(psFlash2xCSInfo->OffsetISOImage2Part3End);
2307 psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader = ntohl(psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader);
2308 psFlash2xCSInfo->OffsetFromZeroForDSD1Start = ntohl(psFlash2xCSInfo->OffsetFromZeroForDSD1Start);
2309 psFlash2xCSInfo->OffsetFromZeroForDSD1End = ntohl(psFlash2xCSInfo->OffsetFromZeroForDSD1End);
2310 psFlash2xCSInfo->OffsetFromZeroForDSD2Start = ntohl(psFlash2xCSInfo->OffsetFromZeroForDSD2Start);
2311 psFlash2xCSInfo->OffsetFromZeroForDSD2End = ntohl(psFlash2xCSInfo->OffsetFromZeroForDSD2End);
2312 psFlash2xCSInfo->OffsetFromZeroForVSA1Start = ntohl(psFlash2xCSInfo->OffsetFromZeroForVSA1Start);
2313 psFlash2xCSInfo->OffsetFromZeroForVSA1End = ntohl(psFlash2xCSInfo->OffsetFromZeroForVSA1End);
2314 psFlash2xCSInfo->OffsetFromZeroForVSA2Start = ntohl(psFlash2xCSInfo->OffsetFromZeroForVSA2Start);
2315 psFlash2xCSInfo->OffsetFromZeroForVSA2End = ntohl(psFlash2xCSInfo->OffsetFromZeroForVSA2End);
2316
2317 for (Index = 0; Index < (FLASH2X_TOTAL_SIZE / (DEFAULT_SECTOR_SIZE * 16)); Index++)
2318 psFlash2xCSInfo->SectorAccessBitMap[Index] = ntohl(psFlash2xCSInfo->SectorAccessBitMap[Index]);
2319
2320 return STATUS_SUCCESS;
2321 }
2322
2323 static int ConvertEndianOfCSStructure(struct bcm_flash_cs_info *psFlashCSInfo)
2324 {
2325 /* unsigned int Index = 0; */
2326 psFlashCSInfo->MagicNumber = ntohl(psFlashCSInfo->MagicNumber);
2327 psFlashCSInfo->FlashLayoutVersion = ntohl(psFlashCSInfo->FlashLayoutVersion);
2328 psFlashCSInfo->ISOImageVersion = ntohl(psFlashCSInfo->ISOImageVersion);
2329 /* won't convert according to old assumption */
2330 psFlashCSInfo->SCSIFirmwareVersion = (psFlashCSInfo->SCSIFirmwareVersion);
2331 psFlashCSInfo->OffsetFromZeroForPart1ISOImage = ntohl(psFlashCSInfo->OffsetFromZeroForPart1ISOImage);
2332 psFlashCSInfo->OffsetFromZeroForScsiFirmware = ntohl(psFlashCSInfo->OffsetFromZeroForScsiFirmware);
2333 psFlashCSInfo->SizeOfScsiFirmware = ntohl(psFlashCSInfo->SizeOfScsiFirmware);
2334 psFlashCSInfo->OffsetFromZeroForPart2ISOImage = ntohl(psFlashCSInfo->OffsetFromZeroForPart2ISOImage);
2335 psFlashCSInfo->OffsetFromZeroForCalibrationStart = ntohl(psFlashCSInfo->OffsetFromZeroForCalibrationStart);
2336 psFlashCSInfo->OffsetFromZeroForCalibrationEnd = ntohl(psFlashCSInfo->OffsetFromZeroForCalibrationEnd);
2337 psFlashCSInfo->OffsetFromZeroForVSAStart = ntohl(psFlashCSInfo->OffsetFromZeroForVSAStart);
2338 psFlashCSInfo->OffsetFromZeroForVSAEnd = ntohl(psFlashCSInfo->OffsetFromZeroForVSAEnd);
2339 psFlashCSInfo->OffsetFromZeroForControlSectionStart = ntohl(psFlashCSInfo->OffsetFromZeroForControlSectionStart);
2340 psFlashCSInfo->OffsetFromZeroForControlSectionData = ntohl(psFlashCSInfo->OffsetFromZeroForControlSectionData);
2341 psFlashCSInfo->CDLessInactivityTimeout = ntohl(psFlashCSInfo->CDLessInactivityTimeout);
2342 psFlashCSInfo->NewImageSignature = ntohl(psFlashCSInfo->NewImageSignature);
2343 psFlashCSInfo->FlashSectorSizeSig = ntohl(psFlashCSInfo->FlashSectorSizeSig);
2344 psFlashCSInfo->FlashSectorSize = ntohl(psFlashCSInfo->FlashSectorSize);
2345 psFlashCSInfo->FlashWriteSupportSize = ntohl(psFlashCSInfo->FlashWriteSupportSize);
2346 psFlashCSInfo->TotalFlashSize = ntohl(psFlashCSInfo->TotalFlashSize);
2347 psFlashCSInfo->FlashBaseAddr = ntohl(psFlashCSInfo->FlashBaseAddr);
2348 psFlashCSInfo->FlashPartMaxSize = ntohl(psFlashCSInfo->FlashPartMaxSize);
2349 psFlashCSInfo->IsCDLessDeviceBootSig = ntohl(psFlashCSInfo->IsCDLessDeviceBootSig);
2350 psFlashCSInfo->MassStorageTimeout = ntohl(psFlashCSInfo->MassStorageTimeout);
2351
2352 return STATUS_SUCCESS;
2353 }
2354
2355 static int IsSectionExistInVendorInfo(struct bcm_mini_adapter *Adapter, enum bcm_flash2x_section_val section)
2356 {
2357 return (Adapter->uiVendorExtnFlag &&
2358 (Adapter->psFlash2xVendorInfo->VendorSection[section].AccessFlags & FLASH2X_SECTION_PRESENT) &&
2359 (Adapter->psFlash2xVendorInfo->VendorSection[section].OffsetFromZeroForSectionStart != UNINIT_PTR_IN_CS));
2360 }
2361
2362 static VOID UpdateVendorInfo(struct bcm_mini_adapter *Adapter)
2363 {
2364 B_UINT32 i = 0;
2365 unsigned int uiSizeSection = 0;
2366
2367 Adapter->uiVendorExtnFlag = false;
2368
2369 for (i = 0; i < TOTAL_SECTIONS; i++)
2370 Adapter->psFlash2xVendorInfo->VendorSection[i].OffsetFromZeroForSectionStart = UNINIT_PTR_IN_CS;
2371
2372 if (STATUS_SUCCESS != vendorextnGetSectionInfo(Adapter, Adapter->psFlash2xVendorInfo))
2373 return;
2374
2375 i = 0;
2376 while (i < TOTAL_SECTIONS) {
2377 if (!(Adapter->psFlash2xVendorInfo->VendorSection[i].AccessFlags & FLASH2X_SECTION_PRESENT)) {
2378 i++;
2379 continue;
2380 }
2381
2382 Adapter->uiVendorExtnFlag = TRUE;
2383 uiSizeSection = (Adapter->psFlash2xVendorInfo->VendorSection[i].OffsetFromZeroForSectionEnd -
2384 Adapter->psFlash2xVendorInfo->VendorSection[i].OffsetFromZeroForSectionStart);
2385
2386 switch (i) {
2387 case DSD0:
2388 if ((uiSizeSection >= (Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader + sizeof(struct bcm_dsd_header))) &&
2389 (UNINIT_PTR_IN_CS != Adapter->psFlash2xVendorInfo->VendorSection[i].OffsetFromZeroForSectionStart))
2390 Adapter->psFlash2xCSInfo->OffsetFromZeroForDSDStart = Adapter->psFlash2xCSInfo->OffsetFromZeroForDSDEnd = VENDOR_PTR_IN_CS;
2391 else
2392 Adapter->psFlash2xCSInfo->OffsetFromZeroForDSDStart = Adapter->psFlash2xCSInfo->OffsetFromZeroForDSDEnd = UNINIT_PTR_IN_CS;
2393 break;
2394
2395 case DSD1:
2396 if ((uiSizeSection >= (Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader + sizeof(struct bcm_dsd_header))) &&
2397 (UNINIT_PTR_IN_CS != Adapter->psFlash2xVendorInfo->VendorSection[i].OffsetFromZeroForSectionStart))
2398 Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD1Start = Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD1End = VENDOR_PTR_IN_CS;
2399 else
2400 Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD1Start = Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD1End = UNINIT_PTR_IN_CS;
2401 break;
2402
2403 case DSD2:
2404 if ((uiSizeSection >= (Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader + sizeof(struct bcm_dsd_header))) &&
2405 (UNINIT_PTR_IN_CS != Adapter->psFlash2xVendorInfo->VendorSection[i].OffsetFromZeroForSectionStart))
2406 Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD2Start = Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD2End = VENDOR_PTR_IN_CS;
2407 else
2408 Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD2Start = Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD2End = UNINIT_PTR_IN_CS;
2409 break;
2410 case VSA0:
2411 if (UNINIT_PTR_IN_CS != Adapter->psFlash2xVendorInfo->VendorSection[i].OffsetFromZeroForSectionStart)
2412 Adapter->psFlash2xCSInfo->OffsetFromZeroForVSAStart = Adapter->psFlash2xCSInfo->OffsetFromZeroForVSAEnd = VENDOR_PTR_IN_CS;
2413 else
2414 Adapter->psFlash2xCSInfo->OffsetFromZeroForVSAStart = Adapter->psFlash2xCSInfo->OffsetFromZeroForVSAEnd = UNINIT_PTR_IN_CS;
2415 break;
2416
2417 case VSA1:
2418 if (UNINIT_PTR_IN_CS != Adapter->psFlash2xVendorInfo->VendorSection[i].OffsetFromZeroForSectionStart)
2419 Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA1Start = Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA1End = VENDOR_PTR_IN_CS;
2420 else
2421 Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA1Start = Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA1End = UNINIT_PTR_IN_CS;
2422 break;
2423 case VSA2:
2424 if (UNINIT_PTR_IN_CS != Adapter->psFlash2xVendorInfo->VendorSection[i].OffsetFromZeroForSectionStart)
2425 Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA2Start = Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA2End = VENDOR_PTR_IN_CS;
2426 else
2427 Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA2Start = Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA2End = UNINIT_PTR_IN_CS;
2428 break;
2429
2430 default:
2431 break;
2432 }
2433 i++;
2434 }
2435 }
2436
2437 /*
2438 * Procedure: BcmGetFlashCSInfo
2439 *
2440 * Description: Reads control structure and gets Cal section addresses.
2441 *
2442 * Arguments:
2443 * Adapter - ptr to Adapter object instance
2444 *
2445 * Returns:
2446 * <VOID>
2447 */
2448
2449 static int BcmGetFlashCSInfo(struct bcm_mini_adapter *Adapter)
2450 {
2451 /* struct bcm_flash_cs_info sFlashCsInfo = {0}; */
2452
2453 #if !defined(BCM_SHM_INTERFACE) || defined(FLASH_DIRECT_ACCESS)
2454 unsigned int value;
2455 #endif
2456
2457 unsigned int uiFlashLayoutMajorVersion;
2458 Adapter->uiFlashLayoutMinorVersion = 0;
2459 Adapter->uiFlashLayoutMajorVersion = 0;
2460 Adapter->ulFlashControlSectionStart = FLASH_CS_INFO_START_ADDR;
2461
2462 Adapter->uiFlashBaseAdd = 0;
2463 Adapter->ulFlashCalStart = 0;
2464 memset(Adapter->psFlashCSInfo, 0 , sizeof(struct bcm_flash_cs_info));
2465 memset(Adapter->psFlash2xCSInfo, 0 , sizeof(struct bcm_flash2x_cs_info));
2466
2467 if (!Adapter->bDDRInitDone) {
2468 value = FLASH_CONTIGIOUS_START_ADDR_BEFORE_INIT;
2469 wrmalt(Adapter, 0xAF00A080, &value, sizeof(value));
2470 }
2471
2472 /* Reading first 8 Bytes to get the Flash Layout
2473 * MagicNumber(4 bytes) +FlashLayoutMinorVersion(2 Bytes) +FlashLayoutMajorVersion(2 Bytes)
2474 */
2475 BeceemFlashBulkRead(Adapter, (PUINT)Adapter->psFlashCSInfo, Adapter->ulFlashControlSectionStart, 8);
2476
2477 Adapter->psFlashCSInfo->FlashLayoutVersion = ntohl(Adapter->psFlashCSInfo->FlashLayoutVersion);
2478 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Flash Layout Version :%X", (Adapter->psFlashCSInfo->FlashLayoutVersion));
2479 /* BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Flash Layout Minor Version :%d\n", ntohs(sFlashCsInfo.FlashLayoutMinorVersion)); */
2480 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Signature is :%x\n", ntohl(Adapter->psFlashCSInfo->MagicNumber));
2481
2482 if (FLASH_CONTROL_STRUCT_SIGNATURE == ntohl(Adapter->psFlashCSInfo->MagicNumber)) {
2483 uiFlashLayoutMajorVersion = MAJOR_VERSION((Adapter->psFlashCSInfo->FlashLayoutVersion));
2484 Adapter->uiFlashLayoutMinorVersion = MINOR_VERSION((Adapter->psFlashCSInfo->FlashLayoutVersion));
2485 } else {
2486 Adapter->uiFlashLayoutMinorVersion = 0;
2487 uiFlashLayoutMajorVersion = 0;
2488 }
2489
2490 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "FLASH LAYOUT MAJOR VERSION :%X", uiFlashLayoutMajorVersion);
2491
2492 if (uiFlashLayoutMajorVersion < FLASH_2X_MAJOR_NUMBER) {
2493 BeceemFlashBulkRead(Adapter, (PUINT)Adapter->psFlashCSInfo, Adapter->ulFlashControlSectionStart, sizeof(struct bcm_flash_cs_info));
2494 ConvertEndianOfCSStructure(Adapter->psFlashCSInfo);
2495 Adapter->ulFlashCalStart = (Adapter->psFlashCSInfo->OffsetFromZeroForCalibrationStart);
2496
2497 if (!((Adapter->uiFlashLayoutMajorVersion == 1) && (Adapter->uiFlashLayoutMinorVersion == 1)))
2498 Adapter->ulFlashControlSectionStart = Adapter->psFlashCSInfo->OffsetFromZeroForControlSectionStart;
2499
2500 if ((FLASH_CONTROL_STRUCT_SIGNATURE == (Adapter->psFlashCSInfo->MagicNumber)) &&
2501 (SCSI_FIRMWARE_MINOR_VERSION <= MINOR_VERSION(Adapter->psFlashCSInfo->SCSIFirmwareVersion)) &&
2502 (FLASH_SECTOR_SIZE_SIG == (Adapter->psFlashCSInfo->FlashSectorSizeSig)) &&
2503 (BYTE_WRITE_SUPPORT == (Adapter->psFlashCSInfo->FlashWriteSupportSize))) {
2504 Adapter->ulFlashWriteSize = (Adapter->psFlashCSInfo->FlashWriteSupportSize);
2505 Adapter->fpFlashWrite = flashByteWrite;
2506 Adapter->fpFlashWriteWithStatusCheck = flashByteWriteStatus;
2507 } else {
2508 Adapter->ulFlashWriteSize = MAX_RW_SIZE;
2509 Adapter->fpFlashWrite = flashWrite;
2510 Adapter->fpFlashWriteWithStatusCheck = flashWriteStatus;
2511 }
2512
2513 BcmGetFlashSectorSize(Adapter, (Adapter->psFlashCSInfo->FlashSectorSizeSig),
2514 (Adapter->psFlashCSInfo->FlashSectorSize));
2515 Adapter->uiFlashBaseAdd = Adapter->psFlashCSInfo->FlashBaseAddr & 0xFCFFFFFF;
2516 } else {
2517 if (BcmFlash2xBulkRead(Adapter, (PUINT)Adapter->psFlash2xCSInfo, NO_SECTION_VAL,
2518 Adapter->ulFlashControlSectionStart, sizeof(struct bcm_flash2x_cs_info))) {
2519 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Unable to read CS structure\n");
2520 return STATUS_FAILURE;
2521 }
2522
2523 ConvertEndianOf2XCSStructure(Adapter->psFlash2xCSInfo);
2524 BcmDumpFlash2XCSStructure(Adapter->psFlash2xCSInfo, Adapter);
2525 if ((FLASH_CONTROL_STRUCT_SIGNATURE == Adapter->psFlash2xCSInfo->MagicNumber) &&
2526 (SCSI_FIRMWARE_MINOR_VERSION <= MINOR_VERSION(Adapter->psFlash2xCSInfo->SCSIFirmwareVersion)) &&
2527 (FLASH_SECTOR_SIZE_SIG == Adapter->psFlash2xCSInfo->FlashSectorSizeSig) &&
2528 (BYTE_WRITE_SUPPORT == Adapter->psFlash2xCSInfo->FlashWriteSupportSize)) {
2529 Adapter->ulFlashWriteSize = Adapter->psFlash2xCSInfo->FlashWriteSupportSize;
2530 Adapter->fpFlashWrite = flashByteWrite;
2531 Adapter->fpFlashWriteWithStatusCheck = flashByteWriteStatus;
2532 } else {
2533 Adapter->ulFlashWriteSize = MAX_RW_SIZE;
2534 Adapter->fpFlashWrite = flashWrite;
2535 Adapter->fpFlashWriteWithStatusCheck = flashWriteStatus;
2536 }
2537
2538 BcmGetFlashSectorSize(Adapter, Adapter->psFlash2xCSInfo->FlashSectorSizeSig,
2539 Adapter->psFlash2xCSInfo->FlashSectorSize);
2540
2541 UpdateVendorInfo(Adapter);
2542
2543 BcmGetActiveDSD(Adapter);
2544 BcmGetActiveISO(Adapter);
2545 Adapter->uiFlashBaseAdd = Adapter->psFlash2xCSInfo->FlashBaseAddr & 0xFCFFFFFF;
2546 Adapter->ulFlashControlSectionStart = Adapter->psFlash2xCSInfo->OffsetFromZeroForControlSectionStart;
2547 }
2548 /*
2549 * Concerns: what if CS sector size does not match with this sector size ???
2550 * what is the indication of AccessBitMap in CS in flash 2.x ????
2551 */
2552 Adapter->ulFlashID = BcmReadFlashRDID(Adapter);
2553 Adapter->uiFlashLayoutMajorVersion = uiFlashLayoutMajorVersion;
2554
2555 return STATUS_SUCCESS;
2556 }
2557
2558 /*
2559 * Procedure: BcmGetNvmType
2560 *
2561 * Description: Finds the type of NVM used.
2562 *
2563 * Arguments:
2564 * Adapter - ptr to Adapter object instance
2565 *
2566 * Returns:
2567 * NVM_TYPE
2568 *
2569 */
2570
2571 static enum bcm_nvm_type BcmGetNvmType(struct bcm_mini_adapter *Adapter)
2572 {
2573 unsigned int uiData = 0;
2574
2575 BeceemEEPROMBulkRead(Adapter, &uiData, 0x0, 4);
2576 if (uiData == BECM)
2577 return NVM_EEPROM;
2578
2579 /*
2580 * Read control struct and get cal addresses before accessing the flash
2581 */
2582 BcmGetFlashCSInfo(Adapter);
2583
2584 BeceemFlashBulkRead(Adapter, &uiData, 0x0 + Adapter->ulFlashCalStart, 4);
2585 if (uiData == BECM)
2586 return NVM_FLASH;
2587
2588 /*
2589 * even if there is no valid signature on EEPROM/FLASH find out if they really exist.
2590 * if exist select it.
2591 */
2592 if (BcmGetEEPROMSize(Adapter))
2593 return NVM_EEPROM;
2594
2595 /* TBD for Flash. */
2596 return NVM_UNKNOWN;
2597 }
2598
2599 /*
2600 * BcmGetSectionValStartOffset - this will calculate the section's starting offset if section val is given
2601 * @Adapter : Drivers Private Data structure
2602 * @eFlashSectionVal : Flash secion value defined in enum bcm_flash2x_section_val
2603 *
2604 * Return value:-
2605 * On success it return the start offset of the provided section val
2606 * On Failure -returns STATUS_FAILURE
2607 */
2608
2609 int BcmGetSectionValStartOffset(struct bcm_mini_adapter *Adapter, enum bcm_flash2x_section_val eFlashSectionVal)
2610 {
2611 /*
2612 * Considering all the section for which end offset can be calculated or directly given
2613 * in CS Structure. if matching case does not exist, return STATUS_FAILURE indicating section
2614 * endoffset can't be calculated or given in CS Structure.
2615 */
2616
2617 int SectStartOffset = 0;
2618
2619 SectStartOffset = INVALID_OFFSET;
2620
2621 if (IsSectionExistInVendorInfo(Adapter, eFlashSectionVal))
2622 return Adapter->psFlash2xVendorInfo->VendorSection[eFlashSectionVal].OffsetFromZeroForSectionStart;
2623
2624 switch (eFlashSectionVal) {
2625 case ISO_IMAGE1:
2626 if ((Adapter->psFlash2xCSInfo->OffsetISOImage1Part1Start != UNINIT_PTR_IN_CS) &&
2627 (IsNonCDLessDevice(Adapter) == false))
2628 SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage1Part1Start);
2629 break;
2630 case ISO_IMAGE2:
2631 if ((Adapter->psFlash2xCSInfo->OffsetISOImage2Part1Start != UNINIT_PTR_IN_CS) &&
2632 (IsNonCDLessDevice(Adapter) == false))
2633 SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage2Part1Start);
2634 break;
2635 case DSD0:
2636 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSDStart != UNINIT_PTR_IN_CS)
2637 SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSDStart);
2638 break;
2639 case DSD1:
2640 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD1Start != UNINIT_PTR_IN_CS)
2641 SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD1Start);
2642 break;
2643 case DSD2:
2644 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD2Start != UNINIT_PTR_IN_CS)
2645 SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD2Start);
2646 break;
2647 case VSA0:
2648 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSAStart != UNINIT_PTR_IN_CS)
2649 SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSAStart);
2650 break;
2651 case VSA1:
2652 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA1Start != UNINIT_PTR_IN_CS)
2653 SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA1Start);
2654 break;
2655 case VSA2:
2656 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA2Start != UNINIT_PTR_IN_CS)
2657 SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA2Start);
2658 break;
2659 case SCSI:
2660 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForScsiFirmware != UNINIT_PTR_IN_CS)
2661 SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForScsiFirmware);
2662 break;
2663 case CONTROL_SECTION:
2664 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForControlSectionStart != UNINIT_PTR_IN_CS)
2665 SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForControlSectionStart);
2666 break;
2667 case ISO_IMAGE1_PART2:
2668 if (Adapter->psFlash2xCSInfo->OffsetISOImage1Part2Start != UNINIT_PTR_IN_CS)
2669 SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage1Part2Start);
2670 break;
2671 case ISO_IMAGE1_PART3:
2672 if (Adapter->psFlash2xCSInfo->OffsetISOImage1Part3Start != UNINIT_PTR_IN_CS)
2673 SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage1Part3Start);
2674 break;
2675 case ISO_IMAGE2_PART2:
2676 if (Adapter->psFlash2xCSInfo->OffsetISOImage2Part2Start != UNINIT_PTR_IN_CS)
2677 SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage2Part2Start);
2678 break;
2679 case ISO_IMAGE2_PART3:
2680 if (Adapter->psFlash2xCSInfo->OffsetISOImage2Part3Start != UNINIT_PTR_IN_CS)
2681 SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage2Part3Start);
2682 break;
2683 default:
2684 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Section Does not exist in Flash 2.x");
2685 SectStartOffset = INVALID_OFFSET;
2686 }
2687
2688 return SectStartOffset;
2689 }
2690
2691 /*
2692 * BcmGetSectionValEndOffset - this will calculate the section's Ending offset if section val is given
2693 * @Adapter : Drivers Private Data structure
2694 * @eFlashSectionVal : Flash secion value defined in enum bcm_flash2x_section_val
2695 *
2696 * Return value:-
2697 * On success it return the end offset of the provided section val
2698 * On Failure -returns STATUS_FAILURE
2699 */
2700
2701 int BcmGetSectionValEndOffset(struct bcm_mini_adapter *Adapter, enum bcm_flash2x_section_val eFlash2xSectionVal)
2702 {
2703 int SectEndOffset = 0;
2704
2705 SectEndOffset = INVALID_OFFSET;
2706 if (IsSectionExistInVendorInfo(Adapter, eFlash2xSectionVal))
2707 return Adapter->psFlash2xVendorInfo->VendorSection[eFlash2xSectionVal].OffsetFromZeroForSectionEnd;
2708
2709 switch (eFlash2xSectionVal) {
2710 case ISO_IMAGE1:
2711 if ((Adapter->psFlash2xCSInfo->OffsetISOImage1Part1End != UNINIT_PTR_IN_CS) &&
2712 (IsNonCDLessDevice(Adapter) == false))
2713 SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage1Part1End);
2714 break;
2715 case ISO_IMAGE2:
2716 if ((Adapter->psFlash2xCSInfo->OffsetISOImage2Part1End != UNINIT_PTR_IN_CS) &&
2717 (IsNonCDLessDevice(Adapter) == false))
2718 SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage2Part1End);
2719 break;
2720 case DSD0:
2721 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSDEnd != UNINIT_PTR_IN_CS)
2722 SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSDEnd);
2723 break;
2724 case DSD1:
2725 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD1End != UNINIT_PTR_IN_CS)
2726 SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD1End);
2727 break;
2728 case DSD2:
2729 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD2End != UNINIT_PTR_IN_CS)
2730 SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD2End);
2731 break;
2732 case VSA0:
2733 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSAEnd != UNINIT_PTR_IN_CS)
2734 SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSAEnd);
2735 break;
2736 case VSA1:
2737 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA1End != UNINIT_PTR_IN_CS)
2738 SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA1End);
2739 break;
2740 case VSA2:
2741 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA2End != UNINIT_PTR_IN_CS)
2742 SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA2End);
2743 break;
2744 case SCSI:
2745 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForScsiFirmware != UNINIT_PTR_IN_CS)
2746 SectEndOffset = ((Adapter->psFlash2xCSInfo->OffsetFromZeroForScsiFirmware) +
2747 (Adapter->psFlash2xCSInfo->SizeOfScsiFirmware));
2748 break;
2749 case CONTROL_SECTION:
2750 /* Not Clear So Putting failure. confirm and fix it. */
2751 SectEndOffset = STATUS_FAILURE;
2752 break;
2753 case ISO_IMAGE1_PART2:
2754 if (Adapter->psFlash2xCSInfo->OffsetISOImage1Part2End != UNINIT_PTR_IN_CS)
2755 SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage1Part2End);
2756 break;
2757 case ISO_IMAGE1_PART3:
2758 if (Adapter->psFlash2xCSInfo->OffsetISOImage1Part3End != UNINIT_PTR_IN_CS)
2759 SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage1Part3End);
2760 break;
2761 case ISO_IMAGE2_PART2:
2762 if (Adapter->psFlash2xCSInfo->OffsetISOImage2Part2End != UNINIT_PTR_IN_CS)
2763 SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage2Part2End);
2764 break;
2765 case ISO_IMAGE2_PART3:
2766 if (Adapter->psFlash2xCSInfo->OffsetISOImage2Part3End != UNINIT_PTR_IN_CS)
2767 SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage2Part3End);
2768 break;
2769 default:
2770 SectEndOffset = INVALID_OFFSET;
2771 }
2772
2773 return SectEndOffset;
2774 }
2775
2776 /*
2777 * BcmFlash2xBulkRead:- Read API for Flash Map 2.x .
2778 * @Adapter :Driver Private Data Structure
2779 * @pBuffer : Buffer where data has to be put after reading
2780 * @eFlashSectionVal :Flash Section Val defined in enum bcm_flash2x_section_val
2781 * @uiOffsetWithinSectionVal :- Offset with in provided section
2782 * @uiNumBytes : Number of Bytes for Read
2783 *
2784 * Return value:-
2785 * return true on success and STATUS_FAILURE on fail.
2786 */
2787
2788 int BcmFlash2xBulkRead(struct bcm_mini_adapter *Adapter,
2789 PUINT pBuffer,
2790 enum bcm_flash2x_section_val eFlash2xSectionVal,
2791 unsigned int uiOffsetWithinSectionVal,
2792 unsigned int uiNumBytes)
2793 {
2794 int Status = STATUS_SUCCESS;
2795 int SectionStartOffset = 0;
2796 unsigned int uiAbsoluteOffset = 0;
2797 unsigned int uiTemp = 0, value = 0;
2798
2799 if (!Adapter) {
2800 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Adapter structure is NULL");
2801 return -EINVAL;
2802 }
2803 if (Adapter->device_removed) {
2804 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Device has been removed");
2805 return -ENODEV;
2806 }
2807
2808 /* NO_SECTION_VAL means absolute offset is given. */
2809 if (eFlash2xSectionVal == NO_SECTION_VAL)
2810 SectionStartOffset = 0;
2811 else
2812 SectionStartOffset = BcmGetSectionValStartOffset(Adapter, eFlash2xSectionVal);
2813
2814 if (SectionStartOffset == STATUS_FAILURE) {
2815 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "This Section<%d> does not exist in Flash 2.x Map ", eFlash2xSectionVal);
2816 return -EINVAL;
2817 }
2818
2819 if (IsSectionExistInVendorInfo(Adapter, eFlash2xSectionVal))
2820 return vendorextnReadSection(Adapter, (PUCHAR)pBuffer, eFlash2xSectionVal, uiOffsetWithinSectionVal, uiNumBytes);
2821
2822 /* calculating the absolute offset from FLASH; */
2823 uiAbsoluteOffset = uiOffsetWithinSectionVal + SectionStartOffset;
2824 rdmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
2825 value = 0;
2826 wrmalt(Adapter, 0x0f000C80, &value, sizeof(value));
2827 Status = BeceemFlashBulkRead(Adapter, pBuffer, uiAbsoluteOffset, uiNumBytes);
2828 wrmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
2829 if (Status) {
2830 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Flash Read Failed with Status :%d", Status);
2831 return Status;
2832 }
2833
2834 return Status;
2835 }
2836
2837 /*
2838 * BcmFlash2xBulkWrite :-API for Writing on the Flash Map 2.x.
2839 * @Adapter :Driver Private Data Structure
2840 * @pBuffer : Buffer From where data has to taken for writing
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 Write
2844 *
2845 * Return value:-
2846 * return true on success and STATUS_FAILURE on fail.
2847 *
2848 */
2849
2850 int BcmFlash2xBulkWrite(struct bcm_mini_adapter *Adapter,
2851 PUINT pBuffer,
2852 enum bcm_flash2x_section_val eFlash2xSectVal,
2853 unsigned int uiOffset,
2854 unsigned int uiNumBytes,
2855 unsigned int bVerify)
2856 {
2857 int Status = STATUS_SUCCESS;
2858 unsigned int FlashSectValStartOffset = 0;
2859 unsigned int uiTemp = 0, value = 0;
2860
2861 if (!Adapter) {
2862 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Adapter structure is NULL");
2863 return -EINVAL;
2864 }
2865
2866 if (Adapter->device_removed) {
2867 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Device has been removed");
2868 return -ENODEV;
2869 }
2870
2871 /* NO_SECTION_VAL means absolute offset is given. */
2872 if (eFlash2xSectVal == NO_SECTION_VAL)
2873 FlashSectValStartOffset = 0;
2874 else
2875 FlashSectValStartOffset = BcmGetSectionValStartOffset(Adapter, eFlash2xSectVal);
2876
2877 if (FlashSectValStartOffset == STATUS_FAILURE) {
2878 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "This Section<%d> does not exist in Flash Map 2.x", eFlash2xSectVal);
2879 return -EINVAL;
2880 }
2881
2882 if (IsSectionExistInVendorInfo(Adapter, eFlash2xSectVal))
2883 return vendorextnWriteSection(Adapter, (PUCHAR)pBuffer, eFlash2xSectVal, uiOffset, uiNumBytes, bVerify);
2884
2885 /* calculating the absolute offset from FLASH; */
2886 uiOffset = uiOffset + FlashSectValStartOffset;
2887
2888 rdmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
2889 value = 0;
2890 wrmalt(Adapter, 0x0f000C80, &value, sizeof(value));
2891
2892 Status = BeceemFlashBulkWrite(Adapter, pBuffer, uiOffset, uiNumBytes, bVerify);
2893
2894 wrmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
2895 if (Status) {
2896 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Flash Write failed with Status :%d", Status);
2897 return Status;
2898 }
2899
2900 return Status;
2901 }
2902
2903 /*
2904 * BcmGetActiveDSD : Set the Active DSD in Adapter Structure which has to be dumped in DDR
2905 * @Adapter :-Drivers private Data Structure
2906 *
2907 * Return Value:-
2908 * Return STATUS_SUCESS if get success in setting the right DSD else negative error code
2909 *
2910 */
2911
2912 static int BcmGetActiveDSD(struct bcm_mini_adapter *Adapter)
2913 {
2914 enum bcm_flash2x_section_val uiHighestPriDSD = 0;
2915
2916 uiHighestPriDSD = getHighestPriDSD(Adapter);
2917 Adapter->eActiveDSD = uiHighestPriDSD;
2918
2919 if (DSD0 == uiHighestPriDSD)
2920 Adapter->ulFlashCalStart = Adapter->psFlash2xCSInfo->OffsetFromZeroForDSDStart;
2921 if (DSD1 == uiHighestPriDSD)
2922 Adapter->ulFlashCalStart = Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD1Start;
2923 if (DSD2 == uiHighestPriDSD)
2924 Adapter->ulFlashCalStart = Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD2Start;
2925 if (Adapter->eActiveDSD)
2926 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Active DSD :%d", Adapter->eActiveDSD);
2927 if (Adapter->eActiveDSD == 0) {
2928 /* if No DSD gets Active, Make Active the DSD with WR permission */
2929 if (IsSectionWritable(Adapter, DSD2)) {
2930 Adapter->eActiveDSD = DSD2;
2931 Adapter->ulFlashCalStart = Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD2Start;
2932 } else if (IsSectionWritable(Adapter, DSD1)) {
2933 Adapter->eActiveDSD = DSD1;
2934 Adapter->ulFlashCalStart = Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD1Start;
2935 } else if (IsSectionWritable(Adapter, DSD0)) {
2936 Adapter->eActiveDSD = DSD0;
2937 Adapter->ulFlashCalStart = Adapter->psFlash2xCSInfo->OffsetFromZeroForDSDStart;
2938 }
2939 }
2940
2941 return STATUS_SUCCESS;
2942 }
2943
2944 /*
2945 * BcmGetActiveISO :- Set the Active ISO in Adapter Data Structue
2946 * @Adapter : Driver private Data Structure
2947 *
2948 * Return Value:-
2949 * Sucsess:- STATUS_SUCESS
2950 * Failure- : negative erro code
2951 *
2952 */
2953
2954 static int BcmGetActiveISO(struct bcm_mini_adapter *Adapter)
2955 {
2956 int HighestPriISO = 0;
2957
2958 HighestPriISO = getHighestPriISO(Adapter);
2959
2960 Adapter->eActiveISO = HighestPriISO;
2961 if (Adapter->eActiveISO == ISO_IMAGE2)
2962 Adapter->uiActiveISOOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage2Part1Start);
2963 else if (Adapter->eActiveISO == ISO_IMAGE1)
2964 Adapter->uiActiveISOOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage1Part1Start);
2965
2966 if (Adapter->eActiveISO)
2967 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Active ISO :%x", Adapter->eActiveISO);
2968
2969 return STATUS_SUCCESS;
2970 }
2971
2972 /*
2973 * IsOffsetWritable :- it will tell the access permission of the sector having passed offset
2974 * @Adapter : Drivers Private Data Structure
2975 * @uiOffset : Offset provided in the Flash
2976 *
2977 * Return Value:-
2978 * Success:-TRUE , offset is writable
2979 * Failure:-false, offset is RO
2980 *
2981 */
2982
2983 B_UINT8 IsOffsetWritable(struct bcm_mini_adapter *Adapter, unsigned int uiOffset)
2984 {
2985 unsigned int uiSectorNum = 0;
2986 unsigned int uiWordOfSectorPermission = 0;
2987 unsigned int uiBitofSectorePermission = 0;
2988 B_UINT32 permissionBits = 0;
2989
2990 uiSectorNum = uiOffset/Adapter->uiSectorSize;
2991
2992 /* calculating the word having this Sector Access permission from SectorAccessBitMap Array */
2993 uiWordOfSectorPermission = Adapter->psFlash2xCSInfo->SectorAccessBitMap[uiSectorNum / 16];
2994
2995 /* calculating the bit index inside the word for this sector */
2996 uiBitofSectorePermission = 2 * (15 - uiSectorNum % 16);
2997
2998 /* Setting Access permission */
2999 permissionBits = uiWordOfSectorPermission & (0x3 << uiBitofSectorePermission);
3000 permissionBits = (permissionBits >> uiBitofSectorePermission) & 0x3;
3001 if (permissionBits == SECTOR_READWRITE_PERMISSION)
3002 return TRUE;
3003 else
3004 return false;
3005 }
3006
3007 static int BcmDumpFlash2xSectionBitMap(struct bcm_flash2x_bitmap *psFlash2xBitMap)
3008 {
3009 struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
3010
3011 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "***************Flash 2.x Section Bitmap***************");
3012 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "ISO_IMAGE1 :0X%x", psFlash2xBitMap->ISO_IMAGE1);
3013 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "ISO_IMAGE2 :0X%x", psFlash2xBitMap->ISO_IMAGE2);
3014 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "DSD0 :0X%x", psFlash2xBitMap->DSD0);
3015 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "DSD1 :0X%x", psFlash2xBitMap->DSD1);
3016 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "DSD2 :0X%x", psFlash2xBitMap->DSD2);
3017 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "VSA0 :0X%x", psFlash2xBitMap->VSA0);
3018 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "VSA1 :0X%x", psFlash2xBitMap->VSA1);
3019 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "VSA2 :0X%x", psFlash2xBitMap->VSA2);
3020 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "SCSI :0X%x", psFlash2xBitMap->SCSI);
3021 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "CONTROL_SECTION :0X%x", psFlash2xBitMap->CONTROL_SECTION);
3022
3023 return STATUS_SUCCESS;
3024 }
3025
3026 /*
3027 * BcmGetFlash2xSectionalBitMap :- It will provide the bit map of all the section present in Flash
3028 * 8bit has been assigned to every section.
3029 * bit[0] :Section present or not
3030 * bit[1] :section is valid or not
3031 * bit[2] : Secton is read only or has write permission too.
3032 * bit[3] : Active Section -
3033 * bit[7...4] = Reserved .
3034 *
3035 * @Adapter:-Driver private Data Structure
3036 *
3037 * Return value:-
3038 * Success:- STATUS_SUCESS
3039 * Failure:- negative error code
3040 */
3041
3042 int BcmGetFlash2xSectionalBitMap(struct bcm_mini_adapter *Adapter, struct bcm_flash2x_bitmap *psFlash2xBitMap)
3043 {
3044 struct bcm_flash2x_cs_info *psFlash2xCSInfo = Adapter->psFlash2xCSInfo;
3045 enum bcm_flash2x_section_val uiHighestPriDSD = 0;
3046 enum bcm_flash2x_section_val uiHighestPriISO = 0;
3047 bool SetActiveDSDDone = false;
3048 bool SetActiveISODone = false;
3049
3050 /* For 1.x map all the section except DSD0 will be shown as not present
3051 * This part will be used by calibration tool to detect the number of DSD present in Flash.
3052 */
3053 if (IsFlash2x(Adapter) == false) {
3054 psFlash2xBitMap->ISO_IMAGE2 = 0;
3055 psFlash2xBitMap->ISO_IMAGE1 = 0;
3056 psFlash2xBitMap->DSD0 = FLASH2X_SECTION_VALID | FLASH2X_SECTION_ACT | FLASH2X_SECTION_PRESENT; /* 0xF; 0000(Reseved)1(Active)0(RW)1(valid)1(present) */
3057 psFlash2xBitMap->DSD1 = 0;
3058 psFlash2xBitMap->DSD2 = 0;
3059 psFlash2xBitMap->VSA0 = 0;
3060 psFlash2xBitMap->VSA1 = 0;
3061 psFlash2xBitMap->VSA2 = 0;
3062 psFlash2xBitMap->CONTROL_SECTION = 0;
3063 psFlash2xBitMap->SCSI = 0;
3064 psFlash2xBitMap->Reserved0 = 0;
3065 psFlash2xBitMap->Reserved1 = 0;
3066 psFlash2xBitMap->Reserved2 = 0;
3067
3068 return STATUS_SUCCESS;
3069 }
3070
3071 uiHighestPriDSD = getHighestPriDSD(Adapter);
3072 uiHighestPriISO = getHighestPriISO(Adapter);
3073
3074 /*
3075 * IS0 IMAGE 2
3076 */
3077 if ((psFlash2xCSInfo->OffsetISOImage2Part1Start) != UNINIT_PTR_IN_CS) {
3078 /* Setting the 0th Bit representing the Section is present or not. */
3079 psFlash2xBitMap->ISO_IMAGE2 = psFlash2xBitMap->ISO_IMAGE2 | FLASH2X_SECTION_PRESENT;
3080
3081 if (ReadISOSignature(Adapter, ISO_IMAGE2) == ISO_IMAGE_MAGIC_NUMBER)
3082 psFlash2xBitMap->ISO_IMAGE2 |= FLASH2X_SECTION_VALID;
3083
3084 /* Calculation for extrating the Access permission */
3085 if (IsSectionWritable(Adapter, ISO_IMAGE2) == false)
3086 psFlash2xBitMap->ISO_IMAGE2 |= FLASH2X_SECTION_RO;
3087
3088 if (SetActiveISODone == false && uiHighestPriISO == ISO_IMAGE2) {
3089 psFlash2xBitMap->ISO_IMAGE2 |= FLASH2X_SECTION_ACT;
3090 SetActiveISODone = TRUE;
3091 }
3092 }
3093
3094 /*
3095 * IS0 IMAGE 1
3096 */
3097 if ((psFlash2xCSInfo->OffsetISOImage1Part1Start) != UNINIT_PTR_IN_CS) {
3098 /* Setting the 0th Bit representing the Section is present or not. */
3099 psFlash2xBitMap->ISO_IMAGE1 = psFlash2xBitMap->ISO_IMAGE1 | FLASH2X_SECTION_PRESENT;
3100
3101 if (ReadISOSignature(Adapter, ISO_IMAGE1) == ISO_IMAGE_MAGIC_NUMBER)
3102 psFlash2xBitMap->ISO_IMAGE1 |= FLASH2X_SECTION_VALID;
3103
3104 /* Calculation for extrating the Access permission */
3105 if (IsSectionWritable(Adapter, ISO_IMAGE1) == false)
3106 psFlash2xBitMap->ISO_IMAGE1 |= FLASH2X_SECTION_RO;
3107
3108 if (SetActiveISODone == false && uiHighestPriISO == ISO_IMAGE1) {
3109 psFlash2xBitMap->ISO_IMAGE1 |= FLASH2X_SECTION_ACT;
3110 SetActiveISODone = TRUE;
3111 }
3112 }
3113
3114 /*
3115 * DSD2
3116 */
3117 if ((psFlash2xCSInfo->OffsetFromZeroForDSD2Start) != UNINIT_PTR_IN_CS) {
3118 /* Setting the 0th Bit representing the Section is present or not. */
3119 psFlash2xBitMap->DSD2 = psFlash2xBitMap->DSD2 | FLASH2X_SECTION_PRESENT;
3120
3121 if (ReadDSDSignature(Adapter, DSD2) == DSD_IMAGE_MAGIC_NUMBER)
3122 psFlash2xBitMap->DSD2 |= FLASH2X_SECTION_VALID;
3123
3124 /* Calculation for extrating the Access permission */
3125 if (IsSectionWritable(Adapter, DSD2) == false) {
3126 psFlash2xBitMap->DSD2 |= FLASH2X_SECTION_RO;
3127 } else {
3128 /* Means section is writable */
3129 if ((SetActiveDSDDone == false) && (uiHighestPriDSD == DSD2)) {
3130 psFlash2xBitMap->DSD2 |= FLASH2X_SECTION_ACT;
3131 SetActiveDSDDone = TRUE;
3132 }
3133 }
3134 }
3135
3136 /*
3137 * DSD 1
3138 */
3139 if ((psFlash2xCSInfo->OffsetFromZeroForDSD1Start) != UNINIT_PTR_IN_CS) {
3140 /* Setting the 0th Bit representing the Section is present or not. */
3141 psFlash2xBitMap->DSD1 = psFlash2xBitMap->DSD1 | FLASH2X_SECTION_PRESENT;
3142
3143 if (ReadDSDSignature(Adapter, DSD1) == DSD_IMAGE_MAGIC_NUMBER)
3144 psFlash2xBitMap->DSD1 |= FLASH2X_SECTION_VALID;
3145
3146 /* Calculation for extrating the Access permission */
3147 if (IsSectionWritable(Adapter, DSD1) == false) {
3148 psFlash2xBitMap->DSD1 |= FLASH2X_SECTION_RO;
3149 } else {
3150 /* Means section is writable */
3151 if ((SetActiveDSDDone == false) && (uiHighestPriDSD == DSD1)) {
3152 psFlash2xBitMap->DSD1 |= FLASH2X_SECTION_ACT;
3153 SetActiveDSDDone = TRUE;
3154 }
3155 }
3156 }
3157
3158 /*
3159 * For DSD 0
3160 */
3161 if ((psFlash2xCSInfo->OffsetFromZeroForDSDStart) != UNINIT_PTR_IN_CS) {
3162 /* Setting the 0th Bit representing the Section is present or not. */
3163 psFlash2xBitMap->DSD0 = psFlash2xBitMap->DSD0 | FLASH2X_SECTION_PRESENT;
3164
3165 if (ReadDSDSignature(Adapter, DSD0) == DSD_IMAGE_MAGIC_NUMBER)
3166 psFlash2xBitMap->DSD0 |= FLASH2X_SECTION_VALID;
3167
3168 /* Setting Access permission */
3169 if (IsSectionWritable(Adapter, DSD0) == false) {
3170 psFlash2xBitMap->DSD0 |= FLASH2X_SECTION_RO;
3171 } else {
3172 /* Means section is writable */
3173 if ((SetActiveDSDDone == false) && (uiHighestPriDSD == DSD0)) {
3174 psFlash2xBitMap->DSD0 |= FLASH2X_SECTION_ACT;
3175 SetActiveDSDDone = TRUE;
3176 }
3177 }
3178 }
3179
3180 /*
3181 * VSA 0
3182 */
3183 if ((psFlash2xCSInfo->OffsetFromZeroForVSAStart) != UNINIT_PTR_IN_CS) {
3184 /* Setting the 0th Bit representing the Section is present or not. */
3185 psFlash2xBitMap->VSA0 = psFlash2xBitMap->VSA0 | FLASH2X_SECTION_PRESENT;
3186
3187 /* Setting the Access Bit. Map is not defined hece setting it always valid */
3188 psFlash2xBitMap->VSA0 |= FLASH2X_SECTION_VALID;
3189
3190 /* Calculation for extrating the Access permission */
3191 if (IsSectionWritable(Adapter, VSA0) == false)
3192 psFlash2xBitMap->VSA0 |= FLASH2X_SECTION_RO;
3193
3194 /* By Default section is Active */
3195 psFlash2xBitMap->VSA0 |= FLASH2X_SECTION_ACT;
3196 }
3197
3198 /*
3199 * VSA 1
3200 */
3201 if ((psFlash2xCSInfo->OffsetFromZeroForVSA1Start) != UNINIT_PTR_IN_CS) {
3202 /* Setting the 0th Bit representing the Section is present or not. */
3203 psFlash2xBitMap->VSA1 = psFlash2xBitMap->VSA1 | FLASH2X_SECTION_PRESENT;
3204
3205 /* Setting the Access Bit. Map is not defined hece setting it always valid */
3206 psFlash2xBitMap->VSA1 |= FLASH2X_SECTION_VALID;
3207
3208 /* Checking For Access permission */
3209 if (IsSectionWritable(Adapter, VSA1) == false)
3210 psFlash2xBitMap->VSA1 |= FLASH2X_SECTION_RO;
3211
3212 /* By Default section is Active */
3213 psFlash2xBitMap->VSA1 |= FLASH2X_SECTION_ACT;
3214 }
3215
3216 /*
3217 * VSA 2
3218 */
3219 if ((psFlash2xCSInfo->OffsetFromZeroForVSA2Start) != UNINIT_PTR_IN_CS) {
3220 /* Setting the 0th Bit representing the Section is present or not. */
3221 psFlash2xBitMap->VSA2 = psFlash2xBitMap->VSA2 | FLASH2X_SECTION_PRESENT;
3222
3223 /* Setting the Access Bit. Map is not defined hece setting it always valid */
3224 psFlash2xBitMap->VSA2 |= FLASH2X_SECTION_VALID;
3225
3226 /* Checking For Access permission */
3227 if (IsSectionWritable(Adapter, VSA2) == false)
3228 psFlash2xBitMap->VSA2 |= FLASH2X_SECTION_RO;
3229
3230 /* By Default section is Active */
3231 psFlash2xBitMap->VSA2 |= FLASH2X_SECTION_ACT;
3232 }
3233
3234 /*
3235 * SCSI Section
3236 */
3237 if ((psFlash2xCSInfo->OffsetFromZeroForScsiFirmware) != UNINIT_PTR_IN_CS) {
3238 /* Setting the 0th Bit representing the Section is present or not. */
3239 psFlash2xBitMap->SCSI = psFlash2xBitMap->SCSI | FLASH2X_SECTION_PRESENT;
3240
3241 /* Setting the Access Bit. Map is not defined hece setting it always valid */
3242 psFlash2xBitMap->SCSI |= FLASH2X_SECTION_VALID;
3243
3244 /* Checking For Access permission */
3245 if (IsSectionWritable(Adapter, SCSI) == false)
3246 psFlash2xBitMap->SCSI |= FLASH2X_SECTION_RO;
3247
3248 /* By Default section is Active */
3249 psFlash2xBitMap->SCSI |= FLASH2X_SECTION_ACT;
3250 }
3251
3252 /*
3253 * Control Section
3254 */
3255 if ((psFlash2xCSInfo->OffsetFromZeroForControlSectionStart) != UNINIT_PTR_IN_CS) {
3256 /* Setting the 0th Bit representing the Section is present or not. */
3257 psFlash2xBitMap->CONTROL_SECTION = psFlash2xBitMap->CONTROL_SECTION | (FLASH2X_SECTION_PRESENT);
3258
3259 /* Setting the Access Bit. Map is not defined hece setting it always valid */
3260 psFlash2xBitMap->CONTROL_SECTION |= FLASH2X_SECTION_VALID;
3261
3262 /* Checking For Access permission */
3263 if (IsSectionWritable(Adapter, CONTROL_SECTION) == false)
3264 psFlash2xBitMap->CONTROL_SECTION |= FLASH2X_SECTION_RO;
3265
3266 /* By Default section is Active */
3267 psFlash2xBitMap->CONTROL_SECTION |= FLASH2X_SECTION_ACT;
3268 }
3269
3270 /*
3271 * For Reserved Sections
3272 */
3273 psFlash2xBitMap->Reserved0 = 0;
3274 psFlash2xBitMap->Reserved0 = 0;
3275 psFlash2xBitMap->Reserved0 = 0;
3276 BcmDumpFlash2xSectionBitMap(psFlash2xBitMap);
3277
3278 return STATUS_SUCCESS;
3279 }
3280
3281 /*
3282 * BcmSetActiveSection :- Set Active section is used to make priority field highest over other
3283 * section of same type.
3284 *
3285 * @Adapater :- Bcm Driver Private Data Structure
3286 * @eFlash2xSectionVal :- Flash section val whose priority has to be made highest.
3287 *
3288 * Return Value:- Make the priorit highest else return erorr code
3289 *
3290 */
3291
3292 int BcmSetActiveSection(struct bcm_mini_adapter *Adapter, enum bcm_flash2x_section_val eFlash2xSectVal)
3293 {
3294 unsigned int SectImagePriority = 0;
3295 int Status = STATUS_SUCCESS;
3296
3297 /* struct bcm_dsd_header sDSD = {0};
3298 * struct bcm_iso_header sISO = {0};
3299 */
3300 int HighestPriDSD = 0;
3301 int HighestPriISO = 0;
3302
3303 Status = IsSectionWritable(Adapter, eFlash2xSectVal);
3304 if (Status != TRUE) {
3305 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Provided Section <%d> is not writable", eFlash2xSectVal);
3306 return STATUS_FAILURE;
3307 }
3308
3309 Adapter->bHeaderChangeAllowed = TRUE;
3310 switch (eFlash2xSectVal) {
3311 case ISO_IMAGE1:
3312 case ISO_IMAGE2:
3313 if (ReadISOSignature(Adapter, eFlash2xSectVal) == ISO_IMAGE_MAGIC_NUMBER) {
3314 HighestPriISO = getHighestPriISO(Adapter);
3315
3316 if (HighestPriISO == eFlash2xSectVal) {
3317 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Given ISO<%x> already has highest priority", eFlash2xSectVal);
3318 Status = STATUS_SUCCESS;
3319 break;
3320 }
3321
3322 SectImagePriority = ReadISOPriority(Adapter, HighestPriISO) + 1;
3323
3324 if ((SectImagePriority <= 0) && IsSectionWritable(Adapter, HighestPriISO)) {
3325 /* This is a SPECIAL Case which will only happen if the current highest priority ISO has priority value = 0x7FFFFFFF.
3326 * We will write 1 to the current Highest priority ISO And then shall increase the priority of the requested ISO
3327 * by user
3328 */
3329 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "SectImagePriority wraparound happened, eFlash2xSectVal: 0x%x\n", eFlash2xSectVal);
3330 SectImagePriority = htonl(0x1);
3331 Status = BcmFlash2xBulkWrite(Adapter,
3332 &SectImagePriority,
3333 HighestPriISO,
3334 0 + FIELD_OFFSET_IN_HEADER(struct bcm_iso_header *, ISOImagePriority),
3335 SIGNATURE_SIZE,
3336 TRUE);
3337 if (Status) {
3338 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Priority has not been written properly");
3339 Status = STATUS_FAILURE;
3340 break;
3341 }
3342
3343 HighestPriISO = getHighestPriISO(Adapter);
3344
3345 if (HighestPriISO == eFlash2xSectVal) {
3346 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Given ISO<%x> already has highest priority", eFlash2xSectVal);
3347 Status = STATUS_SUCCESS;
3348 break;
3349 }
3350
3351 SectImagePriority = 2;
3352 }
3353
3354 SectImagePriority = htonl(SectImagePriority);
3355
3356 Status = BcmFlash2xBulkWrite(Adapter,
3357 &SectImagePriority,
3358 eFlash2xSectVal,
3359 0 + FIELD_OFFSET_IN_HEADER(struct bcm_iso_header *, ISOImagePriority),
3360 SIGNATURE_SIZE,
3361 TRUE);
3362 if (Status) {
3363 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Priority has not been written properly");
3364 break;
3365 }
3366 } else {
3367 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Signature is currupted. Hence can't increase the priority");
3368 Status = STATUS_FAILURE;
3369 break;
3370 }
3371 break;
3372 case DSD0:
3373 case DSD1:
3374 case DSD2:
3375 if (ReadDSDSignature(Adapter, eFlash2xSectVal) == DSD_IMAGE_MAGIC_NUMBER) {
3376 HighestPriDSD = getHighestPriDSD(Adapter);
3377 if ((HighestPriDSD == eFlash2xSectVal)) {
3378 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Given DSD<%x> already has highest priority", eFlash2xSectVal);
3379 Status = STATUS_SUCCESS;
3380 break;
3381 }
3382
3383 SectImagePriority = ReadDSDPriority(Adapter, HighestPriDSD) + 1;
3384 if (SectImagePriority <= 0) {
3385 /* This is a SPECIAL Case which will only happen if the current highest priority DSD has priority value = 0x7FFFFFFF.
3386 * We will write 1 to the current Highest priority DSD And then shall increase the priority of the requested DSD
3387 * by user
3388 */
3389 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, NVM_RW, DBG_LVL_ALL, "SectImagePriority wraparound happened, eFlash2xSectVal: 0x%x\n", eFlash2xSectVal);
3390 SectImagePriority = htonl(0x1);
3391
3392 Status = BcmFlash2xBulkWrite(Adapter,
3393 &SectImagePriority,
3394 HighestPriDSD,
3395 Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader + FIELD_OFFSET_IN_HEADER(struct bcm_dsd_header *, DSDImagePriority),
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 break;
3401 }
3402
3403 HighestPriDSD = getHighestPriDSD(Adapter);
3404
3405 if ((HighestPriDSD == eFlash2xSectVal)) {
3406 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Made the DSD: %x highest by reducing priority of other\n", eFlash2xSectVal);
3407 Status = STATUS_SUCCESS;
3408 break;
3409 }
3410
3411 SectImagePriority = htonl(0x2);
3412 Status = BcmFlash2xBulkWrite(Adapter,
3413 &SectImagePriority,
3414 HighestPriDSD,
3415 Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader + FIELD_OFFSET_IN_HEADER(struct bcm_dsd_header *, DSDImagePriority),
3416 SIGNATURE_SIZE,
3417 TRUE);
3418 if (Status) {
3419 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Priority has not been written properly");
3420 break;
3421 }
3422
3423 HighestPriDSD = getHighestPriDSD(Adapter);
3424 if ((HighestPriDSD == eFlash2xSectVal)) {
3425 Status = STATUS_SUCCESS;
3426 break;
3427 }
3428
3429 SectImagePriority = 3;
3430 }
3431 SectImagePriority = htonl(SectImagePriority);
3432 Status = BcmFlash2xBulkWrite(Adapter,
3433 &SectImagePriority,
3434 eFlash2xSectVal,
3435 Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader + FIELD_OFFSET_IN_HEADER(struct bcm_dsd_header *, DSDImagePriority),
3436 SIGNATURE_SIZE,
3437 TRUE);
3438 if (Status) {
3439 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Priority has not been written properly");
3440 Status = STATUS_FAILURE;
3441 break;
3442 }
3443 } else {
3444 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Signature is currupted. Hence can't increase the priority");
3445 Status = STATUS_FAILURE;
3446 break;
3447 }
3448 break;
3449 case VSA0:
3450 case VSA1:
3451 case VSA2:
3452 /* Has to be decided */
3453 break;
3454 default:
3455 Status = STATUS_FAILURE;
3456 break;
3457 }
3458
3459 Adapter->bHeaderChangeAllowed = false;
3460 return Status;
3461 }
3462
3463 /*
3464 * BcmCopyISO - Used only for copying the ISO section
3465 * @Adapater :- Bcm Driver Private Data Structure
3466 * @sCopySectStrut :- Section copy structure
3467 *
3468 * Return value:- SUCCESS if copies successfully else negative error code
3469 *
3470 */
3471
3472 int BcmCopyISO(struct bcm_mini_adapter *Adapter, struct bcm_flash2x_copy_section sCopySectStrut)
3473 {
3474 PCHAR Buff = NULL;
3475 enum bcm_flash2x_section_val eISOReadPart = 0, eISOWritePart = 0;
3476 unsigned int uiReadOffsetWithinPart = 0, uiWriteOffsetWithinPart = 0;
3477 unsigned int uiTotalDataToCopy = 0;
3478 bool IsThisHeaderSector = false;
3479 unsigned int sigOffset = 0;
3480 unsigned int ISOLength = 0;
3481 unsigned int Status = STATUS_SUCCESS;
3482 unsigned int SigBuff[MAX_RW_SIZE];
3483 unsigned int i = 0;
3484
3485 if (ReadISOSignature(Adapter, sCopySectStrut.SrcSection) != ISO_IMAGE_MAGIC_NUMBER) {
3486 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "error as Source ISO Section does not have valid signature");
3487 return STATUS_FAILURE;
3488 }
3489
3490 Status = BcmFlash2xBulkRead(Adapter,
3491 &ISOLength,
3492 sCopySectStrut.SrcSection,
3493 0 + FIELD_OFFSET_IN_HEADER(struct bcm_iso_header *, ISOImageSize),
3494 4);
3495 if (Status) {
3496 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Read failed while copying ISO\n");
3497 return Status;
3498 }
3499
3500 ISOLength = htonl(ISOLength);
3501 if (ISOLength % Adapter->uiSectorSize)
3502 ISOLength = Adapter->uiSectorSize * (1 + ISOLength/Adapter->uiSectorSize);
3503
3504 sigOffset = FIELD_OFFSET_IN_HEADER(struct bcm_iso_header *, ISOImageMagicNumber);
3505
3506 Buff = kzalloc(Adapter->uiSectorSize, GFP_KERNEL);
3507
3508 if (!Buff) {
3509 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Memory allocation failed for section size");
3510 return -ENOMEM;
3511 }
3512
3513 if (sCopySectStrut.SrcSection == ISO_IMAGE1 && sCopySectStrut.DstSection == ISO_IMAGE2) {
3514 eISOReadPart = ISO_IMAGE1;
3515 eISOWritePart = ISO_IMAGE2;
3516 uiReadOffsetWithinPart = 0;
3517 uiWriteOffsetWithinPart = 0;
3518
3519 uiTotalDataToCopy = (Adapter->psFlash2xCSInfo->OffsetISOImage1Part1End) -
3520 (Adapter->psFlash2xCSInfo->OffsetISOImage1Part1Start) +
3521 (Adapter->psFlash2xCSInfo->OffsetISOImage1Part2End) -
3522 (Adapter->psFlash2xCSInfo->OffsetISOImage1Part2Start) +
3523 (Adapter->psFlash2xCSInfo->OffsetISOImage1Part3End) -
3524 (Adapter->psFlash2xCSInfo->OffsetISOImage1Part3Start);
3525
3526 if (uiTotalDataToCopy < ISOLength) {
3527 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "error as Source ISO Section does not have valid signature");
3528 Status = STATUS_FAILURE;
3529 goto out;
3530 }
3531
3532 uiTotalDataToCopy = (Adapter->psFlash2xCSInfo->OffsetISOImage2Part1End) -
3533 (Adapter->psFlash2xCSInfo->OffsetISOImage2Part1Start) +
3534 (Adapter->psFlash2xCSInfo->OffsetISOImage2Part2End) -
3535 (Adapter->psFlash2xCSInfo->OffsetISOImage2Part2Start) +
3536 (Adapter->psFlash2xCSInfo->OffsetISOImage2Part3End) -
3537 (Adapter->psFlash2xCSInfo->OffsetISOImage2Part3Start);
3538
3539 if (uiTotalDataToCopy < ISOLength) {
3540 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "error as Dest ISO Section does not have enough section size");
3541 Status = STATUS_FAILURE;
3542 goto out;
3543 }
3544
3545 uiTotalDataToCopy = ISOLength;
3546
3547 CorruptISOSig(Adapter, ISO_IMAGE2);
3548 while (uiTotalDataToCopy) {
3549 if (uiTotalDataToCopy == Adapter->uiSectorSize) {
3550 /* Setting for write of first sector. First sector is assumed to be written in last */
3551 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Writing the signature sector");
3552 eISOReadPart = ISO_IMAGE1;
3553 uiReadOffsetWithinPart = 0;
3554 eISOWritePart = ISO_IMAGE2;
3555 uiWriteOffsetWithinPart = 0;
3556 IsThisHeaderSector = TRUE;
3557 } else {
3558 uiReadOffsetWithinPart = uiReadOffsetWithinPart + Adapter->uiSectorSize;
3559 uiWriteOffsetWithinPart = uiWriteOffsetWithinPart + Adapter->uiSectorSize;
3560
3561 if ((eISOReadPart == ISO_IMAGE1) && (uiReadOffsetWithinPart == (Adapter->psFlash2xCSInfo->OffsetISOImage1Part1End - Adapter->psFlash2xCSInfo->OffsetISOImage1Part1Start))) {
3562 eISOReadPart = ISO_IMAGE1_PART2;
3563 uiReadOffsetWithinPart = 0;
3564 }
3565
3566 if ((eISOReadPart == ISO_IMAGE1_PART2) && (uiReadOffsetWithinPart == (Adapter->psFlash2xCSInfo->OffsetISOImage1Part2End - Adapter->psFlash2xCSInfo->OffsetISOImage1Part2Start))) {
3567 eISOReadPart = ISO_IMAGE1_PART3;
3568 uiReadOffsetWithinPart = 0;
3569 }
3570
3571 if ((eISOWritePart == ISO_IMAGE2) && (uiWriteOffsetWithinPart == (Adapter->psFlash2xCSInfo->OffsetISOImage2Part1End - Adapter->psFlash2xCSInfo->OffsetISOImage2Part1Start))) {
3572 eISOWritePart = ISO_IMAGE2_PART2;
3573 uiWriteOffsetWithinPart = 0;
3574 }
3575
3576 if ((eISOWritePart == ISO_IMAGE2_PART2) && (uiWriteOffsetWithinPart == (Adapter->psFlash2xCSInfo->OffsetISOImage2Part2End - Adapter->psFlash2xCSInfo->OffsetISOImage2Part2Start))) {
3577 eISOWritePart = ISO_IMAGE2_PART3;
3578 uiWriteOffsetWithinPart = 0;
3579 }
3580 }
3581
3582 Status = BcmFlash2xBulkRead(Adapter,
3583 (PUINT)Buff,
3584 eISOReadPart,
3585 uiReadOffsetWithinPart,
3586 Adapter->uiSectorSize);
3587 if (Status) {
3588 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Read failed while copying ISO: Part: %x, OffsetWithinPart: %x\n", eISOReadPart, uiReadOffsetWithinPart);
3589 break;
3590 }
3591
3592 if (IsThisHeaderSector == TRUE) {
3593 /* If this is header sector write 0xFFFFFFFF at the sig time and in last write sig */
3594 memcpy(SigBuff, Buff + sigOffset, MAX_RW_SIZE);
3595
3596 for (i = 0; i < MAX_RW_SIZE; i++)
3597 *(Buff + sigOffset + i) = 0xFF;
3598 }
3599 Adapter->bHeaderChangeAllowed = TRUE;
3600 Status = BcmFlash2xBulkWrite(Adapter,
3601 (PUINT)Buff,
3602 eISOWritePart,
3603 uiWriteOffsetWithinPart,
3604 Adapter->uiSectorSize,
3605 TRUE);
3606 if (Status) {
3607 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Write failed while copying ISO: Part: %x, OffsetWithinPart: %x\n", eISOWritePart, uiWriteOffsetWithinPart);
3608 break;
3609 }
3610
3611 Adapter->bHeaderChangeAllowed = false;
3612 if (IsThisHeaderSector == TRUE) {
3613 WriteToFlashWithoutSectorErase(Adapter,
3614 SigBuff,
3615 eISOWritePart,
3616 sigOffset,
3617 MAX_RW_SIZE);
3618 IsThisHeaderSector = false;
3619 }
3620 /* subtracting the written Data */
3621 uiTotalDataToCopy = uiTotalDataToCopy - Adapter->uiSectorSize;
3622 }
3623 }
3624
3625 if (sCopySectStrut.SrcSection == ISO_IMAGE2 && sCopySectStrut.DstSection == ISO_IMAGE1) {
3626 eISOReadPart = ISO_IMAGE2;
3627 eISOWritePart = ISO_IMAGE1;
3628 uiReadOffsetWithinPart = 0;
3629 uiWriteOffsetWithinPart = 0;
3630
3631 uiTotalDataToCopy = (Adapter->psFlash2xCSInfo->OffsetISOImage2Part1End) -
3632 (Adapter->psFlash2xCSInfo->OffsetISOImage2Part1Start) +
3633 (Adapter->psFlash2xCSInfo->OffsetISOImage2Part2End) -
3634 (Adapter->psFlash2xCSInfo->OffsetISOImage2Part2Start) +
3635 (Adapter->psFlash2xCSInfo->OffsetISOImage2Part3End) -
3636 (Adapter->psFlash2xCSInfo->OffsetISOImage2Part3Start);
3637
3638 if (uiTotalDataToCopy < ISOLength) {
3639 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "error as Source ISO Section does not have valid signature");
3640 Status = STATUS_FAILURE;
3641 goto out;
3642 }
3643
3644 uiTotalDataToCopy = (Adapter->psFlash2xCSInfo->OffsetISOImage1Part1End) -
3645 (Adapter->psFlash2xCSInfo->OffsetISOImage1Part1Start) +
3646 (Adapter->psFlash2xCSInfo->OffsetISOImage1Part2End) -
3647 (Adapter->psFlash2xCSInfo->OffsetISOImage1Part2Start) +
3648 (Adapter->psFlash2xCSInfo->OffsetISOImage1Part3End) -
3649 (Adapter->psFlash2xCSInfo->OffsetISOImage1Part3Start);
3650
3651 if (uiTotalDataToCopy < ISOLength) {
3652 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "error as Dest ISO Section does not have enough section size");
3653 Status = STATUS_FAILURE;
3654 goto out;
3655 }
3656
3657 uiTotalDataToCopy = ISOLength;
3658
3659 CorruptISOSig(Adapter, ISO_IMAGE1);
3660
3661 while (uiTotalDataToCopy) {
3662 if (uiTotalDataToCopy == Adapter->uiSectorSize) {
3663 /* Setting for write of first sector. First sector is assumed to be written in last */
3664 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Writing the signature sector");
3665 eISOReadPart = ISO_IMAGE2;
3666 uiReadOffsetWithinPart = 0;
3667 eISOWritePart = ISO_IMAGE1;
3668 uiWriteOffsetWithinPart = 0;
3669 IsThisHeaderSector = TRUE;
3670 } else {
3671 uiReadOffsetWithinPart = uiReadOffsetWithinPart + Adapter->uiSectorSize;
3672 uiWriteOffsetWithinPart = uiWriteOffsetWithinPart + Adapter->uiSectorSize;
3673
3674 if ((eISOReadPart == ISO_IMAGE2) && (uiReadOffsetWithinPart == (Adapter->psFlash2xCSInfo->OffsetISOImage2Part1End - Adapter->psFlash2xCSInfo->OffsetISOImage2Part1Start))) {
3675 eISOReadPart = ISO_IMAGE2_PART2;
3676 uiReadOffsetWithinPart = 0;
3677 }
3678
3679 if ((eISOReadPart == ISO_IMAGE2_PART2) && (uiReadOffsetWithinPart == (Adapter->psFlash2xCSInfo->OffsetISOImage2Part2End - Adapter->psFlash2xCSInfo->OffsetISOImage2Part2Start))) {
3680 eISOReadPart = ISO_IMAGE2_PART3;
3681 uiReadOffsetWithinPart = 0;
3682 }
3683
3684 if ((eISOWritePart == ISO_IMAGE1) && (uiWriteOffsetWithinPart == (Adapter->psFlash2xCSInfo->OffsetISOImage1Part1End - Adapter->psFlash2xCSInfo->OffsetISOImage1Part1Start))) {
3685 eISOWritePart = ISO_IMAGE1_PART2;
3686 uiWriteOffsetWithinPart = 0;
3687 }
3688
3689 if ((eISOWritePart == ISO_IMAGE1_PART2) && (uiWriteOffsetWithinPart == (Adapter->psFlash2xCSInfo->OffsetISOImage1Part2End - Adapter->psFlash2xCSInfo->OffsetISOImage1Part2Start))) {
3690 eISOWritePart = ISO_IMAGE1_PART3;
3691 uiWriteOffsetWithinPart = 0;
3692 }
3693 }
3694
3695 Status = BcmFlash2xBulkRead(Adapter,
3696 (PUINT)Buff,
3697 eISOReadPart,
3698 uiReadOffsetWithinPart,
3699 Adapter->uiSectorSize);
3700 if (Status) {
3701 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Read failed while copying ISO: Part: %x, OffsetWithinPart: %x\n", eISOReadPart, uiReadOffsetWithinPart);
3702 break;
3703 }
3704
3705 if (IsThisHeaderSector == TRUE) {
3706 /* If this is header sector write 0xFFFFFFFF at the sig time and in last write sig */
3707 memcpy(SigBuff, Buff + sigOffset, MAX_RW_SIZE);
3708
3709 for (i = 0; i < MAX_RW_SIZE; i++)
3710 *(Buff + sigOffset + i) = 0xFF;
3711 }
3712 Adapter->bHeaderChangeAllowed = TRUE;
3713 Status = BcmFlash2xBulkWrite(Adapter,
3714 (PUINT)Buff,
3715 eISOWritePart,
3716 uiWriteOffsetWithinPart,
3717 Adapter->uiSectorSize,
3718 TRUE);
3719 if (Status) {
3720 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Write failed while copying ISO: Part: %x, OffsetWithinPart: %x\n", eISOWritePart, uiWriteOffsetWithinPart);
3721 break;
3722 }
3723
3724 Adapter->bHeaderChangeAllowed = false;
3725 if (IsThisHeaderSector == TRUE) {
3726 WriteToFlashWithoutSectorErase(Adapter,
3727 SigBuff,
3728 eISOWritePart,
3729 sigOffset,
3730 MAX_RW_SIZE);
3731
3732 IsThisHeaderSector = false;
3733 }
3734
3735 /* subtracting the written Data */
3736 uiTotalDataToCopy = uiTotalDataToCopy - Adapter->uiSectorSize;
3737 }
3738 }
3739 out:
3740 kfree(Buff);
3741
3742 return Status;
3743 }
3744
3745 /*
3746 * BcmFlash2xCorruptSig : this API is used to corrupt the written sig in Bcm Header present in flash section.
3747 * It will corrupt the sig, if Section is writable, by making first bytes as zero.
3748 * @Adapater :- Bcm Driver Private Data Structure
3749 * @eFlash2xSectionVal :- Flash section val which has header
3750 *
3751 * Return Value :-
3752 * Success :- If Section is present and writable, corrupt the sig and return STATUS_SUCCESS
3753 * Failure :-Return negative error code
3754 */
3755
3756 int BcmFlash2xCorruptSig(struct bcm_mini_adapter *Adapter, enum bcm_flash2x_section_val eFlash2xSectionVal)
3757 {
3758 int Status = STATUS_SUCCESS;
3759
3760 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Section Value :%x\n", eFlash2xSectionVal);
3761
3762 if ((eFlash2xSectionVal == DSD0) || (eFlash2xSectionVal == DSD1) || (eFlash2xSectionVal == DSD2)) {
3763 Status = CorruptDSDSig(Adapter, eFlash2xSectionVal);
3764 } else if (eFlash2xSectionVal == ISO_IMAGE1 || eFlash2xSectionVal == ISO_IMAGE2) {
3765 Status = CorruptISOSig(Adapter, eFlash2xSectionVal);
3766 } else {
3767 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Given Section <%d>does not have Header", eFlash2xSectionVal);
3768 return STATUS_SUCCESS;
3769 }
3770 return Status;
3771 }
3772
3773 /*
3774 *BcmFlash2xWriteSig :-this API is used to Write the sig if requested Section has
3775 * header and Write Permission.
3776 * @Adapater :- Bcm Driver Private Data Structure
3777 * @eFlashSectionVal :- Flash section val which has header
3778 *
3779 * Return Value :-
3780 * Success :- If Section is present and writable write the sig and return STATUS_SUCCESS
3781 * Failure :-Return negative error code
3782 */
3783
3784 int BcmFlash2xWriteSig(struct bcm_mini_adapter *Adapter, enum bcm_flash2x_section_val eFlashSectionVal)
3785 {
3786 unsigned int uiSignature = 0;
3787 unsigned int uiOffset = 0;
3788
3789 /* struct bcm_dsd_header dsdHeader = {0}; */
3790 if (Adapter->bSigCorrupted == false) {
3791 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Signature is not corrupted by driver, hence not restoring\n");
3792 return STATUS_SUCCESS;
3793 }
3794
3795 if (Adapter->bAllDSDWriteAllow == false) {
3796 if (IsSectionWritable(Adapter, eFlashSectionVal) == false) {
3797 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Section is not Writable...Hence can't Write signature");
3798 return SECTOR_IS_NOT_WRITABLE;
3799 }
3800 }
3801
3802 if ((eFlashSectionVal == DSD0) || (eFlashSectionVal == DSD1) || (eFlashSectionVal == DSD2)) {
3803 uiSignature = htonl(DSD_IMAGE_MAGIC_NUMBER);
3804 uiOffset = Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader;
3805
3806 uiOffset += FIELD_OFFSET_IN_HEADER(struct bcm_dsd_header *, DSDImageMagicNumber);
3807
3808 if ((ReadDSDSignature(Adapter, eFlashSectionVal) & 0xFF000000) != CORRUPTED_PATTERN) {
3809 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Corrupted Pattern is not there. Hence won't write sig");
3810 return STATUS_FAILURE;
3811 }
3812 } else if ((eFlashSectionVal == ISO_IMAGE1) || (eFlashSectionVal == ISO_IMAGE2)) {
3813 uiSignature = htonl(ISO_IMAGE_MAGIC_NUMBER);
3814 /* uiOffset = 0; */
3815 uiOffset = FIELD_OFFSET_IN_HEADER(struct bcm_iso_header *, ISOImageMagicNumber);
3816 if ((ReadISOSignature(Adapter, eFlashSectionVal) & 0xFF000000) != CORRUPTED_PATTERN) {
3817 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Currupted Pattern is not there. Hence won't write sig");
3818 return STATUS_FAILURE;
3819 }
3820 } else {
3821 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "GIVEN SECTION< %d > IS NOT VALID FOR SIG WRITE...", eFlashSectionVal);
3822 return STATUS_FAILURE;
3823 }
3824
3825 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Restoring the signature");
3826
3827 Adapter->bHeaderChangeAllowed = TRUE;
3828 Adapter->bSigCorrupted = false;
3829 BcmFlash2xBulkWrite(Adapter, &uiSignature, eFlashSectionVal, uiOffset, SIGNATURE_SIZE, TRUE);
3830 Adapter->bHeaderChangeAllowed = false;
3831
3832 return STATUS_SUCCESS;
3833 }
3834
3835 /*
3836 * validateFlash2xReadWrite :- This API is used to validate the user request for Read/Write.
3837 * if requested Bytes goes beyond the Requested section, it reports error.
3838 * @Adapater :- Bcm Driver Private Data Structure
3839 * @psFlash2xReadWrite :-Flash2x Read/write structure pointer
3840 *
3841 * Return values:-Return TRUE is request is valid else false.
3842 */
3843
3844 int validateFlash2xReadWrite(struct bcm_mini_adapter *Adapter, struct bcm_flash2x_readwrite *psFlash2xReadWrite)
3845 {
3846 unsigned int uiNumOfBytes = 0;
3847 unsigned int uiSectStartOffset = 0;
3848 unsigned int uiSectEndOffset = 0;
3849
3850 uiNumOfBytes = psFlash2xReadWrite->numOfBytes;
3851
3852 if (IsSectionExistInFlash(Adapter, psFlash2xReadWrite->Section) != TRUE) {
3853 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Section<%x> does not exist in Flash", psFlash2xReadWrite->Section);
3854 return false;
3855 }
3856 uiSectStartOffset = BcmGetSectionValStartOffset(Adapter, psFlash2xReadWrite->Section);
3857 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Start offset :%x ,section :%d\n", uiSectStartOffset, psFlash2xReadWrite->Section);
3858 if ((psFlash2xReadWrite->Section == ISO_IMAGE1) || (psFlash2xReadWrite->Section == ISO_IMAGE2)) {
3859 if (psFlash2xReadWrite->Section == ISO_IMAGE1) {
3860 uiSectEndOffset = BcmGetSectionValEndOffset(Adapter, ISO_IMAGE1) -
3861 BcmGetSectionValStartOffset(Adapter, ISO_IMAGE1) +
3862 BcmGetSectionValEndOffset(Adapter, ISO_IMAGE1_PART2) -
3863 BcmGetSectionValStartOffset(Adapter, ISO_IMAGE1_PART2) +
3864 BcmGetSectionValEndOffset(Adapter, ISO_IMAGE1_PART3) -
3865 BcmGetSectionValStartOffset(Adapter, ISO_IMAGE1_PART3);
3866 } else if (psFlash2xReadWrite->Section == ISO_IMAGE2) {
3867 uiSectEndOffset = BcmGetSectionValEndOffset(Adapter, ISO_IMAGE2) -
3868 BcmGetSectionValStartOffset(Adapter, ISO_IMAGE2) +
3869 BcmGetSectionValEndOffset(Adapter, ISO_IMAGE2_PART2) -
3870 BcmGetSectionValStartOffset(Adapter, ISO_IMAGE2_PART2) +
3871 BcmGetSectionValEndOffset(Adapter, ISO_IMAGE2_PART3) -
3872 BcmGetSectionValStartOffset(Adapter, ISO_IMAGE2_PART3);
3873 }
3874
3875 /* since this uiSectEndoffset is the size of iso Image. hence for calculating the virtual endoffset
3876 * it should be added in startoffset. so that check done in last of this function can be valued.
3877 */
3878 uiSectEndOffset = uiSectStartOffset + uiSectEndOffset;
3879
3880 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Total size of the ISO Image :%x", uiSectEndOffset);
3881 } else
3882 uiSectEndOffset = BcmGetSectionValEndOffset(Adapter, psFlash2xReadWrite->Section);
3883
3884 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "End offset :%x\n", uiSectEndOffset);
3885
3886 /* psFlash2xReadWrite->offset and uiNumOfBytes are user controlled and can lead to integer overflows */
3887 if (psFlash2xReadWrite->offset > uiSectEndOffset) {
3888 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Invalid Request....");
3889 return false;
3890 }
3891 if (uiNumOfBytes > uiSectEndOffset) {
3892 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Invalid Request....");
3893 return false;
3894 }
3895 /* Checking the boundary condition */
3896 if ((uiSectStartOffset + psFlash2xReadWrite->offset + uiNumOfBytes) <= uiSectEndOffset)
3897 return TRUE;
3898 else {
3899 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Invalid Request....");
3900 return false;
3901 }
3902 }
3903
3904 /*
3905 * IsFlash2x :- check for Flash 2.x
3906 * Adapater :- Bcm Driver Private Data Structure
3907 *
3908 * Return value:-
3909 * return TRUE if flah2.x of hgher version else return false.
3910 */
3911
3912 int IsFlash2x(struct bcm_mini_adapter *Adapter)
3913 {
3914 if (Adapter->uiFlashLayoutMajorVersion >= FLASH_2X_MAJOR_NUMBER)
3915 return TRUE;
3916 else
3917 return false;
3918 }
3919
3920 /*
3921 * GetFlashBaseAddr :- Calculate the Flash Base address
3922 * @Adapater :- Bcm Driver Private Data Structure
3923 *
3924 * Return Value:-
3925 * Success :- Base Address of the Flash
3926 */
3927
3928 static int GetFlashBaseAddr(struct bcm_mini_adapter *Adapter)
3929 {
3930 unsigned int uiBaseAddr = 0;
3931
3932 if (Adapter->bDDRInitDone) {
3933 /*
3934 * For All Valid Flash Versions... except 1.1, take the value from FlashBaseAddr
3935 * In case of Raw Read... use the default value
3936 */
3937 if (Adapter->uiFlashLayoutMajorVersion && (Adapter->bFlashRawRead == false) &&
3938 !((Adapter->uiFlashLayoutMajorVersion == 1) && (Adapter->uiFlashLayoutMinorVersion == 1)))
3939 uiBaseAddr = Adapter->uiFlashBaseAdd;
3940 else
3941 uiBaseAddr = FLASH_CONTIGIOUS_START_ADDR_AFTER_INIT;
3942 } else {
3943 /*
3944 * For All Valid Flash Versions... except 1.1, take the value from FlashBaseAddr
3945 * In case of Raw Read... use the default value
3946 */
3947 if (Adapter->uiFlashLayoutMajorVersion && (Adapter->bFlashRawRead == false) &&
3948 !((Adapter->uiFlashLayoutMajorVersion == 1) && (Adapter->uiFlashLayoutMinorVersion == 1)))
3949 uiBaseAddr = Adapter->uiFlashBaseAdd | FLASH_CONTIGIOUS_START_ADDR_BEFORE_INIT;
3950 else
3951 uiBaseAddr = FLASH_CONTIGIOUS_START_ADDR_BEFORE_INIT;
3952 }
3953
3954 return uiBaseAddr;
3955 }
3956
3957 /*
3958 * BcmCopySection :- This API is used to copy the One section in another. Both section should
3959 * be contiuous and of same size. Hence this Will not be applicabe to copy ISO.
3960 *
3961 * @Adapater :- Bcm Driver Private Data Structure
3962 * @SrcSection :- Source section From where data has to be copied
3963 * @DstSection :- Destination section to which data has to be copied
3964 * @offset :- Offset from/to where data has to be copied from one section to another.
3965 * @numOfBytes :- number of byes that has to be copyed from one section to another at given offset.
3966 * in case of numofBytes equal zero complete section will be copied.
3967 * Return Values-
3968 * Success : Return STATUS_SUCCESS
3969 * Faillure :- return negative error code
3970 */
3971
3972 int BcmCopySection(struct bcm_mini_adapter *Adapter,
3973 enum bcm_flash2x_section_val SrcSection,
3974 enum bcm_flash2x_section_val DstSection,
3975 unsigned int offset,
3976 unsigned int numOfBytes)
3977 {
3978 unsigned int BuffSize = 0;
3979 unsigned int BytesToBeCopied = 0;
3980 PUCHAR pBuff = NULL;
3981 int Status = STATUS_SUCCESS;
3982
3983 if (SrcSection == DstSection) {
3984 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Source and Destination should be different ...try again");
3985 return -EINVAL;
3986 }
3987
3988 if ((SrcSection != DSD0) && (SrcSection != DSD1) && (SrcSection != DSD2)) {
3989 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Source should be DSD subsection");
3990 return -EINVAL;
3991 }
3992
3993 if ((DstSection != DSD0) && (DstSection != DSD1) && (DstSection != DSD2)) {
3994 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Destination should be DSD subsection");
3995 return -EINVAL;
3996 }
3997
3998 /* if offset zero means have to copy complete secton */
3999 if (numOfBytes == 0) {
4000 numOfBytes = BcmGetSectionValEndOffset(Adapter, SrcSection)
4001 - BcmGetSectionValStartOffset(Adapter, SrcSection);
4002
4003 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Section Size :0x%x", numOfBytes);
4004 }
4005
4006 if ((offset + numOfBytes) > BcmGetSectionValEndOffset(Adapter, SrcSection)
4007 - BcmGetSectionValStartOffset(Adapter, SrcSection)) {
4008 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, " Input parameters going beyond the section offS: %x numB: %x of Source Section\n",
4009 offset, numOfBytes);
4010 return -EINVAL;
4011 }
4012
4013 if ((offset + numOfBytes) > BcmGetSectionValEndOffset(Adapter, DstSection)
4014 - BcmGetSectionValStartOffset(Adapter, DstSection)) {
4015 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Input parameters going beyond the section offS: %x numB: %x of Destination Section\n",
4016 offset, numOfBytes);
4017 return -EINVAL;
4018 }
4019
4020 if (numOfBytes > Adapter->uiSectorSize)
4021 BuffSize = Adapter->uiSectorSize;
4022 else
4023 BuffSize = numOfBytes;
4024
4025 pBuff = kzalloc(BuffSize, GFP_KERNEL);
4026 if (!pBuff) {
4027 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Memory allocation failed.. ");
4028 return -ENOMEM;
4029 }
4030
4031 BytesToBeCopied = Adapter->uiSectorSize;
4032 if (offset % Adapter->uiSectorSize)
4033 BytesToBeCopied = Adapter->uiSectorSize - (offset % Adapter->uiSectorSize);
4034 if (BytesToBeCopied > numOfBytes)
4035 BytesToBeCopied = numOfBytes;
4036
4037 Adapter->bHeaderChangeAllowed = TRUE;
4038
4039 do {
4040 Status = BcmFlash2xBulkRead(Adapter, (PUINT)pBuff, SrcSection , offset, BytesToBeCopied);
4041 if (Status) {
4042 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Read failed at offset :%d for NOB :%d", SrcSection, BytesToBeCopied);
4043 break;
4044 }
4045 Status = BcmFlash2xBulkWrite(Adapter, (PUINT)pBuff, DstSection, offset, BytesToBeCopied, false);
4046 if (Status) {
4047 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Write failed at offset :%d for NOB :%d", DstSection, BytesToBeCopied);
4048 break;
4049 }
4050 offset = offset + BytesToBeCopied;
4051 numOfBytes = numOfBytes - BytesToBeCopied;
4052 if (numOfBytes) {
4053 if (numOfBytes > Adapter->uiSectorSize)
4054 BytesToBeCopied = Adapter->uiSectorSize;
4055 else
4056 BytesToBeCopied = numOfBytes;
4057 }
4058 } while (numOfBytes > 0);
4059
4060 kfree(pBuff);
4061 Adapter->bHeaderChangeAllowed = false;
4062
4063 return Status;
4064 }
4065
4066 /*
4067 * SaveHeaderIfPresent :- This API is use to Protect the Header in case of Header Sector write
4068 * @Adapater :- Bcm Driver Private Data Structure
4069 * @pBuff :- Data buffer that has to be written in sector having the header map.
4070 * @uiOffset :- Flash offset that has to be written.
4071 *
4072 * Return value :-
4073 * Success :- On success return STATUS_SUCCESS
4074 * Faillure :- Return negative error code
4075 */
4076
4077 int SaveHeaderIfPresent(struct bcm_mini_adapter *Adapter, PUCHAR pBuff, unsigned int uiOffset)
4078 {
4079 unsigned int offsetToProtect = 0, HeaderSizeToProtect = 0;
4080 bool bHasHeader = false;
4081 PUCHAR pTempBuff = NULL;
4082 unsigned int uiSectAlignAddr = 0;
4083 unsigned int sig = 0;
4084
4085 /* making the offset sector aligned */
4086 uiSectAlignAddr = uiOffset & ~(Adapter->uiSectorSize - 1);
4087
4088 if ((uiSectAlignAddr == BcmGetSectionValEndOffset(Adapter, DSD2) - Adapter->uiSectorSize) ||
4089 (uiSectAlignAddr == BcmGetSectionValEndOffset(Adapter, DSD1) - Adapter->uiSectorSize) ||
4090 (uiSectAlignAddr == BcmGetSectionValEndOffset(Adapter, DSD0) - Adapter->uiSectorSize)) {
4091 /* offset from the sector boundary having the header map */
4092 offsetToProtect = Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader % Adapter->uiSectorSize;
4093 HeaderSizeToProtect = sizeof(struct bcm_dsd_header);
4094 bHasHeader = TRUE;
4095 }
4096
4097 if (uiSectAlignAddr == BcmGetSectionValStartOffset(Adapter, ISO_IMAGE1) ||
4098 uiSectAlignAddr == BcmGetSectionValStartOffset(Adapter, ISO_IMAGE2)) {
4099 offsetToProtect = 0;
4100 HeaderSizeToProtect = sizeof(struct bcm_iso_header);
4101 bHasHeader = TRUE;
4102 }
4103 /* If Header is present overwrite passed buffer with this */
4104 if (bHasHeader && (Adapter->bHeaderChangeAllowed == false)) {
4105 pTempBuff = kzalloc(HeaderSizeToProtect, GFP_KERNEL);
4106 if (!pTempBuff) {
4107 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Memory allocation failed");
4108 return -ENOMEM;
4109 }
4110 /* Read header */
4111 BeceemFlashBulkRead(Adapter, (PUINT)pTempBuff, (uiSectAlignAddr + offsetToProtect), HeaderSizeToProtect);
4112 BCM_DEBUG_PRINT_BUFFER(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, pTempBuff, HeaderSizeToProtect);
4113 /* Replace Buffer content with Header */
4114 memcpy(pBuff + offsetToProtect, pTempBuff, HeaderSizeToProtect);
4115
4116 kfree(pTempBuff);
4117 }
4118 if (bHasHeader && Adapter->bSigCorrupted) {
4119 sig = *((PUINT)(pBuff + offsetToProtect + FIELD_OFFSET_IN_HEADER(struct bcm_dsd_header *, DSDImageMagicNumber)));
4120 sig = ntohl(sig);
4121 if ((sig & 0xFF000000) != CORRUPTED_PATTERN) {
4122 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Desired pattern is not at sig offset. Hence won't restore");
4123 Adapter->bSigCorrupted = false;
4124 return STATUS_SUCCESS;
4125 }
4126 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, " Corrupted sig is :%X", sig);
4127 *((PUINT)(pBuff + offsetToProtect + FIELD_OFFSET_IN_HEADER(struct bcm_dsd_header *, DSDImageMagicNumber))) = htonl(DSD_IMAGE_MAGIC_NUMBER);
4128 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Restoring the signature in Header Write only");
4129 Adapter->bSigCorrupted = false;
4130 }
4131
4132 return STATUS_SUCCESS;
4133 }
4134
4135 /*
4136 * BcmDoChipSelect : This will selcet the appropriate chip for writing.
4137 * @Adapater :- Bcm Driver Private Data Structure
4138 *
4139 * OutPut:-
4140 * Select the Appropriate chip and retrn status Success
4141 */
4142 static int BcmDoChipSelect(struct bcm_mini_adapter *Adapter, unsigned int offset)
4143 {
4144 unsigned int FlashConfig = 0;
4145 int ChipNum = 0;
4146 unsigned int GPIOConfig = 0;
4147 unsigned int PartNum = 0;
4148
4149 ChipNum = offset / FLASH_PART_SIZE;
4150
4151 /*
4152 * Chip Select mapping to enable flash0.
4153 * To select flash 0, we have to OR with (0<<12).
4154 * ORing 0 will have no impact so not doing that part.
4155 * In future if Chip select value changes from 0 to non zero,
4156 * That needs be taken care with backward comaptibility. No worries for now.
4157 */
4158
4159 /*
4160 * SelectedChip Variable is the selection that the host is 100% Sure the same as what the register will hold. This can be ONLY ensured
4161 * if the Chip doesn't goes to low power mode while the flash operation is in progress (NVMRdmWrmLock is taken)
4162 * Before every new Flash Write operation, we reset the variable. This is to ensure that after any wake-up from
4163 * power down modes (Idle mode/shutdown mode), the values in the register will be different.
4164 */
4165
4166 if (Adapter->SelectedChip == ChipNum)
4167 return STATUS_SUCCESS;
4168
4169 /* BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Selected Chip :%x", ChipNum); */
4170 Adapter->SelectedChip = ChipNum;
4171
4172 /* bit[13..12] will select the appropriate chip */
4173 rdmalt(Adapter, FLASH_CONFIG_REG, &FlashConfig, 4);
4174 rdmalt(Adapter, FLASH_GPIO_CONFIG_REG, &GPIOConfig, 4);
4175 {
4176 switch (ChipNum) {
4177 case 0:
4178 PartNum = 0;
4179 break;
4180 case 1:
4181 PartNum = 3;
4182 GPIOConfig |= (0x4 << CHIP_SELECT_BIT12);
4183 break;
4184 case 2:
4185 PartNum = 1;
4186 GPIOConfig |= (0x1 << CHIP_SELECT_BIT12);
4187 break;
4188 case 3:
4189 PartNum = 2;
4190 GPIOConfig |= (0x2 << CHIP_SELECT_BIT12);
4191 break;
4192 }
4193 }
4194 /* In case the bits already written in the FLASH_CONFIG_REG is same as what the user desired,
4195 * nothing to do... can return immediately.
4196 * ASSUMPTION: FLASH_GPIO_CONFIG_REG will be in sync with FLASH_CONFIG_REG.
4197 * Even if the chip goes to low power mode, it should wake with values in each register in sync with each other.
4198 * These values are not written by host other than during CHIP_SELECT.
4199 */
4200 if (PartNum == ((FlashConfig >> CHIP_SELECT_BIT12) & 0x3))
4201 return STATUS_SUCCESS;
4202
4203 /* clearing the bit[13..12] */
4204 FlashConfig &= 0xFFFFCFFF;
4205 FlashConfig = (FlashConfig | (PartNum<<CHIP_SELECT_BIT12)); /* 00 */
4206
4207 wrmalt(Adapter, FLASH_GPIO_CONFIG_REG, &GPIOConfig, 4);
4208 udelay(100);
4209
4210 wrmalt(Adapter, FLASH_CONFIG_REG, &FlashConfig, 4);
4211 udelay(100);
4212
4213 return STATUS_SUCCESS;
4214 }
4215
4216 int ReadDSDSignature(struct bcm_mini_adapter *Adapter, enum bcm_flash2x_section_val dsd)
4217 {
4218 unsigned int uiDSDsig = 0;
4219 /* unsigned int sigoffsetInMap = 0;
4220 * struct bcm_dsd_header dsdHeader = {0};
4221 */
4222
4223 /* sigoffsetInMap =(PUCHAR)&(dsdHeader.DSDImageMagicNumber) -(PUCHAR)&dsdHeader; */
4224
4225 if (dsd != DSD0 && dsd != DSD1 && dsd != DSD2) {
4226 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "passed section value is not for DSDs");
4227 return STATUS_FAILURE;
4228 }
4229 BcmFlash2xBulkRead(Adapter,
4230 &uiDSDsig,
4231 dsd,
4232 Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader + FIELD_OFFSET_IN_HEADER(struct bcm_dsd_header *, DSDImageMagicNumber),
4233 SIGNATURE_SIZE);
4234
4235 uiDSDsig = ntohl(uiDSDsig);
4236 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "DSD SIG :%x", uiDSDsig);
4237
4238 return uiDSDsig;
4239 }
4240
4241 int ReadDSDPriority(struct bcm_mini_adapter *Adapter, enum bcm_flash2x_section_val dsd)
4242 {
4243 /* unsigned int priOffsetInMap = 0 ; */
4244 unsigned int uiDSDPri = STATUS_FAILURE;
4245 /* struct bcm_dsd_header dsdHeader = {0};
4246 * priOffsetInMap = (PUCHAR)&(dsdHeader.DSDImagePriority) -(PUCHAR)&dsdHeader;
4247 */
4248 if (IsSectionWritable(Adapter, dsd)) {
4249 if (ReadDSDSignature(Adapter, dsd) == DSD_IMAGE_MAGIC_NUMBER) {
4250 BcmFlash2xBulkRead(Adapter,
4251 &uiDSDPri,
4252 dsd,
4253 Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader + FIELD_OFFSET_IN_HEADER(struct bcm_dsd_header *, DSDImagePriority),
4254 4);
4255
4256 uiDSDPri = ntohl(uiDSDPri);
4257 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "DSD<%x> Priority :%x", dsd, uiDSDPri);
4258 }
4259 }
4260
4261 return uiDSDPri;
4262 }
4263
4264 enum bcm_flash2x_section_val getHighestPriDSD(struct bcm_mini_adapter *Adapter)
4265 {
4266 int DSDHighestPri = STATUS_FAILURE;
4267 int DsdPri = 0;
4268 enum bcm_flash2x_section_val HighestPriDSD = 0;
4269
4270 if (IsSectionWritable(Adapter, DSD2)) {
4271 DSDHighestPri = ReadDSDPriority(Adapter, DSD2);
4272 HighestPriDSD = DSD2;
4273 }
4274
4275 if (IsSectionWritable(Adapter, DSD1)) {
4276 DsdPri = ReadDSDPriority(Adapter, DSD1);
4277 if (DSDHighestPri < DsdPri) {
4278 DSDHighestPri = DsdPri;
4279 HighestPriDSD = DSD1;
4280 }
4281 }
4282
4283 if (IsSectionWritable(Adapter, DSD0)) {
4284 DsdPri = ReadDSDPriority(Adapter, DSD0);
4285 if (DSDHighestPri < DsdPri) {
4286 DSDHighestPri = DsdPri;
4287 HighestPriDSD = DSD0;
4288 }
4289 }
4290 if (HighestPriDSD)
4291 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Highest DSD :%x , and its Pri :%x", HighestPriDSD, DSDHighestPri);
4292
4293 return HighestPriDSD;
4294 }
4295
4296 int ReadISOSignature(struct bcm_mini_adapter *Adapter, enum bcm_flash2x_section_val iso)
4297 {
4298 unsigned int uiISOsig = 0;
4299 /* unsigned int sigoffsetInMap = 0;
4300 * struct bcm_iso_header ISOHeader = {0};
4301 * sigoffsetInMap =(PUCHAR)&(ISOHeader.ISOImageMagicNumber) -(PUCHAR)&ISOHeader;
4302 */
4303 if (iso != ISO_IMAGE1 && iso != ISO_IMAGE2) {
4304 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "passed section value is not for ISOs");
4305 return STATUS_FAILURE;
4306 }
4307 BcmFlash2xBulkRead(Adapter,
4308 &uiISOsig,
4309 iso,
4310 0 + FIELD_OFFSET_IN_HEADER(struct bcm_iso_header *, ISOImageMagicNumber),
4311 SIGNATURE_SIZE);
4312
4313 uiISOsig = ntohl(uiISOsig);
4314 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "ISO SIG :%x", uiISOsig);
4315
4316 return uiISOsig;
4317 }
4318
4319 int ReadISOPriority(struct bcm_mini_adapter *Adapter, enum bcm_flash2x_section_val iso)
4320 {
4321 unsigned int ISOPri = STATUS_FAILURE;
4322 if (IsSectionWritable(Adapter, iso)) {
4323 if (ReadISOSignature(Adapter, iso) == ISO_IMAGE_MAGIC_NUMBER) {
4324 BcmFlash2xBulkRead(Adapter,
4325 &ISOPri,
4326 iso,
4327 0 + FIELD_OFFSET_IN_HEADER(struct bcm_iso_header *, ISOImagePriority),
4328 4);
4329
4330 ISOPri = ntohl(ISOPri);
4331 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "ISO<%x> Priority :%x", iso, ISOPri);
4332 }
4333 }
4334
4335 return ISOPri;
4336 }
4337
4338 enum bcm_flash2x_section_val getHighestPriISO(struct bcm_mini_adapter *Adapter)
4339 {
4340 int ISOHighestPri = STATUS_FAILURE;
4341 int ISOPri = 0;
4342 enum bcm_flash2x_section_val HighestPriISO = NO_SECTION_VAL;
4343
4344 if (IsSectionWritable(Adapter, ISO_IMAGE2)) {
4345 ISOHighestPri = ReadISOPriority(Adapter, ISO_IMAGE2);
4346 HighestPriISO = ISO_IMAGE2;
4347 }
4348
4349 if (IsSectionWritable(Adapter, ISO_IMAGE1)) {
4350 ISOPri = ReadISOPriority(Adapter, ISO_IMAGE1);
4351 if (ISOHighestPri < ISOPri) {
4352 ISOHighestPri = ISOPri;
4353 HighestPriISO = ISO_IMAGE1;
4354 }
4355 }
4356 if (HighestPriISO)
4357 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Highest ISO :%x and its Pri :%x", HighestPriISO, ISOHighestPri);
4358
4359 return HighestPriISO;
4360 }
4361
4362 int WriteToFlashWithoutSectorErase(struct bcm_mini_adapter *Adapter,
4363 PUINT pBuff,
4364 enum bcm_flash2x_section_val eFlash2xSectionVal,
4365 unsigned int uiOffset,
4366 unsigned int uiNumBytes)
4367 {
4368 #if !defined(BCM_SHM_INTERFACE) || defined(FLASH_DIRECT_ACCESS)
4369 unsigned int uiTemp = 0, value = 0;
4370 unsigned int i = 0;
4371 unsigned int uiPartOffset = 0;
4372 #endif
4373 unsigned int uiStartOffset = 0;
4374 /* Adding section start address */
4375 int Status = STATUS_SUCCESS;
4376 PUCHAR pcBuff = (PUCHAR)pBuff;
4377
4378 if (uiNumBytes % Adapter->ulFlashWriteSize) {
4379 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Writing without Sector Erase for non-FlashWriteSize number of bytes 0x%x\n", uiNumBytes);
4380 return STATUS_FAILURE;
4381 }
4382
4383 uiStartOffset = BcmGetSectionValStartOffset(Adapter, eFlash2xSectionVal);
4384
4385 if (IsSectionExistInVendorInfo(Adapter, eFlash2xSectionVal))
4386 return vendorextnWriteSectionWithoutErase(Adapter, pcBuff, eFlash2xSectionVal, uiOffset, uiNumBytes);
4387
4388 uiOffset = uiOffset + uiStartOffset;
4389
4390 #if defined(BCM_SHM_INTERFACE) && !defined(FLASH_DIRECT_ACCESS)
4391 Status = bcmflash_raw_writenoerase((uiOffset / FLASH_PART_SIZE), (uiOffset % FLASH_PART_SIZE), pcBuff, uiNumBytes);
4392 #else
4393 rdmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
4394 value = 0;
4395 wrmalt(Adapter, 0x0f000C80, &value, sizeof(value));
4396
4397 Adapter->SelectedChip = RESET_CHIP_SELECT;
4398 BcmDoChipSelect(Adapter, uiOffset);
4399 uiPartOffset = (uiOffset & (FLASH_PART_SIZE - 1)) + GetFlashBaseAddr(Adapter);
4400
4401 for (i = 0; i < uiNumBytes; i += Adapter->ulFlashWriteSize) {
4402 if (Adapter->ulFlashWriteSize == BYTE_WRITE_SUPPORT)
4403 Status = flashByteWrite(Adapter, uiPartOffset, pcBuff);
4404 else
4405 Status = flashWrite(Adapter, uiPartOffset, pcBuff);
4406
4407 if (Status != STATUS_SUCCESS)
4408 break;
4409
4410 pcBuff = pcBuff + Adapter->ulFlashWriteSize;
4411 uiPartOffset = uiPartOffset + Adapter->ulFlashWriteSize;
4412 }
4413 wrmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
4414 Adapter->SelectedChip = RESET_CHIP_SELECT;
4415 #endif
4416
4417 return Status;
4418 }
4419
4420 bool IsSectionExistInFlash(struct bcm_mini_adapter *Adapter, enum bcm_flash2x_section_val section)
4421 {
4422 bool SectionPresent = false;
4423
4424 switch (section) {
4425 case ISO_IMAGE1:
4426 if ((Adapter->psFlash2xCSInfo->OffsetISOImage1Part1Start != UNINIT_PTR_IN_CS) &&
4427 (IsNonCDLessDevice(Adapter) == false))
4428 SectionPresent = TRUE;
4429 break;
4430 case ISO_IMAGE2:
4431 if ((Adapter->psFlash2xCSInfo->OffsetISOImage2Part1Start != UNINIT_PTR_IN_CS) &&
4432 (IsNonCDLessDevice(Adapter) == false))
4433 SectionPresent = TRUE;
4434 break;
4435 case DSD0:
4436 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSDStart != UNINIT_PTR_IN_CS)
4437 SectionPresent = TRUE;
4438 break;
4439 case DSD1:
4440 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD1Start != UNINIT_PTR_IN_CS)
4441 SectionPresent = TRUE;
4442 break;
4443 case DSD2:
4444 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD2Start != UNINIT_PTR_IN_CS)
4445 SectionPresent = TRUE;
4446 break;
4447 case VSA0:
4448 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSAStart != UNINIT_PTR_IN_CS)
4449 SectionPresent = TRUE;
4450 break;
4451 case VSA1:
4452 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA1Start != UNINIT_PTR_IN_CS)
4453 SectionPresent = TRUE;
4454 break;
4455 case VSA2:
4456 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA2Start != UNINIT_PTR_IN_CS)
4457 SectionPresent = TRUE;
4458 break;
4459 case SCSI:
4460 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForScsiFirmware != UNINIT_PTR_IN_CS)
4461 SectionPresent = TRUE;
4462 break;
4463 case CONTROL_SECTION:
4464 if (Adapter->psFlash2xCSInfo->OffsetFromZeroForControlSectionStart != UNINIT_PTR_IN_CS)
4465 SectionPresent = TRUE;
4466 break;
4467 default:
4468 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Section Does not exist in Flash 2.x");
4469 SectionPresent = false;
4470 }
4471
4472 return SectionPresent;
4473 }
4474
4475 int IsSectionWritable(struct bcm_mini_adapter *Adapter, enum bcm_flash2x_section_val Section)
4476 {
4477 int offset = STATUS_FAILURE;
4478 int Status = false;
4479
4480 if (IsSectionExistInFlash(Adapter, Section) == false) {
4481 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Section <%d> does not exist", Section);
4482 return false;
4483 }
4484
4485 offset = BcmGetSectionValStartOffset(Adapter, Section);
4486 if (offset == INVALID_OFFSET) {
4487 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Section<%d> does not exist", Section);
4488 return false;
4489 }
4490
4491 if (IsSectionExistInVendorInfo(Adapter, Section))
4492 return !(Adapter->psFlash2xVendorInfo->VendorSection[Section].AccessFlags & FLASH2X_SECTION_RO);
4493
4494 Status = IsOffsetWritable(Adapter, offset);
4495 return Status;
4496 }
4497
4498 static int CorruptDSDSig(struct bcm_mini_adapter *Adapter, enum bcm_flash2x_section_val eFlash2xSectionVal)
4499 {
4500 PUCHAR pBuff = NULL;
4501 unsigned int sig = 0;
4502 unsigned int uiOffset = 0;
4503 unsigned int BlockStatus = 0;
4504 unsigned int uiSectAlignAddr = 0;
4505
4506 Adapter->bSigCorrupted = false;
4507 if (Adapter->bAllDSDWriteAllow == false) {
4508 if (IsSectionWritable(Adapter, eFlash2xSectionVal) != TRUE) {
4509 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Section is not Writable...Hence can't Corrupt signature");
4510 return SECTOR_IS_NOT_WRITABLE;
4511 }
4512 }
4513
4514 pBuff = kzalloc(MAX_RW_SIZE, GFP_KERNEL);
4515 if (!pBuff) {
4516 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Can't allocate memorey");
4517 return -ENOMEM;
4518 }
4519
4520 uiOffset = Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader + sizeof(struct bcm_dsd_header);
4521 uiOffset -= MAX_RW_SIZE;
4522
4523 BcmFlash2xBulkRead(Adapter, (PUINT)pBuff, eFlash2xSectionVal, uiOffset, MAX_RW_SIZE);
4524
4525 sig = *((PUINT)(pBuff + 12));
4526 sig = ntohl(sig);
4527 BCM_DEBUG_PRINT_BUFFER(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, pBuff, MAX_RW_SIZE);
4528 /* Now corrupting the sig by corrupting 4th last Byte. */
4529 *(pBuff + 12) = 0;
4530
4531 if (sig == DSD_IMAGE_MAGIC_NUMBER) {
4532 Adapter->bSigCorrupted = TRUE;
4533 if (Adapter->ulFlashWriteSize == BYTE_WRITE_SUPPORT) {
4534 uiSectAlignAddr = uiOffset & ~(Adapter->uiSectorSize - 1);
4535 BlockStatus = BcmFlashUnProtectBlock(Adapter, uiSectAlignAddr, Adapter->uiSectorSize);
4536
4537 WriteToFlashWithoutSectorErase(Adapter, (PUINT)(pBuff + 12), eFlash2xSectionVal,
4538 (uiOffset + 12), BYTE_WRITE_SUPPORT);
4539 if (BlockStatus) {
4540 BcmRestoreBlockProtectStatus(Adapter, BlockStatus);
4541 BlockStatus = 0;
4542 }
4543 } else {
4544 WriteToFlashWithoutSectorErase(Adapter, (PUINT)pBuff, eFlash2xSectionVal,
4545 uiOffset, MAX_RW_SIZE);
4546 }
4547 } else {
4548 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "BCM Signature is not present in header");
4549 kfree(pBuff);
4550
4551 return STATUS_FAILURE;
4552 }
4553
4554 kfree(pBuff);
4555 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Corrupted the signature");
4556
4557 return STATUS_SUCCESS;
4558 }
4559
4560 static int CorruptISOSig(struct bcm_mini_adapter *Adapter, enum bcm_flash2x_section_val eFlash2xSectionVal)
4561 {
4562 PUCHAR pBuff = NULL;
4563 unsigned int sig = 0;
4564 unsigned int uiOffset = 0;
4565
4566 Adapter->bSigCorrupted = false;
4567
4568 if (IsSectionWritable(Adapter, eFlash2xSectionVal) != TRUE) {
4569 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Section is not Writable...Hence can't Corrupt signature");
4570 return SECTOR_IS_NOT_WRITABLE;
4571 }
4572
4573 pBuff = kzalloc(MAX_RW_SIZE, GFP_KERNEL);
4574 if (!pBuff) {
4575 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Can't allocate memorey");
4576 return -ENOMEM;
4577 }
4578
4579 uiOffset = 0;
4580
4581 BcmFlash2xBulkRead(Adapter, (PUINT)pBuff, eFlash2xSectionVal, uiOffset, MAX_RW_SIZE);
4582
4583 sig = *((PUINT)pBuff);
4584 sig = ntohl(sig);
4585
4586 /* corrupt signature */
4587 *pBuff = 0;
4588
4589 if (sig == ISO_IMAGE_MAGIC_NUMBER) {
4590 Adapter->bSigCorrupted = TRUE;
4591 WriteToFlashWithoutSectorErase(Adapter, (PUINT)pBuff, eFlash2xSectionVal,
4592 uiOffset, Adapter->ulFlashWriteSize);
4593 } else {
4594 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "BCM Signature is not present in header");
4595 kfree(pBuff);
4596
4597 return STATUS_FAILURE;
4598 }
4599
4600 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Corrupted the signature");
4601 BCM_DEBUG_PRINT_BUFFER(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, pBuff, MAX_RW_SIZE);
4602
4603 kfree(pBuff);
4604 return STATUS_SUCCESS;
4605 }
4606
4607 bool IsNonCDLessDevice(struct bcm_mini_adapter *Adapter)
4608 {
4609 if (Adapter->psFlash2xCSInfo->IsCDLessDeviceBootSig == NON_CDLESS_DEVICE_BOOT_SIG)
4610 return TRUE;
4611 else
4612 return false;
4613 }
Linux with added FPC-III support