wrt54g.c

wag200 debrick utility.

    printf("Flashing Routine Complete\n");
    printf("=========================\n");

    time(&end_time);
    elapsed_seconds = difftime(end_time, start_time); 
    printf("elapsed time: %d seconds\n", (int)elapsed_seconds);
}


void run_erase(char *filename, unsigned int start, unsigned int length)
{
    time_t start_time = time(0);
    time_t end_time, elapsed_seconds;

    printf("*** You Selected to Erase the %s ***\n\n",filename);

    printf("=========================\n");
    printf("Erasing Routine Started\n");
    printf("=========================\n");

    sflash_erase_area(start,length);
    sflash_reset();

    printf("=========================\n");
    printf("Erasing Routine Complete\n");
    printf("=========================\n");

    time(&end_time);
    elapsed_seconds = difftime(end_time, start_time); 
    printf("elapsed time: %d seconds\n", (int)elapsed_seconds);
}


void identify_flash_part(void)
{
   flash_chip_type*   flash_chip = flash_chip_list;
   flash_area_type*   flash_area = flash_area_list;

   // Important for these to initialize to zero
   block_addr  = 0;
   block_total = 0;
   flash_size  = 0;
   cmd_type    = 0;
   strcpy(flash_part,"");

   // Funky AMD Chip
   if (((vendid & 0x00ff) == 0x0001) && (devid == 0x227E))  devid = ejtag_read_h(FLASH_MEMORY_START+0x1E);  // Get real devid

   while (flash_chip->vendid)
   {
      if ((flash_chip->vendid == vendid) && (flash_chip->devid == devid))
      {
         flash_size = flash_chip->flash_size & 0xfffff0;
         cmd_type   = flash_chip->cmd_type;
         strcpy(flash_part, flash_chip->flash_part);

         if (flash_size >= size8MB) FLASH_MEMORY_START = 0x1C000000;
	 else if (flash_chip->flash_size == size4bMB) 
	    {
	    FLASH_MEMORY_START = 0x90000000;
	    }
         else FLASH_MEMORY_START = 0x1FC00000;

         while (flash_area->chip_size)
         {
            if ((flash_area->chip_size == flash_chip->flash_size) && (strcasecmp(flash_area->area_name, AREA_NAME)==0))
            {
               strcat(AREA_NAME,".BIN");
               AREA_START  = flash_area->area_start;
               AREA_LENGTH = flash_area->area_length;
               break;
            }
            flash_area++;
         }
         
         if (strcasecmp(AREA_NAME,"CUSTOM")==0)
         {
            strcat(AREA_NAME,".BIN");
            FLASH_MEMORY_START = selected_window;
            AREA_START         = selected_start;
            AREA_LENGTH        = selected_length;
         }

         if (flash_chip->region1_num)  define_block(flash_chip->region1_num, flash_chip->region1_size);
         if (flash_chip->region2_num)  define_block(flash_chip->region2_num, flash_chip->region2_size);
         if (flash_chip->region3_num)  define_block(flash_chip->region3_num, flash_chip->region3_size);
         if (flash_chip->region4_num)  define_block(flash_chip->region4_num, flash_chip->region4_size);

         sflash_reset();

         printf("Done\n\n");
         printf("Flash Vendor ID: ");  ShowData(vendid);
         printf("Flash Device ID: ");  ShowData(devid);
         if (selected_fc != 0)
            printf("*** Manually Selected a %s Flash Chip ***\n\n", flash_part);
         else
            printf("*** Found a %s Flash Chip ***\n\n", flash_part);

         printf("    - Flash Chip Window Start .... : %08x\n", FLASH_MEMORY_START);
         printf("    - Flash Chip Window Length ... : %08x\n", flash_size);
         printf("    - Selected Area Start ........ : %08x\n", AREA_START);
         printf("    - Selected Area Length ....... : %08x\n\n", AREA_LENGTH);
         
         break;
      }
      flash_chip++;
   }
}


