skyeye_flash.c

skyeye-1.0.0.rar surce code

    case WSM_WRITE_BUFFER:
      if (pb_count == 0)
	{			/* step 1: get count */
	  pb_count = (data & 0xff) + 1;
	  progbuf_latch_addr = addr;
	  if (pb_count > INTEL_WRITEBUFFER_SIZE)
	    {
	      program_setlb_error = erase_clearlb_error = 1;
	      wsm_mode = WSM_READY;
	      printf ("\nFlash: buffer program count too large: %d",
		      pb_count);
	      break;
	    }
	  if (SECTOR_ADDR (addr) != SECTOR_ADDR (addr + pb_count - 1))
	    {
	      program_setlb_error = erase_clearlb_error = 1;
	      wsm_mode = WSM_READY;
	      printf
		("\nFlash: buffer program address range across sectors: 0x%x-0x%x",
		 addr, addr + pb_count - 1);
	      break;
	    }
	  break;
	}
      if (pb_loaded < pb_count)
	{			/* step 2: load data */
	  if (SECTOR_ADDR (addr) != SECTOR_ADDR (progbuf_latch_addr))
	    {
	      program_setlb_error = erase_clearlb_error = 1;
	      wsm_mode = WSM_READY;
	      printf ("\nFlash: buffer program address across sectors: 0x%x",
		      addr);
	      break;
	    }
	  if (pb_loaded == 0)
	    pb_start = addr;
	  pb_buf[WORD_ADDR (addr) & INTEL_WRITEBUFFER_MASK] = data;
	  pb_loaded++;
	  break;
	}
      if ((data & 0xff) == WSM_CONFIRM)
	{			/* step 3: confirm the program */
	  progbuf_busy = 1;
	  read_mode = WSM_READ_STATUS;
	  /* copy buffer to flash */
	  if (ISLOCKED (progbuf_latch_addr))
	    {
	      printf ("\nFlash: buffer program locked address [0x%x]",
		      progbuf_latch_addr);
	      program_setlb_error = protection_error = 1;
	    }
	  else if (DEVICE_SUSPENDED)
	    {
	      printf ("\nFlash: buffer program suspended device");
	      program_setlb_error = 1;
	    }
	  else if (vpen != 1)
	    {
	      printf ("\nFlash: can't buffer program when VPEN low");
	      program_setlb_error = program_volt_error = 1;
	    }
	  else
	    {
	      for (j = WORD_ADDR (pb_start);
		   j < WORD_ADDR (pb_start) + INTEL_WRITEBUFFER_SIZE; j++)
		//mem[j] &= pb_buf[j & INTEL_WRITEBUFFER_MASK];
		real_write_word (state, j,
				 real_read_word (state,
						 j) & pb_buf[j &
							     INTEL_WRITEBUFFER_MASK]);
	    }
	  wsm_mode = WSM_READY;
	  progbuf_busy = 0;
	  break;
	}
      else
	{
	  printf ("\nFlash: buffer program with wrong cmd sequence: 0x%x",
		  data);
	  program_setlb_error = erase_clearlb_error = 1;
	  wsm_mode = WSM_READY;
	  break;
	}
      break;
    case WSM_PROGRAM:
    case WSM_PROGRAM2:
      program_busy = 1;
      program_latch_addr = addr;
      program_latch_data = data;
      read_mode = WSM_READ_STATUS;
      if (ISLOCKED (program_latch_addr))
	{
	  printf ("\nFlash: program locked address [0x%x]=0x%x", addr, data);
	  program_setlb_error = protection_error = 1;
	}
      else if (ADDR_SUSPENDED (program_latch_addr))
	{
	  printf ("\nFlash: program suspended address [0x%x]=0x%x", addr,
		  data);
	  program_setlb_error = 1;
	}
      else if (vpen != 1)
	{
	  printf ("\nFlash: can't program when VPEN low");
	  program_setlb_error = program_volt_error = 1;
	}
      else
	{
	  //mem[WORD_ADDR(program_latch_addr)] &= data;
	  real_write_word (state, program_latch_addr,
			   real_read_word (state, program_latch_addr) & data);
	}
      program_busy = 0;
      wsm_mode = WSM_READY;
      break;
    case WSM_BLOCK_ERASE:
      if ((data & 0xff) == WSM_CONFIRM)
	{
	  erase_busy = 1;
	  erase_latch_addr = addr & FLASH_SECTOR_MASK;
	  read_mode = WSM_READ_STATUS;
	  if (ISLOCKED (erase_latch_addr))
	    {
	      printf ("\nFlash: erase locked address [0x%x]",
		      erase_latch_addr);
	      erase_clearlb_error = protection_error = 1;
	    }
	  else if (DEVICE_SUSPENDED)
	    {
	      printf ("\nFlash: erase suspended device");
	      erase_clearlb_error = 1;
	    }
	  else if (vpen != 1)
	    {
	      printf ("\nFlash: can't erase when VPEN low\n");
	      erase_clearlb_error = program_volt_error = 1;
	    }
	  else
	    {
	      for (i = 0; i < WORD_ADDR (FLASH_SECTOR_SIZE); i++)
		{
		  //mem[WORD_ADDR(erase_latch_addr)+i] = 0xffffffff;
		  real_write_word (state, erase_latch_addr + i * 4,
				   0xffffffff);
		}
	    }
	  erase_busy = 0;
	  wsm_mode = WSM_READY;
	  break;
	}
      else
	{
	  printf ("\nFlash: erase with wrong cmd sequence: 0x%x", data);
	  wsm_mode = WSM_READY;
	  break;
	}
      break;
    case WSM_LOCK_ACCESS:
      if ((data & 0xff) == 0x01)
	{			/* set lock bit */
	  lock_busy = 1;
	  read_mode = WSM_READ_STATUS;
	  if (DEVICE_SUSPENDED)
	    {
	      printf ("\nFlash: set lock on suspended device");
	      program_setlb_error = 1;
	    }
	  else if (vpen != 1)
	    {
	      printf ("\nFlash: can't set lock when VPEN low");
	      program_setlb_error = program_volt_error = 1;
	    }
	  else
	    {
	      lock[SECTOR_ADDR (addr)] = 1;
	    }
	  lock_busy = 0;
	  wsm_mode = WSM_READY;
	  break;
	}
      else if ((data & 0xff) == WSM_CONFIRM)
	{			/* clear all lock bits */
	  lock_busy = 1;
	  read_mode = WSM_READ_STATUS;
	  if (DEVICE_SUSPENDED)
	    {
	      printf ("\nFlash: clear locks on suspended device");
	      erase_clearlb_error = 1;
	    }
	  else if (vpen != 1)
	    {
	      printf ("\nFlash: can't clear locks when VPEN low");
	      erase_clearlb_error = program_volt_error = 1;
	    }
	  else
	    {
	      for (i = 0; i < size / FLASH_SECTOR_SIZE; i++)
		lock[i] = 0;
	    }
	  lock_busy = 0;
	  wsm_mode = WSM_READY;
	  break;
	}
      else
	{
	  printf ("\nFlash: lock access with wrong cmd sequence: 0x%x", data);
	  wsm_mode = WSM_READY;
	  break;
	}
      break;
    default:
      printf ("\nFlash: Can't recognize WSM mode: 0x%x", wsm_mode);
      break;
    }

}

