release/src-rt-6.x.4708/cfe/cfe/arch/mips/board/bcm9635x/src/dev_bcm635x_flash.c

   1 /*
   2 <:copyright-gpl
   3
   4  Copyright 2002 Broadcom Corp. All Rights Reserved.
   5
   6  This program is free software; you can distribute it and/or modify it
   7  under the terms of the GNU General Public License (Version 2) as
   8  published by the Free Software Foundation.
   9
  10  This program is distributed in the hope it will be useful, but WITHOUT
  11  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13  for more details.
  14
  15  You should have received a copy of the GNU General Public License along
  16  with this program; if not, write to the Free Software Foundation, Inc.,
  17  59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
  18
  19 :>
  20 */
  21 /***************************************************************************
  22  * File Name  : dev_bcm6352_flash.c
  23  *
  24  * Description: This file contains flash entry point functions.
  25  *
  26  * Created on :  05/20/2002  lat.  Lifted from BCM96352 board.c.
  27  *
  28  ***************************************************************************/
  29
  30
  31 /* Includes. */
  32 #include "lib_types.h"
  33 #include "lib_malloc.h"
  34 #include "lib_string.h"
  35 #include "lib_printf.h"
  36 #include "cfe_timer.h"
  37
  38 #include "board.h"
  39 #include "6352_map.h"
  40 #include "dev_bcm63xx_flash.h"
  41 #include "flash.h"
  42
  43 static FLASH_ADDR_INFO fInfo;
  44 extern NVRAM_DATA nvramData;
  45 extern int readNvramData(void);
  46
  47
  48 /***********************************************************************
  49  * Function Name: flashAddrReadBlock
  50  * Description  : Reads an array of bytes from flash memory.
  51  * Returns      : None.
  52  ***********************************************************************/
  53 static void flashAddrReadBlock(char *string, char *addr, int strLen, int offset)
  54 {
  55     int i;
  56
  57     if( (offset & 0x01) != ((unsigned long) string & 0x01) )
  58     {
  59         /* Source and destination addresses are on different odd/even
  60          * boundaries.  Do a byte copy.
  61          */
  62         unsigned char *dest = (unsigned char *) string;
  63         unsigned char *src = (unsigned char *) (addr + offset);
  64
  65         for( i = 0; i < strLen; i++ )
  66             *dest++ = *src++;
  67     }
  68     else
  69     {
  70         /* Source and destination addresses are on the same odd/even
  71          * boundaries.  Do a word (16 bit) copy.
  72          */
  73         unsigned short *dest, *src;
  74
  75         if( (offset & 0x01) == 0x01 )
  76         {
  77             *string++ = (char) *(addr + offset);
  78             strLen--;
  79             offset++;
  80         }
  81
  82         dest = (unsigned short*) string;
  83         src = (unsigned short*) (addr + offset);
  84
  85         for( i = 0; i < strLen / 2; i++ )
  86             *dest++ = *src++;
  87
  88         if( (strLen & 0x01) == 0x01 )
  89             string[strLen - 1] = *(addr + offset + strLen - 1);
  90     }
  91
  92 } /* flashAddrReadBlock */
  93
  94
  95 //**************************************************************************************
  96 // Flash read/write and image downloading..
  97 //**************************************************************************************
  98
  99 void kerSysFlashInit( void )
 100 {
 101     int i = 0;
 102     int totalBlks = 0;
 103     int totalSize = 0;
 104     int startAddr = 0;
 105     int usedBlkSize = 0;
 106
 107     flash_init();
 108
 109     totalBlks = flash_get_numsectors();
 110     totalSize = flash_get_total_size();
 111
 112 #if defined(DEBUG_FLASH)
 113     printf("totalBlks=%d\n", totalBlks);
 114     printf("totalSize=%dK\n", totalSize/1024);
 115 #endif
 116
 117
 118     /* nvram is always at the end of flash */
 119     fInfo.flash_nvram_length = NVRAM_LENGTH;
 120     startAddr = totalSize - NVRAM_LENGTH;
 121     fInfo.flash_nvram_start_blk = flash_get_blk(startAddr+FLASH_BASE_ADDR_REG);
 122     fInfo.flash_nvram_number_blk = totalBlks - fInfo.flash_nvram_start_blk;
 123
 124 printf("nvram startaddr = 0x%x, start_blk = %d\n", startAddr, fInfo.flash_nvram_start_blk);
 125
 126     // find out the offset in the start_blk
 127     for (i = fInfo.flash_nvram_start_blk;
 128         i < (fInfo.flash_nvram_start_blk + fInfo.flash_nvram_number_blk); i++)
 129         usedBlkSize += flash_get_sector_size((byte) i);
 130
 131 #if defined(DEBUG_FLASH)
 132     printf("i=%d, usedBlkSize=%d\n", i, usedBlkSize);
 133 #endif
 134
 135     fInfo.flash_nvram_blk_offset = usedBlkSize - NVRAM_LENGTH;
 136
 137     if (readNvramData() != 0)
 138     {
 139         printf("Board is not initialized: Using the default PSI size: %d\n", NVRAM_PSI_DEFAULT_635X);
 140         fInfo.flash_persistent_length = NVRAM_PSI_DEFAULT_635X;
 141     }
 142     else
 143         fInfo.flash_persistent_length = nvramData.ulPsiSize;
 144
 145     /* PSI is right below NVRAM */
 146     fInfo.flash_persistent_length *= ONEK;
 147     startAddr -= fInfo.flash_persistent_length;          // PSI start address
 148     fInfo.flash_persistent_start_blk = flash_get_blk(startAddr+FLASH_BASE_ADDR_REG);
 149     if (fInfo.flash_nvram_start_blk == fInfo.flash_persistent_start_blk)  // share blk
 150     {
 151         fInfo.flash_persistent_number_blk = 1;
 152         fInfo.flash_persistent_blk_offset = fInfo.flash_nvram_blk_offset - fInfo.flash_persistent_length;
 153     }
 154     else // on different blk
 155     {
 156         fInfo.flash_persistent_number_blk = totalBlks - fInfo.flash_persistent_start_blk;
 157         // find out the offset in the start_blk
 158         usedBlkSize = 0;
 159         for (i = fInfo.flash_persistent_start_blk;
 160             i < (fInfo.flash_persistent_start_blk + fInfo.flash_persistent_number_blk); i++)
 161             usedBlkSize += flash_get_sector_size((byte) i);
 162
 163 printf("usesize=%d\n", usedBlkSize);
 164
 165         fInfo.flash_persistent_blk_offset =  usedBlkSize - fInfo.flash_persistent_length - fInfo.flash_nvram_length;
 166     }
 167
 168 #if defined(DEBUG_FLASH)
 169     printf("fInfo.flash_nvram_start_blk = %d\n", fInfo.flash_nvram_start_blk);
 170     printf("fInfo.flash_nvram_blk_offset = 0x%x\n", fInfo.flash_nvram_blk_offset);
 171     printf("fInfo.flash_nvram_number_blk = %d\n", fInfo.flash_nvram_number_blk);
 172
 173     printf("psi startAddr = %x\n", startAddr+FLASH_BASE_ADDR_REG);
 174     printf("fInfo.flash_persistent_start_blk = %d\n", fInfo.flash_persistent_start_blk);
 175     printf("fInfo.flash_persistent_blk_offset = 0x%x\n", fInfo.flash_persistent_blk_offset);
 176     printf("fInfo.flash_persistent_number_blk = %d\n", fInfo.flash_persistent_number_blk);
 177 #endif
 178
 179 }
 180
 181
 182 /***********************************************************************
 183  * Function Name: kerSysFlashAddrInfoGet
 184  * Description  : Fills in a structure with information about the NVRAM
 185  *                and persistent storage sections of flash memory.
 186  * Returns      : None.
 187  ***********************************************************************/
 188 void kerSysFlashAddrInfoGet(PFLASH_ADDR_INFO pflash_addr_info)
 189 {
 190     pflash_addr_info->flash_nvram_blk_offset = fInfo.flash_nvram_blk_offset;
 191     pflash_addr_info->flash_nvram_length = fInfo.flash_nvram_length;
 192     pflash_addr_info->flash_nvram_number_blk = fInfo.flash_nvram_number_blk;
 193     pflash_addr_info->flash_nvram_start_blk = fInfo.flash_nvram_start_blk;
 194     pflash_addr_info->flash_persistent_blk_offset = fInfo.flash_persistent_blk_offset;
 195     pflash_addr_info->flash_persistent_length = fInfo.flash_persistent_length;
 196     pflash_addr_info->flash_persistent_number_blk = fInfo.flash_persistent_number_blk;
 197     pflash_addr_info->flash_persistent_start_blk = fInfo.flash_persistent_start_blk;
 198 }
 199
 200
 201 // get shared blks into *** pTempBuf *** which has to be released bye the caller!
 202 // return: if pTempBuf != NULL, poits to the data with the dataSize of the buffer
 203 // !NULL -- ok
 204 // NULL  -- fail
 205 static char *getSharedBlks(int start_blk, int end_blk)
 206 {
 207     int i = 0;
 208     int usedBlkSize = 0;
 209     int sect_size = 0;
 210     char *pTempBuf = NULL;
 211     char *pBuf = NULL;
 212
 213     for (i = start_blk; i < end_blk; i++)
 214         usedBlkSize += flash_get_sector_size((byte) i);
 215
 216 //printf("usedBlkSize = %d\n", usedBlkSize);
 217
 218     if ((pTempBuf = (char *) KMALLOC(usedBlkSize, sizeof(long))) == NULL)
 219     {
 220         printf("failed to allocate memory with size: %d\n", usedBlkSize);
 221         return pTempBuf;
 222     }
 223
 224     pBuf = pTempBuf;
 225     for (i = start_blk; i < end_blk; i++)
 226     {
 227         sect_size = flash_get_sector_size((byte) i);
 228 #if defined(DEBUG_FLASH)
 229         printf("getShareBlks: i=%d, sect_size=%d, end_blk=%d\n", i, sect_size, end_blk);
 230 #endif
 231         flashAddrReadBlock(pBuf, (char *) flash_get_memptr(i), sect_size, 0);
 232         pBuf += sect_size;
 233     }
 234
 235     return pTempBuf;
 236 }
 237
 238
 239
 240 // Set the pTempBuf to flash from start_blk to end_blk
 241 // return:
 242 // 0 -- ok
 243 // -1 -- fail
 244 static int setSharedBlks(int start_blk, int end_blk, char *pTempBuf)
 245 {
 246     int i = 0;
 247     int sect_size = 0;
 248     int sts = 0;
 249     unsigned short esr;
 250     unsigned char *src = (unsigned char *) pTempBuf;
 251     unsigned char *dest =  flash_get_memptr(start_blk);
 252
 253     for (i = start_blk; i < end_blk; i++)
 254     {
 255         sect_size = flash_get_sector_size((byte) i);
 256         if (AddrWriteProtect((unsigned short *) dest, UNLOCK) != 0)
 257         {
 258             printf("Failed on unlock\n");
 259             sts = -1;
 260             break;
 261         }
 262         if (EraseFlashBlock(i) != 0)
 263         {
 264             printf("Failed to erase flash sector: %d\n", i);
 265             sts  = -1;
 266             break;
 267         }
 268         if( FlashWordWrite((unsigned short *) dest, (unsigned short *) src,
 269             sect_size / sizeof(short), &esr) != 0 )
 270         {
 271             sts = -1;
 272             break;
 273         }
 274         AddrWriteProtect((unsigned short *) dest, LOCK);
 275
 276         src += sect_size;
 277         dest += sect_size;
 278         printf(".");
 279     }
 280
 281     cfe_sleep(1); /* mdelay(100); */
 282     Set_Read_Array();
 283
 284     return sts;
 285 }
 286
 287
 288
 289 /*******************************************************************************
 290  * NVRAM functions
 291  *******************************************************************************/
 292
 293 // get nvram data
 294 // return:
 295 //  0 - ok
 296 //  -1 - fail
 297 int kerSysNvRamGet(char *string, int strLen, int offset)
 298 {
 299     char *pBuf = NULL;
 300
 301     if (strLen > NVRAM_LENGTH)
 302         return -1;
 303
 304     if ((pBuf = getSharedBlks(fInfo.flash_nvram_start_blk,
 305         (fInfo.flash_nvram_start_blk + fInfo.flash_nvram_number_blk))) == NULL)
 306         return -1;
 307
 308     // get string off the memory buffer
 309     memcpy(string, (pBuf + fInfo.flash_nvram_blk_offset + offset), strLen);
 310
 311     KFREE(pBuf);
 312
 313     return 0;
 314 }
 315
 316
 317 // set nvram
 318 // return:
 319 //  0 - ok
 320 //  -1 - fail
 321 int kerSysNvRamSet(char *string, int strLen, int offset)
 322 {
 323     int sts = 0;
 324     char *pBuf = NULL;
 325
 326     if (strLen > NVRAM_LENGTH)
 327         return -1;
 328
 329     if ((pBuf = getSharedBlks(fInfo.flash_nvram_start_blk,
 330         (fInfo.flash_nvram_start_blk + fInfo.flash_nvram_number_blk))) == NULL)
 331         return -1;
 332
 333     // set string to the memory buffer
 334     memcpy((pBuf + fInfo.flash_nvram_blk_offset + offset), string, strLen);
 335
 336     if (setSharedBlks(fInfo.flash_nvram_start_blk,
 337         (fInfo.flash_nvram_number_blk + fInfo.flash_nvram_start_blk), pBuf) != 0)
 338         sts = -1;
 339
 340     KFREE(pBuf);
 341
 342     return sts;
 343 }
 344
 345
 346 /***********************************************************************
 347  * Function Name: kerSysEraseNvRam
 348  * Description  : Erase the NVRAM storage section of flash memory.
 349  * Returns      : 1 -- ok, 0 -- fail
 350  ***********************************************************************/
 351 int kerSysEraseNvRam(void)
 352 {
 353     int sts = 1;
 354     char *tempStorage = KMALLOC(NVRAM_LENGTH, sizeof(long));
 355
 356     // just write the whole buf with '0xff' to the flash
 357     if (!tempStorage)
 358         sts = 0;
 359     else
 360     {
 361         memset(tempStorage, 0xff, NVRAM_LENGTH);
 362         if (kerSysNvRamSet(tempStorage, NVRAM_LENGTH, 0) != 0)
 363             sts = 0;
 364         KFREE(tempStorage);
 365     }
 366
 367     return sts;
 368 }
 369
 370
 371 /*******************************************************************************
 372  * PSI functions
 373  *******************************************************************************/
 374 // get psi data
 375 // return:
 376 //  0 - ok
 377 //  -1 - fail
 378 int kerSysPsiGet(char *string, int strLen, int offset)
 379 {
 380     char *pBuf = NULL;
 381
 382     if (strLen > fInfo.flash_persistent_length)
 383         return -1;
 384
 385     if ((pBuf = getSharedBlks(fInfo.flash_persistent_start_blk,
 386         (fInfo.flash_persistent_start_blk + fInfo.flash_persistent_number_blk))) == NULL)
 387         return -1;
 388
 389     // get string off the memory buffer
 390     memcpy(string, (pBuf + fInfo.flash_persistent_blk_offset + offset), strLen);
 391
 392     KFREE(pBuf);
 393
 394     return 0;
 395 }
 396
 397
 398 // set psi
 399 // return:
 400 //  0 - ok
 401 //  -1 - fail
 402 int kerSysPsiSet(char *string, int strLen, int offset)
 403 {
 404     int sts = 0;
 405     char *pBuf = NULL;
 406
 407     if (strLen > fInfo.flash_persistent_length)
 408         return -1;
 409
 410     if ((pBuf = getSharedBlks(fInfo.flash_persistent_start_blk,
 411         (fInfo.flash_persistent_start_blk + fInfo.flash_persistent_number_blk))) == NULL)
 412         return -1;
 413
 414     // set string to the memory buffer
 415     memcpy((pBuf + fInfo.flash_persistent_blk_offset + offset), string, strLen);
 416
 417     if (setSharedBlks(fInfo.flash_persistent_start_blk,
 418         (fInfo.flash_persistent_number_blk + fInfo.flash_persistent_start_blk), pBuf) != 0)
 419         sts = -1;
 420
 421     KFREE(pBuf);
 422
 423     return sts;
 424 }
 425
 426
 427 /***********************************************************************
 428  * Function Name: kerSysErasePsi
 429  * Description  : Erase the Psi storage section of flash memory.
 430  * Returns      : 1 -- ok, 0 -- fail
 431  ***********************************************************************/
 432 int kerSysErasePsi(void)
 433 {
 434     int sts = 1;
 435     char *tempStorage = KMALLOC(fInfo.flash_persistent_length, sizeof(long));
 436
 437     // just write the whole buf with '0xff' to the flash
 438     if (!tempStorage)
 439         sts = 0;
 440     else
 441     {
 442         memset(tempStorage, 0xff, fInfo.flash_persistent_length);
 443         if (kerSysPsiSet(tempStorage, fInfo.flash_persistent_length, 0) != 0)
 444             sts = 0;
 445         KFREE(tempStorage);
 446     }
 447
 448     return sts;
 449 }
 450
 451
 452 /***********************************************************************
 453  * Function Name: kerSysMemoryTypeSet
 454  * Description  : set the memory type 4 bytes
 455  * Returns      : 1 -- ok, 0 -- fail
 456  ***********************************************************************/
 457 int kerSysMemoryTypeSet(int flash_address, char *string, int size)
 458 {
 459     int sect_size;
 460     int blk_start;
 461     char *pTempBuf;
 462     unsigned short esr;
 463
 464     blk_start = flash_get_blk(flash_address);
 465     sect_size = flash_get_sector_size(blk_start);
 466
 467     if ((pTempBuf = (char *) KMALLOC(sect_size, sizeof(long))) == NULL)
 468     {
 469         printf("Failed to allocate memory with size: %d\n", sect_size);
 470         return 0;
 471     }
 472
 473     flashAddrReadBlock(pTempBuf, (char *) flash_address, sect_size, 0);
 474     memcpy(pTempBuf+SDRAM_TYPE_ADDRESS_OFFSET, string, size);
 475
 476     if (EraseFlashBlock(blk_start) != 0)
 477     {
 478         printf("Failed to erase flash sector: %d\n", blk_start);
 479         return 0;
 480     }
 481
 482     if(FlashWordWrite((unsigned short *)flash_address,(unsigned short *)pTempBuf,sect_size/sizeof(short), &esr) != 0) // failed
 483     {
 484         printf("Failed to flash the memory type\n");
 485         return 0;
 486     }
 487
 488     cfe_sleep(1);
 489     Set_Read_Array();
 490
 491     return 1;
 492 }
 493
 494
 495 /***********************************************************************
 496  * Function Name: kerSysMemoryTypeGet
 497  * Description  : get the memory type 4 bytes
 498  * Returns      : memory type
 499  ***********************************************************************/
 500 int kerSysMemoryTypeGet(void)
 501 {
 502     int sdramType = BOARD_SDRAM_TYPE;
 503
 504     return sdramType;
 505 }
 506
 507
 508 // flash bcm image
 509 // return:
 510 // 0 - ok
 511 // !0 - the sector number fail to be flashed (should not be 0)
 512 int kerSysBcmImageSet( int flash_start_addr, char *string, int size, int fWholeImage)
 513 {
 514     int sts = -1;
 515     int sect_size;
 516     int blk_start;
 517     char *pTempBuf = NULL;
 518     unsigned char *flash_address = NULL;
 519     unsigned short esr;
 520
 521 //printf("flash_start_addr = 0x%x\n", flash_start_addr);
 522
 523     blk_start = flash_get_blk(flash_start_addr);
 524     if( blk_start < 0 )
 525         return sts;
 526
 527    /* write image to flash memory */
 528     do
 529     {
 530         sect_size = flash_get_sector_size(blk_start);
 531         flash_address = flash_get_memptr(blk_start);
 532
 533 #if defined(DEBUG_FLASH)
 534         printf("Image flasing on block: %d\n", blk_start);
 535 #endif
 536
 537         // share the blk with nvram only when fWholeImage == 0
 538         if (!fWholeImage && blk_start == fInfo.flash_nvram_start_blk)
 539         {
 540             if (size > (sect_size - NVRAM_LENGTH))
 541             {
 542                 printf("Image is too big\n");
 543                 return sts;          // image is too big. Can not overwrite to nvram
 544             }
 545             if ((pTempBuf = (char *) KMALLOC(sect_size, sizeof(long))) == NULL)
 546             {
 547                 printf("Failed to allocate memory with size: %d\n", sect_size);
 548                 return sts;
 549             }
 550             flashAddrReadBlock(pTempBuf, (char *) flash_address, sect_size, 0);
 551             memcpy(pTempBuf, string, size);
 552
 553             if (AddrWriteProtect((unsigned short *) flash_address, UNLOCK) != 0)
 554             {
 555                 printf("Failed on unlock\n");
 556                 return sts;
 557             }
 558             if (EraseFlashBlock(blk_start) != 0)
 559             {
 560                 printf("Failed to erase flash sector: %d\n", blk_start);
 561                 return sts;
 562             }
 563             if( FlashWordWrite((unsigned short *)flash_address, (unsigned short *) pTempBuf,
 564                 sect_size / sizeof(short), &esr) == 0 ) // write ok
 565                 size = 0;
 566             AddrWriteProtect((unsigned short *)flash_address, LOCK);
 567             // break out and say all is ok
 568             break;
 569         }
 570
 571         if (sect_size > size)
 572         {
 573             if (size & 1)
 574                 size++;
 575             sect_size = size;
 576         }
 577
 578         EraseFlashBlock(blk_start);
 579         if( FlashWordWrite((unsigned short *)flash_address, (unsigned short *) string,
 580             sect_size / sizeof(short), &esr) != 0 )
 581             break;
 582         printf(".");
 583         blk_start++;
 584         string += sect_size;
 585         size -= sect_size;
 586     } while (size > 0);
 587
 588     cfe_sleep(1);
 589     Set_Read_Array();
 590
 591     if( size == 0 )
 592         sts = 0;  // ok
 593     else
 594         sts = blk_start;    // failed to flash this sector
 595
 596     return sts;
 597 }