void define_block(unsigned int block_count, unsigned int block_size)
{
  unsigned int  i;

  if (block_addr == 0)  block_addr = FLASH_MEMORY_START;

  for (i = 1; i <= block_count; i++)
  {
     block_total++;
     blocks[block_total] = block_addr;
     block_addr = block_addr + block_size;
  }
}


void sflash_config(void)
{
   flash_chip_type*   flash_chip = flash_chip_list;
   int counter = 0;

   printf("\nManual Flash Selection ... ");

   while (flash_chip->vendid)
   {
      counter++;
      if (counter == selected_fc)
      {
         vendid = flash_chip->vendid;
         devid  = flash_chip->devid;
         identify_flash_part();
         break;
      }
      flash_chip++;
   }

    if (strcasecmp(flash_part,"")==0)
       printf("*** Unknown or NO Flash Chip Selected ***\n");

}


void sflash_probe(void)
{
   int retries = 300;

    // Default to Standard Flash Window for Detection if not CUSTOM
    if (strcasecmp(AREA_NAME,"CUSTOM")==0)
         FLASH_MEMORY_START = selected_window;
    else FLASH_MEMORY_START = 0x1FC00000;

    printf("\nProbing Flash at (Flash Window: 0x%08x) ... ", FLASH_MEMORY_START);

again:

    strcpy(flash_part,"");

    // Probe using cmd_type for AMD
    if (strcasecmp(flash_part,"")==0)
    {
       cmd_type = CMD_TYPE_AMD;
       sflash_reset();
       ejtag_write_h(FLASH_MEMORY_START + (0x555 << 1), 0x00AA00AA);
       ejtag_write_h(FLASH_MEMORY_START + (0x2AA << 1), 0x00550055);
       ejtag_write_h(FLASH_MEMORY_START + (0x555 << 1), 0x00900090);
       vendid = ejtag_read_h(FLASH_MEMORY_START);
       devid  = ejtag_read_h(FLASH_MEMORY_START+2);
       identify_flash_part();
    }

    // Probe using cmd_type for SST
    if (strcasecmp(flash_part,"")==0)
    {
       cmd_type = CMD_TYPE_SST;
       sflash_reset();
       ejtag_write_h(FLASH_MEMORY_START + (0x5555 << 1), 0x00AA00AA);
       ejtag_write_h(FLASH_MEMORY_START + (0x2AAA << 1), 0x00550055);
       ejtag_write_h(FLASH_MEMORY_START + (0x5555 << 1), 0x00900090);
       vendid = ejtag_read_h(FLASH_MEMORY_START);
       devid  = ejtag_read_h(FLASH_MEMORY_START+2);
       identify_flash_part();
    }

    // Probe using cmd_type for BSC & SCS
    if (strcasecmp(flash_part,"")==0)
    {
       cmd_type = CMD_TYPE_BSC;
       sflash_reset();
       ejtag_write_h(FLASH_MEMORY_START, 0x00900090);
       vendid = ejtag_read_h(FLASH_MEMORY_START);
       devid  = ejtag_read_h(FLASH_MEMORY_START+2);
       identify_flash_part();
    }

    if (strcasecmp(flash_part,"")==0)
    {
       if (retries--)
          goto again;
       else
       {
       	  printf("Done\n\n");
          printf("*** Unknown or NO Flash Chip Detected ***");
       }
    }

    return;
}


