flashutil.c

采用ST20 CPU的机顶盒的烧写程序

  }
}

static void writeDisable_mb392(void)
{
  volatile unsigned char* rw_reg = (volatile unsigned char*)
    vmem_create((void*)0x0200001C, vmem_min_page_size(), NULL, VMEM_CREATE_UNCACHED);
  if (!rw_reg)
  {
    fprintf(stderr, "flashutil: Failed to create virtual mapping to disable FLASH writes - attempting to continue\n");
    return;
  }
  *rw_reg = 0;
  if (OS21_SUCCESS != vmem_delete((void*)rw_reg))
  {
    fprintf(stderr, "flashutil: Failed to delete virtual mapping used disable FLASH writes - continuing\n");
  }
}

static void writeEnable_tmmidr04(void)
{
  volatile unsigned char* pio_virtual_ptr = (volatile unsigned char*)
    vmem_create((void*)0x18323000, 0x100, NULL, VMEM_CREATE_UNCACHED);
  if (!pio_virtual_ptr)
  {
    fprintf(stderr, "flashutil: Failed to create virtual mapping to enable FLASH writes - attempting to continue\n");
    return;
  }
  PIO_CONFIGURE(pio_virtual_ptr, 0, PIO_CFG_OUT);
  *pio_virtual_ptr = 1;
  if (OS21_SUCCESS != vmem_delete((void*)pio_virtual_ptr))
  {
    fprintf(stderr, "flashutil: Failed to delete virtual mapping used enable FLASH writes - continuing\n");
  }

  task_delay(time_ticks_per_sec() / 5);
}

static void writeDisable_tmmidr04(void)
{
  volatile unsigned char* pio_virtual_ptr = (volatile unsigned char*)
    vmem_create((void*)0x18323000, 0x100, NULL, VMEM_CREATE_UNCACHED);
  if (!pio_virtual_ptr)
  {
    fprintf(stderr, "flashutil: Failed to create virtual mapping to disable FLASH writes - attempting to continue\n");
    return;
  }
  *pio_virtual_ptr = 0;
  if (OS21_SUCCESS != vmem_delete((void*)pio_virtual_ptr))
  {
    fprintf(stderr, "flashutil: Failed to delete virtual mapping used disable FLASH writes - continuing\n");
  }

  task_delay(time_ticks_per_sec() / 5);
}

static void writeEnable_tmmlr2(void)
{
  volatile unsigned char* pio_virtual_ptr = (volatile unsigned char*)
    vmem_create((void*)0x18323000, 0x100, NULL, VMEM_CREATE_UNCACHED);
  if (!pio_virtual_ptr)
  {
    fprintf(stderr, "flashutil: Failed to create virtual mapping to enable FLASH writes - attempting to continue\n");
    return;
  }
  PIO_CONFIGURE(pio_virtual_ptr, 0, PIO_CFG_OUT);
  *pio_virtual_ptr = 0;
  if (OS21_SUCCESS != vmem_delete((void*)pio_virtual_ptr))
  {
    fprintf(stderr, "flashutil: Failed to delete virtual mapping used enable FLASH writes - continuing\n");
  }

  task_delay(time_ticks_per_sec() / 5);
}

static void writeDisable_tmmlr2(void)
{
  volatile unsigned char* pio_virtual_ptr = (volatile unsigned char*)
    vmem_create((void*)0x18323000, 0x100, NULL, VMEM_CREATE_UNCACHED);
  if (!pio_virtual_ptr)
  {
    fprintf(stderr, "flashutil: Failed to create virtual mapping to disable FLASH writes - attempting to continue\n");
    return;
  }
  *pio_virtual_ptr = 1;
  if (OS21_SUCCESS != vmem_delete((void*)pio_virtual_ptr))
  {
    fprintf(stderr, "flashutil: Failed to delete virtual mapping used disable FLASH writes - continuing\n");
  }

  task_delay(time_ticks_per_sec() / 5);
}

#elif defined(__stb7100__) || defined(__stb7109__)

