Ejemplo n.º 1
0
uint32_t program( uint32_t *address, uint32_t *buffer )	// size is 256 bytes
{
	uint32_t i ;

	if ( (uint32_t) address >= 0x08008000 )
	{
		return 1 ;
	}

	if ( (uint32_t) address == 0x08000000 )
	{
		eraseSector( 0 ) ;
	}
	if ( (uint32_t) address == 0x08004000 )
	{
		eraseSector( 1 ) ;
	}
	// Now program the 256 bytes
	 
  for (i = 0 ; i < 64 ; i += 1 )
  {
    /* Device voltage range supposed to be [2.7V to 3.6V], the operation will
       be done by word */ 
    
	  // Wait for last operation to be completed
		waitFlashIdle() ;
  
    FLASH->CR &= CR_PSIZE_MASK;
    FLASH->CR |= FLASH_PSIZE_WORD;
    FLASH->CR |= FLASH_CR_PG;
  
    *address = *buffer ;
        
		__disable_irq() ;
    /* Wait for operation to be completed */
		waitFlashIdle() ;
    FLASH->CR &= (~FLASH_CR_PG);
		__enable_irq() ;
		 
		 /* Check the written value */
    if ( *address != *buffer )
    {
      /* Flash content doesn't match SRAM content */
      return 2 ;
    }
    /* Increment FLASH destination address */
    address += 1 ;
		buffer += 1 ;
  }
  return 0 ;
}
Ejemplo n.º 2
0
void writeFlash(uint32_t *address, uint32_t *buffer) // page size is 256 bytes
{
  if ((uint32_t) address == 0x08000000) {
    eraseSector(0);
  }
  else if ((uint32_t) address == 0x08004000) {
    eraseSector(1);
  }
  else if ((uint32_t) address == 0x08008000) {
    eraseSector(2);
  }
  else if ((uint32_t) address == 0x0800C000) {
    eraseSector(3);
  }
  else if ((uint32_t) address == 0x08010000) {
    eraseSector(4);
  }
  else if ((uint32_t) address == 0x08020000) {
    eraseSector(5);
  }
  else if ((uint32_t) address == 0x08040000) {
    eraseSector(6);
  }
  else if ((uint32_t) address == 0x08060000) {
    eraseSector(7);
  }

  for (uint32_t i=0; i<FLASH_PAGESIZE/4; i++) {
    /* Device voltage range supposed to be [2.7V to 3.6V], the operation will
     be done by word */

    // Wait for last operation to be completed
    waitFlashIdle();

    FLASH->CR &= CR_PSIZE_MASK;
    FLASH->CR |= FLASH_PSIZE_WORD;
    FLASH->CR |= FLASH_CR_PG;

    *address = *buffer;

    /* Wait for operation to be completed */
    waitFlashIdle();
    FLASH->CR &= (~FLASH_CR_PG);

    /* Check the written value */
    if (*address != *buffer) {
      /* Flash content doesn't match SRAM content */
      return;
    }
    /* Increment FLASH destination address */
    address += 1;
    buffer += 1;
  }
}
Ejemplo n.º 3
0
/**
 * Erase all sectors of all chips.
 *
 * return 1 for success, 0 for failure
 */
uint8_t eraseAll(void)
{
    uint8_t nBank;
    uint8_t nChip;

    for (nChip = 0; nChip < 2; ++nChip)
    {
        // erase 64 kByte = 8 banks at once (29F040)
        for (nBank = 0; nBank < FLASH_NUM_BANKS; nBank
                += FLASH_BANKS_ERASE_AT_ONCE)
        {
            if (!eraseSector(nBank, nChip))
                return 0;
        }
    }

    return 1;
}
Ejemplo n.º 4
0
/** @brief Writes a sector from memory to a sector in flash
 *
 * Uses writeWord to write a 1k block from sourceAddress(RAM) to
 * flashDestinationAddress, one word at a time. Give it the starting memory
 * address and the destination flash address. Both addresses will be
 * incremented by 1 word after a successful writeWord, until the whole 1024
 * byte sector has been written.  Before any writing occurs eraseSector is
 * called to make sure the destination is blank.
 *
 * @author Sean Keys
 *
 * @param RPage the page of RAM the RAMSourceAddress is located
 * @param RAMSourceAddress the address of the source data
 * @param PPage the page of flash where your flashDestinationAddress is located
 * @param flashDestinationAddress where your data will be written to in flash
 *
 * @return an error code. Zero means success, anything else is a failure.
 */
