flashcode1.c

ST公司的upsd34XX评估板固定源程序

 /* `=========================================================================`

                    ***************************************
                  ****   *                           *   ****
                               Title: FLASHCODE1
                            File name: Flashcode1.c
                            Project name: FLASHCODE1
                  ***                                    ****
                    ****************** * ******************
                  ****                                   ****
                              Author: Petr PFEIFER
                           MPG Prague, Czech Republic
                  ****   *                           *   ****
                    ***************************************

                 $Version:  0.010   Build: 2004-01-28,12:15:55

 
 
                                  Description:
                                  ============
                      based on the previous DEMO 1.07 version,
                              Erase problem fixed.
               Since version 0.004 only one uPSD3200.h is needed.


                                     Notes:
                                     ======
                                     - none




                           ..........................
                          .                          .
                          .      ******************  .
                          .     **PPPPPPPPPPPPPPPP   .
                          .     *PPPP*******PP****   .
                          .    **PPP********PP***    .
                          .    ***PPP******PP****    .
                          .   *****PPP****PP****     .
                          .   *****PPP****PP****     .
                          .  PPPPPPPP****PP****  (R) .
                          .                          .
                           ..........................


                                  =-=-=-=-=-=
                           =-=-=-=-=-=-=-=-=-=-=-=-=
                =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

                       Copyright 2004 ST Microelectronics

             This code/file is provided as is and has no warranty,
     implied or otherwise.  You are free to use/modify any of the provided
    code at your own risk in your applications with the expressed limitation
        of liability (see below) so long as your product using the code
                 contains at least one uPSD products (device).

                            LIMITATION OF LIABILITY:
                            ========================
              NEITHER STMicroelectronics NOR ITS VENDORS OR AGENTS
      SHALL BE LIABLE FOR ANY LOSS OF PROFITS, LOSS OF USE, LOSS OF DATA,
       INTERRUPTION OF BUSINESS, NOR FOR INDIRECT, SPECIAL, INCIDENTAL OR
       CONSEQUENTIAL DAMAGES OF ANY KIND WHETHER UNDER THIS AGREEMENT OR
         OTHERWISE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.

                =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
                           =-=-=-=-=-=-=-=-=-=-=-=-=
                                  =-=-=-=-=-=

                   For current information on uPSD products,
                please consult our pages on the World Wide Web:

                                 www.st.com/psm

                            - - - - - - - - - - - -

                     STMicroelectronics GROUP OF COMPANIES
    Australia - Brazil - China - Czech Republic - Finland - France - Germany
   Hong Kong - India - Italy - Japan - Malaysia - Malta - Morocco - Singapore
             Spain - Sweden - Switzerland - United Kingdom - U.S.A.

                               http://www.st.com


 `========================================================================` */

#pragma NOAREGS

#include "uPSD3200.h"


/* Function prototypes
                                       */
#define _F_W_W_P
#define _F_E_B
#define _F_R


unsigned char flash_write_with_poll(
    volatile unsigned char xdata *addr, unsigned char dat);
unsigned char flash_erase_sector(
    volatile unsigned char xdata* flash_bulk_erase_address);
unsigned char flash_boot_write_with_poll(
    volatile unsigned char xdata *addr, unsigned char dat);
unsigned char flash_boot_erase_sector(
    volatile unsigned char xdata* flash_boot_bulk_erase_address);

unsigned char flash_write_with_toggle(unsigned char *addr,unsigned char dat);
void flash_reset(void);
unsigned char flash_read_id(unsigned char *flash_id_address);
unsigned char flash_read_sector_protect(void);
unsigned char flash_boot_write_with_toggle(volatile unsigned char *addr,
unsigned char dat);
void flash_boot_reset(void);
unsigned char flash_boot_read_id(volatile unsigned char *flash_boot_id_address);
unsigned char flash_boot_read_sector_protect(void);




#ifdef _F_W_W_P

unsigned char flash_write_with_poll(volatile uchar xdata* addr, uchar dat)
/******************************************************************************
 Function   : unsigned char flash_write_with_poll()
 Parameters : (volatile uchar xdata* addr, uchar dat)
 Description: Writes data to flash
 ******************************************************************************/
 {
  unsigned char done;
  unsigned char error;
  unsigned char err;
  unsigned char poll;

  done = FALSE;
  err = FALSE;

                            //  Note:  the following constants (FLASH_COMMON_XXXX)
                              //     are declared type volatile in the header file
                              //    so they are not optimized away by the compiler


  *(FLASH_COMMON_X555) = 0xAA;   // unlock main flash, write 0xAA to addess 0xX555
  *(FLASH_COMMON_XAAA) = 0x55;   // unlock main flash, write 0x55 to addess 0xXAAA
  *(FLASH_COMMON_X555) = 0xA0;               // write 0xA0 command to program

  *(addr) = dat;                             // write byte to flash
  dat = dat & NVM_DATA_POLL;                 // get bit DQ7 of original dat

  do                      // now use dat polling method to verify successful write
   {
    poll = *(addr);                  // Read the location that was just programmed
    error = poll & NVM_ERROR;                // save timeout error bit at DQ5
    poll = poll & NVM_DATA_POLL;           // get DQ7 of poll byte read from flash
    if (dat == poll)                         // compare DQ7
     {
      done = TRUE;                           // dat byte programmed into flash OK,
                                             // indicate successful exit criteria
     }
    else if (error ==  NVM_ERROR )           // check for timeout error
     {
      err = TRUE;                            // indicate timeout error occurred
     }

   }
  while((done == FALSE) && (err == FALSE));


  if (err == TRUE)                  // make sure timeout error and dat poll didn't
                                             // occur simultaneously
   {
    poll = *(addr);                          // Read location in flash again
    poll = poll & NVM_DATA_POLL;           // get DQ7 of poll byte read from flash
    if (dat == poll)                         // compare DQ7
     {
      done = TRUE;                // dat byte programmed into flash OK at the same
                   // time timout error occured, indicate successful exit criteria
     }
    *(FLASH_COMMON_X555) = 0xF0;// reset the flash array (short reset instruction)
                                             // now delay 3 msec per dat sheet
   }
  return(done);     // a successful flash write returns 1, timeout error returns 0
 }