static void writeEnable_mb411(void)
{
  volatile unsigned char* vpp_reg = (volatile unsigned char*)
    vmem_create((void*)0x03400000, vmem_min_page_size(), NULL, VMEM_CREATE_UNCACHED);
  if (!vpp_reg)
  {
    fprintf(stderr, "flashutil: Failed to create virtual mapping to enable FLASH writes - attempting to continue\n");
    return;
  }
  *vpp_reg = 3;
  if (OS21_SUCCESS != vmem_delete((void*)vpp_reg))
  {
    fprintf(stderr, "flashutil: Failed to delete virtual mapping used enable FLASH writes - continuing\n");
  }
}

static void writeDisable_mb411(void)
{
  volatile unsigned char* vpp_reg = (volatile unsigned char*)
    vmem_create((void*)0x03400000, vmem_min_page_size(), NULL, VMEM_CREATE_UNCACHED);
  if (!vpp_reg)
  {
    fprintf(stderr, "flashutil: Failed to create virtual mapping to disable FLASH writes - attempting to continue\n");
    return;
  }
  *vpp_reg = 2;
  if (OS21_SUCCESS != vmem_delete((void*)vpp_reg))
  {
    fprintf(stderr, "flashutil: Failed to delete virtual mapping used disable FLASH writes - continuing\n");
  }
}

#elif defined(__sti7200__)

static void writeEnable_mb519(void)
{
  volatile unsigned char* vpp_reg = (volatile unsigned char*)
    vmem_create((void*)0x05400000, vmem_min_page_size(), NULL, VMEM_CREATE_UNCACHED);
  if (!vpp_reg)
  {
    fprintf(stderr, "flashutil: Failed to create virtual mapping to enable FLASH writes - attempting to continue\n");
    return;
  }
  *vpp_reg = 3;
  if (OS21_SUCCESS != vmem_delete((void*)vpp_reg))
  {
    fprintf(stderr, "flashutil: Failed to delete virtual mapping used enable FLASH writes - continuing\n");
  }
}

static void writeDisable_mb519(void)
{
  volatile unsigned char* vpp_reg = (volatile unsigned char*)
    vmem_create((void*)0x05400000, vmem_min_page_size(), NULL, VMEM_CREATE_UNCACHED);
  if (!vpp_reg)
  {
    fprintf(stderr, "flashutil: Failed to create virtual mapping to disable FLASH writes - attempting to continue\n");
    return;
  }
  *vpp_reg = 2;
  if (OS21_SUCCESS != vmem_delete((void*)vpp_reg))
  {
    fprintf(stderr, "flashutil: Failed to delete virtual mapping used disable FLASH writes - continuing\n");
  }
}

#endif

#endif

/*
 * Routine to establish if we support the FLASH device that
 * has been found. We scan the table of supported devices
 * looking for a match
 */
static flashDevice_t* getDevice(unsigned int manufacturerID, unsigned int deviceID, unsigned int baseAddress)
{
  flashDevice_t* dev;
  flashDevice_t* devices;
  char* manufacturerName;

          printf("flash --> getDevice MF:%x, DEV:%x\n",manufacturerID,deviceID);
  for (devices = supportedDevices; devices->deviceName; devices++)
  {
    if (deviceID == devices->deviceID)
    {
      switch (manufacturerID)
      {
        case ST_ID16:
        case ST_ID:
          manufacturerName = "STMicroelectronics";
          break;

        case AMD_ID16:
        case AMD_ID:
          manufacturerName = "Spansion||AMD";
          printf("flash type --> Spansion\n");
          break;

        case INTEL_ID16:
        case INTEL_ID:
          manufacturerName = "Intel";
          break;

        case MICRON_ID16:
        case MICRON_ID:
          manufacturerName = "Micron";
          break;
           
            break;
        default:
          manufacturerName = NULL;
          break;
      }

      if (manufacturerName)
      {
        dev = (flashDevice_t*)malloc(sizeof(flashDevice_t));
        if (!dev)
        {
          fprintf(stderr, "\nOut of memory\n");
          exit(1);
        }

        *dev = *devices;
        dev->manufacturerName = manufacturerName;
        dev->baseAddress = baseAddress;

        return dev;
      }
    }
  }

  return NULL;
}