unsigned short writeSector(unsigned char RPage, unsigned short* RAMSourceAddress, unsigned char PPage , unsigned short* flashDestinationAddress){

	if(((unsigned short)flashDestinationAddress % FLASHSECTORSIZE) != 0){
		return ADDRESS_NOT_SECTOR_ALIGNED;
	}

	if(((unsigned short)flashDestinationAddress) < 0x4000){
		return ADDRESS_NOT_FLASH_REGION;
	}

	/// @todo TODO Decide if we need to disable interrupts since we are manually setting Flash/RAM pages.
	eraseSector((unsigned char)PPage, (unsigned short*)flashDestinationAddress);  /* First Erase our destination block */

	unsigned short wordCount = FLASHSECTORSIZEINWORDS;

	/* Save pages */
	unsigned char currentRPage = RPAGE;
	unsigned char currentPPage = PPAGE;

	/* Switch pages */
	RPAGE = RPage;
	PPAGE = PPage;

	while (wordCount > 0)
	{
		unsigned short sourceData = *RAMSourceAddress; /*Convert the RAMAddr to data(dereference) */
		unsigned short errorID = writeWord(flashDestinationAddress, sourceData);
		if(errorID != 0){
			return errorID;
		}
		RAMSourceAddress++;
		flashDestinationAddress++;
		wordCount--; /* Decrement our word counter */
	}

	/* Restore pages */
	RPAGE = currentRPage;
	PPAGE = currentPPage;
	// @todo TODO verify the write? necessary??
	return 0;
}
Ejemplo n.º 5
0
/** @brief Writes a sector from memory to a sector in flash
 *
 * Uses writeWord to write a 1k block from sourceAddress(RAM) to
 * flashDestinationAddress, one word at a time. Give it the starting memory
 * address and the destination flash address. Both addresses will be
 * incremented by 1 word after a successful writeWord, until the whole 1024
 * byte sector has been written.  Before any writing occurs eraseSector is
 * called to make sure the destination is blank.
 *
 * @author Sean Keys
 *
 * @param RPage the page of RAM the RAMSourceAddress is located
 * @param RAMSourceAddress the address of the source data
 * @param PPage the page of flash where your flashDestinationAddress is located
 * @param flashDestinationAddress where your data will be written to in flash
 *
 * @return an error code. Zero means success, anything else is a failure.
 */
unsigned short writeSector(unsigned char RPage, unsigned short* RAMSourceAddress, unsigned char PPage , unsigned short* flashDestinationAddress){

	if(((unsigned short)flashDestinationAddress % flashSectorSize) != 0){
			return addressNotSectorAligned;
	}

	if(((unsigned short)flashDestinationAddress) < 0x4000){
		return addressNotFlashRegion;
	}

	/// @todo TODO Decide if we need to disable interrupts since we are manually setting Flash/RAM pages.
	eraseSector((unsigned char)PPage, (unsigned short*)flashDestinationAddress);  /* First Erase our destination block */

	unsigned short wordCount = flashSectorSizeInWords;

	/* Save pages */
	unsigned char currentRPage = RPAGE;
	unsigned char currentPPage = PPAGE;

	/* Switch pages */
	RPAGE = RPage;
	PPAGE = PPage;

	while (wordCount > 0)
	{
    	unsigned short sourceData = *RAMSourceAddress; /*Convert the RAMAddr to data(dereference) */
    	unsigned short errorID = writeWord(flashDestinationAddress, sourceData);
        if(errorID != 0){
			return errorID;
		}
		RAMSourceAddress++;
		flashDestinationAddress++;
	 	wordCount--; /* Decrement our word counter */
	}

	/* Restore pages */
	RPAGE = currentRPage;
	PPAGE = currentPPage;
	return 0;
}
Ejemplo n.º 6
0
/**
 * Write a block of 256 bytes to the flash.
 * The whole block must be located in one bank and in one flash chip.
 * If the flash block has an unknown state, erase it.
 *
 * return 1 for success, 0 for failure
 */