unsigned char flash_boot_write_with_poll(volatile uchar xdata* addr, uchar dat)
/******************************************************************************
 Function   : unsigned char flash_boot_write_with_poll()
 Parameters : (volatile uchar xdata* addr, uchar dat)
 Description: Writes data to boot flash
 ******************************************************************************/
 {
  unsigned char done;
  unsigned char error;
  unsigned char err;
  unsigned char poll;

  done = FALSE;
  err = FALSE;
                              //  Note:  the following constants (FLASH_BOOT_XXXX)
                              //     are declared type volatile in the header file
                              //    so they are not optimized away by the compiler

  *(FLASH_BOOT_X555) = 0xAA;     // unlock main flash, write 0xAA to addess 0xX555
  *(FLASH_BOOT_XAAA) = 0x55;     // unlock main flash, write 0x55 to addess 0xXAAA
  *(FLASH_BOOT_X555) = 0xA0;                 // write 0xA0 command to program

  *(addr) = dat;                             // write byte to flash
  dat = dat & NVM_DATA_POLL;                 // get bit DQ7 of original dat

  do                      // now use dat polling method to verify successful write
   {
    poll = *(addr);                  // Read the location that was just programmed
    error = poll & NVM_ERROR;                // save timeout error bit at DQ5
    poll = poll & NVM_DATA_POLL;           // get DQ7 of poll byte read from flash

    if (dat == poll)                         // compare DQ7
     {
      done = TRUE;                           // dat byte programmed into flash OK,
                                             // indicate successful exit criteria
     }
    else if (error ==  NVM_ERROR )           // check for timeout error
     {
      err = TRUE;                            // indicate timeout error occurred
     }

   }
  while((done == FALSE) && (err == FALSE));


  if (err == TRUE)                  // make sure timeout error and dat poll didn't
                                             // occur simultaneously
   {
    poll = *(addr);                          // Read location in flash again
    poll = poll & NVM_DATA_POLL;           // get DQ7 of poll byte read from flash
    if (dat == poll)                         // compare DQ7
     {
      done = TRUE;                // dat byte programmed into flash OK at the same
                   // time timout error occured, indicate successful exit criteria
     }
    *(FLASH_BOOT_X555) = 0xF0;  // reset the flash array (short reset instruction)
                                             // now delay 3 msec per dat sheet
   }
  return(done);     // a successful flash write returns 1, timeout error returns 0
 }

#endif








#ifdef _F_W_W_T

unsigned char flash_write_with_toggle(addr,dat)
/******************************************************************************
 Function   : unsigned char flash_write_with_toggle()
 Parameters : (addr,dat)
 Description: Programs a single byte, checks status using toggle method.

          You'll need to include the header files generated by PSDsoft
         Express. Important: if memory paging is used, the correct page
        value must be set in the PSD page register prior to calling this
                                   function.
 ******************************************************************************/
volatile unsigned char *addr;
unsigned char dat;
 {
  unsigned char done;
  unsigned char error;
  unsigned char err;
  volatile unsigned char toggle_A;
  volatile unsigned char toggle_B;

  done = FALSE;
  err = FALSE;

                              //  Note:  the following constants (FLASH_BOOT_XXXX)
                              //     are declared type volatile in the header file
                              //    so they are not optimized away by the compiler

  *(FLASH_BOOT_X555) = 0xAA;     // unlock main flash, write 0xAA to addess 0xX555
  *(FLASH_BOOT_XAAA) = 0x55;     // unlock main flash, write 0x55 to addess 0xXAAA
  *(FLASH_BOOT_X555) = 0xA0;                 // write 0xA0 command to program

  *(addr) = dat;                             // write byte to flash
                             // now use toggling method to verify successful write
  toggle_A = *(addr);                // Read the location that was just programmed
  toggle_A = toggle_A & NVM_DATA_TOGGLE;     // mask toggle bit at DQ6

  do
   {
    toggle_B = *(addr);        // Again read the location that was just programmed
    error = toggle_B & NVM_ERROR;            // save timeout error flag at DQ5
    toggle_B = toggle_B & NVM_DATA_TOGGLE;   // mask toggle bit at DQ6
    if (toggle_A == toggle_B)                // compare toggle bit DQ6
     {
      done = TRUE;                 // bit did not toggle, dat byte programmed into
                                    // flash OK, indicate successful exit criteria
     }
    else if (error ==  NVM_ERROR )           // check for timeout error
     {
      err = TRUE;                            // indicate timeout error occurred
     }
    toggle_A = toggle_B;                  // save most recent sample of toggle bit
                                             // to compare with next sample
   }
  while((done == FALSE) && (err == FALSE));