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