/*
 * Routine to probe a FLASH in the style used by AMD FLASHes
 * 16 bit bus version
 */
static void identifyAMDStyle16(unsigned int baseAddress, unsigned int* deviceID, unsigned int* manufacturerID)
{
  volatile unsigned short* command1Ptr;
  volatile unsigned short* command2Ptr;
  volatile unsigned short* manufactureIDPtr;
  volatile unsigned short* deviceIDPtr;

  command1Ptr = (volatile unsigned short*)physToUncachedFlashAddr(baseAddress + 0xAAAA);
  command2Ptr = (volatile unsigned short*)physToUncachedFlashAddr(baseAddress + 0x1554);
  manufactureIDPtr = (volatile unsigned short*)physToUncachedFlashAddr(baseAddress);
  deviceIDPtr = (volatile unsigned short*)physToUncachedFlashAddr(baseAddress + 2);

  /*
   * Generate AMD type sequence to get Flash ID
   */
  *command1Ptr = 0x00AA; /* Auto select command */
  *command2Ptr = 0x0055;
  *command1Ptr = 0x0090;

  *manufacturerID = *manufactureIDPtr;
  *deviceID = *deviceIDPtr;
}

/*
 * Routine to probe a FLASH device CFI style
 * 16 bit bus version
 */
static void identifyCFIStyle16(unsigned int baseAddress, unsigned int* deviceID, unsigned int* manufacturerID)
{
  volatile unsigned short* manufactureIDPtr;
  volatile unsigned short* deviceIDPtr;

  manufactureIDPtr = (volatile unsigned short*)physToUncachedFlashAddr(baseAddress);
  deviceIDPtr = (volatile unsigned short*)physToUncachedFlashAddr(baseAddress + 2);

  *manufactureIDPtr = 0;
  *manufactureIDPtr = (unsigned short)CMD_READ_ESIG16;

  *manufacturerID = *manufactureIDPtr;
  *deviceID = *deviceIDPtr;
}

/*
 * Routine to probe a FLASH in the style used by AMD FLASHes
 * 32 bit bus version
 */
static void identifyAMDStyle(unsigned int baseAddress, unsigned int* deviceID, unsigned int* manufacturerID)
{
  volatile unsigned int* command1Ptr;
  volatile unsigned int* command2Ptr;
  volatile unsigned int* manufactureIDPtr;
  volatile unsigned int* deviceIDPtr;

  command1Ptr = (volatile unsigned int*)physToUncachedFlashAddr(baseAddress + 0x1554);
  command2Ptr = (volatile unsigned int*)physToUncachedFlashAddr(baseAddress + 0x2AA8);
  manufactureIDPtr = (volatile unsigned int*)physToUncachedFlashAddr(baseAddress);
  deviceIDPtr = (volatile unsigned int*)physToUncachedFlashAddr(baseAddress + 4);

  /*
   * Generate AMD type sequence to get Flash ID
   */
  *command1Ptr = 0x00AA00AA; /* Auto select command */
  *command2Ptr = 0x00550055;
  *command1Ptr = 0x00900090;

  *manufacturerID = *manufactureIDPtr;
  *deviceID = *deviceIDPtr;

}

static void identifySpanionStyle(unsigned int baseAddress, unsigned int* deviceID, unsigned int* manufacturerID)
{
  volatile unsigned int* command1Ptr;
  volatile unsigned int* command2Ptr;
  volatile unsigned int* manufactureIDPtr;
  volatile unsigned int* deviceIDPtr;

  command1Ptr = (volatile unsigned int*)physToUncachedFlashAddr(baseAddress + 0x5555);
  command2Ptr = (volatile unsigned int*)physToUncachedFlashAddr(baseAddress + 0x2AAA);
  manufactureIDPtr = (volatile unsigned int*)physToUncachedFlashAddr(baseAddress);
  deviceIDPtr = (volatile unsigned int*)physToUncachedFlashAddr(baseAddress + 1);

  /*
   * Generate AMD type sequence to get Flash ID
   */
  *command1Ptr = 0xAAAA; /* Auto select command */
  *command2Ptr = 0x5555;
  *command1Ptr = 0x9090;

  *manufacturerID = *manufactureIDPtr;
  *deviceID = *deviceIDPtr;
}

