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