void
init_querytable ()
{
  int i;
  for (i = 0; i < INTEL_QUERYTABLE_SIZE; i++)
    {
      query[i] = 0;
    }

  /*
   * This is a dump of a real 28F128J3A flash query table 
   * Lines with a "*": different from Verilog model (Ref.2)
   * Lines with a "+": different from the spec (Ref.1)
   */
  query[0x00] = 0x00890089;	//manu. ID
  //query[0x01] = 0x00170017;             //device ID     
  query[0x01] = 0x00180018;	//device ID     
  query[0x02] = 0x00010001;	//?

  query[0x10] = 0x00510051;	//"Q"
  query[0x11] = 0x00520052;	//"R"
  query[0x12] = 0x00590059;	//"Y"

  query[0x13] = 0x00010001;

  query[0x15] = 0x00310031;

  query[0x1b] = 0x00270027;
  query[0x1c] = 0x00360036;
  query[0x1f] = 0x00070007;
  query[0x20] = 0x00070007;
  query[0x21] = 0x000A000A;
  query[0x23] = 0x00040004;
  query[0x24] = 0x00040004;
  query[0x25] = 0x00040004;

  query[0x27] = 0x00180018;	//2^(0x18) = 2^24 = 16MByte 28F128 flash chip size
  //query[0x27] = 0x00170017;

  query[0x28] = 0x00020002;
  query[0x2a] = 0x00050005;	//2^5 = 32 write buffer size
  query[0x2c] = 0x00010001;	//symmetrically-blocked

  query[0x2d] = 0x007F007F;	//[31,16]=?(128KByte) ;[15,0]=block number

  query[0x30] = 0x00020002;

  query[0x31] = 0x00500050;	//"P"
  query[0x32] = 0x00520052;	//"R"
  query[0x33] = 0x00490049;	//"I"

  query[0x34] = 0x00310031;
  query[0x35] = 0x00320032;	// *

  query[0x36] = 0x00CE00CE;	// *

  query[0x3a] = 0x00010001;

  query[0x3b] = 0x00010001;
  query[0x3c] = 0x00010001;

  query[0x3d] = 0x00330033;
  query[0x3f] = 0x00010001;

  query[0x40] = 0x00000000;	// +
  query[0x41] = 0x00010001;	// +
  query[0x42] = 0x00030003;
  query[0x43] = 0x00030003;
  query[0x44] = 0x00030003;
}

/*
// ywc 2005-02-02
//inline void set_vpen() { vpen = 1; }
//inline void clear_vpen() { vpen = 0; }
void Intel28F128J3A_flash_set_vpen(ARMul_State *state){
	vpen = 1; 
}

void Intel28F128J3A_flash_clear_vpen(ARMul_State *state){
	vpen = 0; 
}
*/