/*
 * Routine to probe a FLASH device CFI style
 * 32 bit bus version
 */
static void identifyCFIStyle(unsigned int baseAddress, unsigned int* deviceID, unsigned int* manufacturerID)
{
  volatile unsigned int* command1Ptr;
  volatile unsigned int* command2Ptr;
  volatile unsigned int* manufactureIDPtr;
  volatile unsigned int* deviceIDPtr;

  command1Ptr = (volatile unsigned int*)physToUncachedFlashAddr(baseAddress + 0x1554);
  command2Ptr = (volatile unsigned int*)physToUncachedFlashAddr(baseAddress + 0x2AA8);
  manufactureIDPtr = (volatile unsigned int*)physToUncachedFlashAddr(baseAddress);
  deviceIDPtr = (volatile unsigned int*)physToUncachedFlashAddr(baseAddress + 4);

  *command1Ptr = 0;
  *command2Ptr = CMD_READ_ESIG;
  *manufacturerID = *manufactureIDPtr;
  *deviceID = *deviceIDPtr;
}

/*
 ********************************************************************
 *
 *  PUBLIC ENTRY POINTS FOLLOW
 *
 * Routine to calculate a 32-bit CRC over a range of data
 */
unsigned int flashCalcCRC(unsigned int* pdata, unsigned int size)
{
  unsigned int crc = 0xFFFFFFFF;
  unsigned int i;

  for (i = 0; i < size; i++)
  {
    int j;
    unsigned int prev, this;
    unsigned int val = *pdata++;

    prev = crc;

    for (j = 0; j < 32; j++)
    {
      this = ((prev << 1) + ((val & 0x80000000) ? 1 : 0)) ^ ((prev & 0x80000000) ? CRC_POLY : 0);
      val <<= 1;
      prev = this;
    }
    crc = this;
  }

  return crc ^ 0xFFFFFFFF;
}

/*
 * Entry point to return board customisation data
 * Returns NULL if board is not known
 */
flashTarget_t* flashGetTarget(char* ptr)
{
  flashTarget_t* target = NULL;

  if (ptr)
  {
    for (target = supportedTargets; target->name; target++)
    {
      if (!strcmp(target->name, ptr))
      {
        return target;
      }
    }
    target = NULL;
  }

  return target;
}

/*
 * Entry point to return an array of strings listing the
 * supported targets.
 */
const char** flashGetTargetNameList(void)
{
  static const char** targetNameList = NULL;

  if (!targetNameList)
  {
    int targetNameListSize = sizeof(supportedTargets) / sizeof(supportedTargets[0]);

    targetNameList = malloc(sizeof(char*) * targetNameListSize);

    if (!targetNameList)
    {
      fprintf(stderr, "\nOut of memory\n");
      exit(1);
    }

    while (targetNameListSize-- > 0)
    {
        targetNameList[targetNameListSize] = supportedTargets[targetNameListSize].name;
    }
  }

  return targetNameList;
}

/*
 * Entry point to return a string containing a space separated
 * list of supported targets.
 */
const char* flashGetTargetNames(void)
{
  static char* targetNames = NULL;

  if (!targetNames)
  {
    int targetNamesSize = 0;
    const char** targetNamesList = NULL;

    for (targetNamesList = flashGetTargetNameList(); targetNamesList && *targetNamesList; targetNamesList++)
    {
      int oldTargetNamesSize = targetNamesSize;

      targetNames = realloc(targetNames, targetNamesSize += strlen(*targetNamesList) + 1);

      if (!targetNames)
      {
        fprintf(stderr, "\nOut of memory\n");
        exit(1);
      }

      if (oldTargetNam