uint8_t __fastcall__ flashWriteBlock(uint8_t nBank, uint8_t nChip,
                                     uint16_t nOffset, uint8_t* pBlock)
{
    uint16_t rv;
    uint8_t* pDest;
    uint8_t* pNormalBase;

    utilStr[0] = 0;
    utilAppendFlashAddr(nBank, nChip, nOffset);
    setStatus(utilStr);

    if (progressGetStateAt(nBank, nChip) == PROGRESS_UNTOUCHED)
    {
        if (!eraseSector(nBank, nChip))
        {
            screenPrintSimpleDialog(apStrEraseFailed);
            return 0;
        }
    }

    eapiSetBank(nBank);
    pNormalBase = apNormalRomBase[nChip];

    // when we write, we have to use the Ultimax address space
    pDest = apUltimaxRomBase[nChip] + nOffset;

    progressSetBankState(nBank, nChip, PROGRESS_WRITING);
    rv = eapiGlueWriteBlock(pDest, pBlock);
    if (rv != 0x100)
    {
         progressSetBankState(nBank, nChip, PROGRESS_UNTOUCHED);
         screenPrintSimpleDialog(apStrFlashWriteFailed);
         return 0;
    }

    progressSetBankState(nBank, nChip, PROGRESS_PROGRAMMED);
    return 1;
}
Ejemplo n.º 7
0
void main(void)
{
  uint8_t  *pBuff;
  uint32_t addr, burst, pageMask, byteCount;

  /* Relocate vector table */
  SCB->VTOR = 0x20000000;
    
  /* Disable interrupts */
  __disable_irq();
  
  /* Signal setup */
  state.flashLoaderStatus = FLASHLOADER_STATUS_NOT_READY;
  state.debuggerStatus = DEBUGGERCMD_NOT_CONNECTED;

  /* Get device info including memory size */
  setupEFM32();
  
  /* Calculate size of available buffers. Two buffers are
   * used. Each buffer will  fill up half of the remaining RAM. 
   * Round down to nearest word boundry */
  state.bufferSize = (state.sramSize - ((uint32_t) &flashBuffer - 0x20000000)) / 2;
  
  /* Only use full 4 bytes (1 word) */
  state.bufferSize = state.bufferSize & 0xFFFFFFFC;
   
  /* Set the address of both buffers  */
  state.bufferAddress1 = (uint32_t) &flashBuffer;
  state.bufferAddress2 = ((uint32_t) &flashBuffer) + state.bufferSize;

  /* Signal setup complete. Ready to accept commands from programmer. */
  state.flashLoaderStatus = FLASHLOADER_STATUS_READY;

  /* Poll debuggerStatus field to listen for commands
   * from programmer */
  while(1)
  {
    
    /* Erase page(s) command */
    if (state.debuggerStatus == DEBUGGERCMD_ERASE_PAGE)
    {
      /* Clear the flag to indicate that we are busy */
      state.flashLoaderStatus = FLASHLOADER_STATUS_NOT_READY;
      state.debuggerStatus = DEBUGGERCMD_NONE;

      /* Enable flash writes */
      MSC->WRITECTRL |= MSC_WRITECTRL_WREN;
      
      /* Get address of first page to erase */
      uint32_t writeAddress = state.writeAddress1;
      
      /* Erase all pages in the given range */
      for (addr = writeAddress; addr < writeAddress + state.numBytes1; addr += state.pageSize)
      {
        eraseSector( addr, state.pageSize );
      }
      
      /* Disable flash writes */
      MSC->WRITECTRL &= ~MSC_WRITECTRL_WREN;

      /* Operation complete. Set flag to ready again. */
      state.flashLoaderStatus = FLASHLOADER_STATUS_READY;
    }
    
    /* Mass erase command */
    if (state.debuggerStatus == DEBUGGERCMD_MASS_ERASE)
    {
      /* Clear the flag to indicate that we are busy */
      state.flashLoaderStatus = FLASHLOADER_STATUS_NOT_READY;
      state.debuggerStatus = DEBUGGERCMD_NONE;

      /* Enable flash writes */
      MSC->WRITECTRL |= MSC_WRITECTRL_WREN;
      
      /* Unlock Mass Erase */
      MSC->MASSLOCK = 0x631A;
      
      /* Erase entire flash */
      doFlashCmd(MSC_WRITECMD_ERASEMAIN0 | MSC_WRITECMD_ERASEMAIN1);
      
      /* Reset lock */
      MSC->MASSLOCK = 0;
      
      /* Disable flash writes again */
      MSC->WRITECTRL &= ~MSC_WRITECTRL_WREN;

      /* Operation complete. Set flag to ready again. */
      state.flashLoaderStatus = FLASHLOADER_STATUS_READY;
    }
    

    /* Write command */
    if (state.debuggerStatus == DEBUGGERCMD_WRITE_DATA1 || state.debuggerStatus == DEBUGGERCMD_WRITE_DATA2 )
    {
      /* Select buffer based on write command */
      bool useBuffer1 = state.debuggerStatus == DEBUGGERCMD_WRITE_DATA1 ? true : false;
      
      /* Clear the flag to indicate that we are busy */
      state.flashLoaderStatus = FLASHLOADER_STATUS_NOT_READY;
      state.debuggerStatus = DEBUGGERCMD_NONE;

      pageMask  = ~(state.pageSize - 1);
      
      /* Set up buffer, size and destination */
      pBuff     = useBuffer1 ? (uint8_t *)state.bufferAddress1 : (uint8_t *)state.bufferAddress2;
      byteCount = useBuffer1 ? state.numBytes1                 : state.numBytes2;
      addr      = useBuffer1 ? state.writeAddress1             : state.writeAddress2;

      /* Enable flash writes */
      MSC->WRITECTRL |= MSC_WRITECTRL_WREN;

      /* Use double word writes if available */
      if ( ( byteCount > 7 ) && writeDouble )
      {
        if ( addr & 7 )   /* Start address not on 8 byte boundary ? */
        {
          pgmWord( addr, *(uint32_t*)pBuff );
          pBuff     += 4;
          addr      += 4;
          byteCount -= 4;
        }

        /* Enable double word writes */
        MSC->WRITECTRL |= MSC_WRITECTRL_WDOUBLE;
        
        /* Writes as many words as possible using double word writes */
        while ( byteCount > 7 )
        {         
          /* Max burst len is up to next flash page boundary. */
          burst = MIN( byteCount, ( ( addr + state.pageSize ) & pageMask ) - addr );
 
          /* Write data to flash */
          burst -= pgmBurstDouble( addr, (uint32_t*)pBuff, burst );

          pBuff     += burst;
          addr      += burst;
          byteCount -= burst;
        }
        
        /* Wait until operations are complete */
        mscStatusWait( MSC_STATUS_BUSY, 0 );
        
        /* Disable double word writes */
        MSC->WRITECTRL &= ~MSC_WRITECTRL_WDOUBLE;
      }

      /* Writes all remaining bytes */
      while ( byteCount )
      {
        /* Max burst len is up to next flash page boundary. */
        burst = MIN( byteCount, ( ( addr + state.pageSize ) & pageMask ) - addr );

        /* Write data to flash */
        pgmBurst( addr, (uint32_t*)pBuff, burst );

        pBuff     += burst;
        addr      += burst;
        byteCount -= burst;
      }
      
      /* Wait until operations are complete */
      mscStatusWait( MSC_STATUS_BUSY, 0 );

      /* Disable flash writes */
      MSC->WRITECTRL &= ~MSC_WRITECTRL_WREN;

      /* Operation complete. Set flag to ready again. */
      state.flashLoaderStatus = FLASHLOADER_STATUS_READY;
    }
  }
}
Ejemplo n.º 8
0
int main(void)
{
	sysInfo = 0;
	
	SCS |= 0x01;
	FIODIR0 |= ((1<<21) | (1<<4) | (1<<11) | (1<<6) | (1<<23) | (1<<19) | (1<<17));
	FIODIR0 |= (1<<12);
	FIOSET0 |= (1<<12);
	xx = 0x00;

	setSpeed(SPEED_30);

	lcd_init(0);
	serial_init();

	startTimerIRQ();
	startADC();

	initKeys();

	initSound();
	startSoundIRQ();

	initIR();
	startIrIRQ();

    RF_init();
    startcc1100IRQ();
	enableWOR();
	
	initRTC();
	startRtcIRQ();
	
	enableIRQ();

	testmenu_init();
	init_menu();
	
	initBacklight();

	oldkeys[0] = keys[0];
	oldkeys[1] = keys[0];

	key_state = KEY_IDLE;

	set_font(BOLDFONT);
	
	BFS_Mount();
	load_RC_setting();
	load_RF_setting();
	load_setting();
	
	{
		struct RAWset_ RAWset;
        unsigned char x;
        unsigned long RAWcmdbase;
        
        RAWcmdbase = FLASH1_BASE +(secaddr[0]<<1);
        x=memcmp((void*)RAWcmdbase,"RC01",4);
		
        if(!x) {
               
				memcpy(&RAWset,(void *)RAWcmdbase,sizeof(struct RAWset_));
				RAWset.name[7] = 0;
				BFS_SaveFile(BFS_ID_RAWslot0, sizeof(struct RAWset_), (unsigned char*) &RAWset);
				eraseSector(1,0);
        }
	}
	
	if (EncIsValid(irDevTab.device[irDevTab.active].encoder, irDevTab.device[irDevTab.active].set)) {
		setEncoder(irDevTab.device[irDevTab.active].encoder, irDevTab.device[irDevTab.active].set);
	}	
	
	drawMainscreen();
	ask_for_time(0);
	
						
/*
	playSound((unsigned char*)sound1_data, sound1_len);
	waitSound();
	playSound((unsigned char*)sound2_data, sound2_len);
*/

	while (1)
	{
		if(keys[0] != oldkeys[0] || keys[1] != oldkeys[1])
		{
			oldkeys[0] = keys[0];
			oldkeys[1] = keys[1];
			sysInfo |= 0x40;
		}

		switch(key_state)
		{
			case KEY_IDLE:
				if(sysInfo & 0x40)
				{
					sysInfo &= 0xBF;
					if(KEY_Betty)
					{
						setBacklight(BL_AUTO);
						menu_exec(&mainMenu);
						if (EncIsValid(irDevTab.device[irDevTab.active].encoder, irDevTab.device[irDevTab.active].set)) {
							setEncoder(irDevTab.device[irDevTab.active].encoder, irDevTab.device[irDevTab.active].set);
						}
						drawMainscreen();
					}
					else if(KEY_2)
					{
						//setSpeed(SPEED_30);
					}
					else if(KEY_3)
					{
						//setSpeed(SPEED_60);
					}
					else  if(KEY_A || KEY_B || KEY_C || KEY_D)
					{
						unsigned char x;
						//playSound((unsigned char*)sound3_data, sound3_len);
						x=0;
						if (KEY_B) x=1;
						if (KEY_C) x=2;
						if (KEY_D) x=3;
						
						if (EncIsValid(irDevTab.device[x].encoder, irDevTab.device[x].set)) {
							setBacklight(BL_AUTO);
							irDevTab.active = x;
							setEncoder(irDevTab.device[x].encoder, irDevTab.device[x].set);
							drawMainscreen();
						}	
					}
/*					else if(KEY_B)
					{
					
					}
					else if(KEY_C)
					{	
//						playSound((unsigned char*)sound1_data, sound1_len);
					}
					else if(KEY_D)
					{	
//						playSound((unsigned char*)sound2_data, sound2_len);
					}*/
					if((keys[0] != 0) || (keys[1] != 0))
						key_state = KEY_PRESS;
				}
				break;
			case KEY_PRESS:
				irSend(getCode());
				key_state = KEY_HOLD;
//				autorepeat = 0;
				break;
			case KEY_HOLD:
//				if(autorepeat >= AUTO_TIMEOUT)
					irRepeat();

				if(keys[0] == 0 && keys[1] == 0)
					key_state = KEY_RELEASE;

				break;
			case KEY_RELEASE:
				irStop();
				key_state = KEY_IDLE;
				break;
		}

		if(serial_tstc() > 0)
		{
			i = serial_getc();
			if(i=='.')
			{
				serial_puts("HELO");
			}
			else if(i=='0')
			{
				setBacklight(0x00);	// pwm value
			}
			else if(i=='1')
			{
				setBacklight(0x1F);	// pwm value
			}
			else if(i=='2')
			{
				setBacklight(0x3F);	// pwm value
			}
			else
				serial_putc(i);
		}
		
		if ((bl_val == 0) && (key_state == KEY_IDLE) && !((FIOPIN0 & (1<<30)) == 0) && (((RFstatus & (WORrxon | RXenabled)) == 0))) {
			EXTINT = 0x08;
			PCON = 0x02;
			PLLFEED = 0xAA;
			PLLFEED = 0x55;
		}
		
		if (timeInfo & timechanged) {
			printTime(86,152,(struct time_ *)&time);
			printDate(0,152,(struct date_ *)&date,0);
			
			timeInfo &= ~timechanged;
		}
		
	}
	return 0;
}