void sflash_erase_area(unsigned int start, unsigned int length)
{
    int cur_block;
    int tot_blocks;
    unsigned int reg_start;
    unsigned int reg_end;


    reg_start = start;
    reg_end   = reg_start + length;

    tot_blocks = 0;

    for (cur_block = 1;  cur_block <= block_total;  cur_block++)
    {
       block_addr = blocks[cur_block];
       if ((block_addr >= reg_start) && (block_addr < reg_end))  tot_blocks++;
    }

    printf("Total Blocks to Erase: %d\n\n", tot_blocks);

    for (cur_block = 1;  cur_block <= block_total;  cur_block++)
    {
       block_addr = blocks[cur_block];
       if ((block_addr >= reg_start) && (block_addr < reg_end))
          {
             printf("Erasing block: %d (addr = %08x)...", cur_block, block_addr);  fflush(stdout);
             sflash_erase_block(block_addr);
             printf("Done\n\n");  fflush(stdout);
          }
    }

}


void sflash_erase_block(unsigned int addr)
{

    if (cmd_type == CMD_TYPE_AMD)
    {

        //Unlock Block
        ejtag_write_h(FLASH_MEMORY_START+(0x555 << 1), 0x00AA00AA);
        ejtag_write_h(FLASH_MEMORY_START+(0x2AA << 1), 0x00550055);
        ejtag_write_h(FLASH_MEMORY_START+(0x555 << 1), 0x00800080);

        //Erase Block
        ejtag_write_h(FLASH_MEMORY_START+(0x555 << 1), 0x00AA00AA);
        ejtag_write_h(FLASH_MEMORY_START+(0x2AA << 1), 0x00550055);
        ejtag_write_h(addr, 0x00300030);

        while (ejtag_read_h(addr) != 0xFFFF) {}

    }

    if (cmd_type == CMD_TYPE_SST)
    {

        //Unlock Block
        ejtag_write_h(FLASH_MEMORY_START+(0x5555 << 1), 0x00AA00AA);
        ejtag_write_h(FLASH_MEMORY_START+(0x2AAA << 1), 0x00550055);
        ejtag_write_h(FLASH_MEMORY_START+(0x5555 << 1), 0x00800080);

        //Erase Block
        ejtag_write_h(FLASH_MEMORY_START+(0x5555 << 1), 0x00AA00AA);
        ejtag_write_h(FLASH_MEMORY_START+(0x2AAA << 1), 0x00550055);
        ejtag_write_h(addr, 0x00500050);

        while (ejtag_read_h(addr) != 0xFFFF) {}

    }

    if ((cmd_type == CMD_TYPE_BSC) || (cmd_type == CMD_TYPE_SCS))
    {

        //Unlock Block
        ejtag_write_h(addr, 0x00600060);     // Unlock Flash Block Command
        ejtag_write_h(addr, 0x00D000D0);     // Confirm Command

        //Erase Block
        ejtag_write_h(addr, 0x00200020);     // Block Erase Command
        ejtag_write_h(addr, 0x00D000D0);     // Confirm Command

        while (ejtag_read_h(FLASH_MEMORY_START) != 0x0080) {}

    }

    sflash_reset();

}


void sflash_reset(void)
{

    if ((cmd_type == CMD_TYPE_AMD) || (cmd_type == CMD_TYPE_SST))
    {
        ejtag_write_h(FLASH_MEMORY_START, 0x00F000F0);    // Set array to read mode
    }

    if ((cmd_type == CMD_TYPE_BSC) || (cmd_type == CMD_TYPE_SCS))
    {
        ejtag_write_h(FLASH_MEMORY_START, 0x00500050);    // Clear CSR
        ejtag_write_h(FLASH_MEMORY_START, 0x00ff00ff);    // Set array to read mode
    }

}


void sflash_write_word(unsigned int addr, unsigned int data)
{
unsigned int data_lo, data_hi;

    if (USE_DMA)
    {
    	 // DMA Uses Byte Lanes
       data_lo = data;
       data_hi = data;
    }
    else   
    {
    	 // PrAcc Does Not
       data_lo = (data & 0xFFFF);
       data_hi = ((data >> 16) & 0xFFFF);
    }

    if (cmd_type == CMD_TYPE_AMD)
    {
      // Handle Half Of Word
      ejtag_write_h(FLASH_MEMORY_START+(0x555 << 1), 0x00AA00AA);