Example #1
0
static void Init()
{
	theLoop = new CMessageLoop;
	_Module.AddMessageLoop(theLoop);

	con=0;
//	con = new Console;
	printf("an!\n");

	sdInit();
	msInit();

	printf("loading bank at %08x, size %d\n",presetbank,pbsize);

//	fileM presetbank;
//	printf("open: %d\n",presetbank.open(IDR_BANK1));
//	printf("load: %d\n",sdLoad(presetbank));
//	presetbank.close();

	fileM pb;
	pb.open(presetbank,pbsize);
	printf("load: %d\n",sdLoad(pb));

	printf("start audio\n");
#ifdef RONAN
	msStartAudio(0,soundmem,globals,(const char **)speechptrs);
#else
	msStartAudio(0,soundmem,globals);
#endif	

	printf("done\n");

}
Example #2
0
/**
 * @brief   HAL initialization.
 */
void halInit(void) {

  hal_lld_init();

#if CH_HAL_USE_PAL
  palInit(&pal_default_config);
#endif
#if CH_HAL_USE_ADC
  adcInit();
#endif
#if CH_HAL_USE_CAN
  canInit();
#endif
#if CH_HAL_USE_MAC
  macInit();
#endif
#if CH_HAL_USE_PWM
  pwmInit();
#endif
#if CH_HAL_USE_SERIAL
  sdInit();
#endif
#if CH_HAL_USE_SPI
  spiInit();
#endif
#if CH_HAL_USE_MMC_SPI
  mmcInit();
#endif
}
Example #3
0
/**
 * @brief   HAL initialization.
 * @details This function invokes the low level initialization code then
 *          initializes all the drivers enabled in the HAL. Finally the
 *          board-specific initialization is performed by invoking
 *          @p boardInit() (usually defined in @p board.c).
 *
 * @init
 */
void halInit(void) {

  hal_lld_init();

#if HAL_USE_TM || defined(__DOXYGEN__)
  tmInit();
#endif
#if HAL_USE_PAL || defined(__DOXYGEN__)
  palInit(&pal_default_config);
#endif
#if HAL_USE_ADC || defined(__DOXYGEN__)
  adcInit();
#endif
#if HAL_USE_CAN || defined(__DOXYGEN__)
  canInit();
#endif
#if HAL_USE_EXT || defined(__DOXYGEN__)
  extInit();
#endif
#if HAL_USE_GPT || defined(__DOXYGEN__)
  gptInit();
#endif
#if HAL_USE_I2C || defined(__DOXYGEN__)
  i2cInit();
#endif
#if HAL_USE_ICU || defined(__DOXYGEN__)
  icuInit();
#endif
#if HAL_USE_MAC || defined(__DOXYGEN__)
  macInit();
#endif
#if HAL_USE_PWM || defined(__DOXYGEN__)
  pwmInit();
#endif
#if HAL_USE_SERIAL || defined(__DOXYGEN__)
  sdInit();
#endif
#if HAL_USE_SDC || defined(__DOXYGEN__)
  //KL All in Kl_sdc sdcInit();
#endif
#if HAL_USE_SPI || defined(__DOXYGEN__)
  spiInit();
#endif
#if HAL_USE_UART || defined(__DOXYGEN__)
  uartInit();
#endif
#if HAL_USE_USB || defined(__DOXYGEN__)
  usbInit();
#endif
#if HAL_USE_MMC_SPI || defined(__DOXYGEN__)
  mmcInit();
#endif
#if HAL_USE_SERIAL_USB || defined(__DOXYGEN__)
  sduInit();
#endif
#if HAL_USE_RTC || defined(__DOXYGEN__)
  rtcInit();
#endif
}
Example #4
0
/*
 * Init AT MODE
 */
void init_atmode()
{
  sdInit();
  sdStart(&SD1, &uartCfg1);     //Start Serial Driver 1
  sdStart(&SD2, &uartCfg2);     //Start Serial Driver 2

  chThdCreateStatic(waSend, sizeof(waSend), NORMALPRIO, Send, NULL);
  chThdCreateStatic(waReceive, sizeof(waReceive), NORMALPRIO, Receive, NULL);

  while (TRUE) {
    chThdSleepMilliseconds(500);
  }
}
Example #5
0
void StartDefaultTask(void const * argument) {
    Pin _led(LED_PIN, Pin::Config().setMode(Pin::MODE_OUTPUT));
    led = &_led;
    printf("Initializing SDIO DMA test...\n");
    if (!sdInit()) {
        error("Failed to initialize sdio\n");
        MatchBox::blinkOfDeath(_led, (MatchBox::BlinkCode) SDIO_INIT);
    }
    if (!sdDmaInit()) {
        debug("Failed to initialize sdio dma\n");
        MatchBox::blinkOfDeath(_led, (MatchBox::BlinkCode) SDIO_DMA);
    }

    int count = 0;
    uint8_t buff[512];
    if (uint32_t(&buff[0]) & 0x3 != 0) {
        error("Buffer not aligned!\n");
        MatchBox::blinkOfDeath(_led, (MatchBox::BlinkCode) BUFFER_NOT_ALIGNED);
    }
    bzero(buff, sizeof(buff));

    // Seed with random value
    srand(HAL_GetTick());

    printf("Starting DMA\n");
    while (1) {
        char tmp[sizeof(buff)]; // temporary read buffer, for verification
        for (int i = 0; i < sizeof(buff); i++) {
            buff[i] = rand() & 0xff;
        }
        writeBlock(&buff[0], count * 512);
//        while (0x100 != (SDGetStatus(&uSdHandle) & 0x100))
//            ;
//        printf("read..\n");
        readBlock(&tmp[0], count * 512);
        if (0 != memcmp(tmp, buff, sizeof(buff))) {
            debug("*** readback error: blocks differ! ***\n");
        } else {
            if (!(count % 64)) {
                printf("\n");
                printf("Block %08x", count);
            } else {
                printf(".");
            }
        }
        //dumpBlock(&buff[0], count);
        _led.write(count++ & 1);
    }
}
Example #6
0
DSTATUS disk_initialize (
	BYTE pdrv				/* Physical drive nmuber to identify the drive */
)
{
	DSTATUS stat;
	int result;

	// switch (pdrv) {
	// case DEV_RAM :
	// 	result = RAM_disk_initialize();

	// 	// translate the reslut code here

	// 	return stat;

	// case DEV_MMC :
	// 	result = MMC_disk_initialize();

	// 	// translate the reslut code here

	// 	return stat;

	// case DEV_USB :
	// 	result = USB_disk_initialize();

	// 	// translate the reslut code here

	// 	return stat;
	// }

	stat=sdInit();  //SD card initialization

	if(stat == STA_NODISK)
	{
		return STA_NODISK;
	}
	else if(stat != 0)
	{
		return STA_NOINIT;  
	}
	else
	{
		return 0;           
	}
	
	return STA_NOINIT;
}
Example #7
0
int 
main(int argc, char *argv[]) {

    int stat;
    int slot;

    if(argc>1)
      {
	slot = atoi(argv[1]);
	if(slot<1 || slot>22)
	  {
	    printf("invalid slot... using 21");
	    slot=21;
	  }
      }
    else 
      slot=21;

    printf("\nJLAB TI Status... slot = %d\n",slot);
    printf("----------------------------\n");

    vmeOpenDefaultWindows();

    /* Set the TI structure pointer */
    tiInit((slot<<19),TI_READOUT_EXT_POLL,1);
    tiStatus();

    sdInit();
    sdStatus();

 CLOSE:

    vmeCloseDefaultWindows();

    exit(0);
}
Example #8
0
int main(){

	SD sd;

	init();
	
	if(!sdInit(&sd)) err_str("sd init failed");
	
	if(0){
		#define E(x)	do{printf(x); while(1);}while(0)
		
		UInt32 p, numSec;
		Boolean ret;
		UInt16 i;
		UInt8 v, buf[512];
		
		printf("Performing some basic tests\n");
		numSec = sdGetNumSec(&sd);
		printf(" - card is %ld sectors (%ld MB)\n", numSec, numSec >> 11UL);
		
		ret = sdSecRead(&sd, 0, buf);
		if(!ret) E("card read fails\n");
		
		for(i = 0; i < 512; i++){
		
			if(i & 0x0F) printf(" ");
			else printf("\n%04X ", i);
			printf("%02X", buf[i]);
		}
		printf("\n");
		
		if(numSec > 32UL * 1024UL) numSec = 512;
		
		for(p = 0; p < numSec; p++){
		
			ret = sdSecRead(&sd, p, buf);
			if(!ret) E("card read fails\n");
			
			printf("\r reading %ld/%ld", p, numSec);
			for(i = 0; i < 512; i += 16) ramWrite((p << 9) + i, buf + i, 16);
		}
		printf("\n");
		
		for(p = 0; p < numSec; p++){
		
			ret = sdSecRead(&sd, p, buf);
			if(!ret) E("card read fails\n");
			
			printf("\r verifying %ld/%ld", p, numSec);
			for(i = 0; i < 512; i++){
				
				ramRead((p << 9) + i, &v, 1);
				
				if(v != buf[i]){
			
					printf("fail on sec %ld byte %d RAM=0x%02X SD=0x%02X\n", p, i, v, buf[i]);
					//E("fail");
				}
			}
		}
		
		for(i = 0; i < 512; i++){
		
			UInt8 b[32];
			
			if(!(i & (sizeof(b) - 1))) ramRead(i, b, sizeof(b));
			
			v = b[i & (sizeof(b) - 1)];
		
			if(i & 0x0F) printf(" ");
			else printf("\n%04X ", i);
			printf("%02X", v);
		}
		
		
		while(1);
	}
Example #9
0
/**
 * @brief   HAL initialization.
 * @details This function invokes the low level initialization code then
 *          initializes all the drivers enabled in the HAL. Finally the
 *          board-specific initialization is performed by invoking
 *          @p boardInit() (usually defined in @p board.c).
 *
 * @init
 */
void halInit(void) {

  /* Initializes the OS Abstraction Layer.*/
  osalInit();

  /* Platform low level initializations.*/
  hal_lld_init();

#if (HAL_USE_PAL == TRUE) || defined(__DOXYGEN__)
  palInit(&pal_default_config);
#endif
#if (HAL_USE_ADC == TRUE) || defined(__DOXYGEN__)
  adcInit();
#endif
#if (HAL_USE_CAN == TRUE) || defined(__DOXYGEN__)
  canInit();
#endif
#if (HAL_USE_DAC == TRUE) || defined(__DOXYGEN__)
  dacInit();
#endif
#if (HAL_USE_EXT == TRUE) || defined(__DOXYGEN__)
  extInit();
#endif
#if (HAL_USE_GPT == TRUE) || defined(__DOXYGEN__)
  gptInit();
#endif
#if (HAL_USE_I2C == TRUE) || defined(__DOXYGEN__)
  i2cInit();
#endif
#if (HAL_USE_I2S == TRUE) || defined(__DOXYGEN__)
  i2sInit();
#endif
#if (HAL_USE_ICU == TRUE) || defined(__DOXYGEN__)
  icuInit();
#endif
#if (HAL_USE_MAC == TRUE) || defined(__DOXYGEN__)
  macInit();
#endif
#if (HAL_USE_PWM == TRUE) || defined(__DOXYGEN__)
  pwmInit();
#endif
#if (HAL_USE_SERIAL == TRUE) || defined(__DOXYGEN__)
  sdInit();
#endif
#if (HAL_USE_SDC == TRUE) || defined(__DOXYGEN__)
  sdcInit();
#endif
#if (HAL_USE_SPI == TRUE) || defined(__DOXYGEN__)
  spiInit();
#endif
#if (HAL_USE_UART == TRUE) || defined(__DOXYGEN__)
  uartInit();
#endif
#if (HAL_USE_USB == TRUE) || defined(__DOXYGEN__)
  usbInit();
#endif
#if (HAL_USE_MMC_SPI == TRUE) || defined(__DOXYGEN__)
  mmcInit();
#endif
#if (HAL_USE_SERIAL_USB == TRUE) || defined(__DOXYGEN__)
  sduInit();
#endif
#if (HAL_USE_RTC == TRUE) || defined(__DOXYGEN__)
  rtcInit();
#endif
#if (HAL_USE_WDG == TRUE) || defined(__DOXYGEN__)
  wdgInit();
#endif

  /* Community driver overlay initialization.*/
#if defined(HAL_USE_COMMUNITY) || defined(__DOXYGEN__)
#if (HAL_USE_COMMUNITY == TRUE) || defined(__DOXYGEN__)
  halCommunityInit();
#endif
#endif

  /* Board specific initialization.*/
  boardInit();

/*
 *  The ST driver is a special case, it is only initialized if the OSAL is
 *  configured to require it.
 */
#if OSAL_ST_MODE != OSAL_ST_MODE_NONE
  stInit();
#endif
}
Example #10
0
int main()
{
  uint8_t index = 0;
  uint8_t maxhsize = DISPLAY_CHAR_WIDTH;
  FRESULT fr;
  uint32_t state = ST_START;
  uint32_t nameCount = 0;
  uint32_t vpos = 0;
  uint32_t hpos = 0;

#if defined(PCBTARANIS)
  wdt_reset();
  RCC->AHB1ENR |= RCC_AHB1ENR_GPIOAEN; 		// Enable portA clock
#endif

  pwrInit();

#if defined(PCBSKY9X)
  MATRIX->CCFG_SYSIO |= 0x000000F0L;		// Disable syspins, enable B4,5,6,7
#endif

#if defined(PCBSKY9X)
  init_SDcard();
  PIOC->PIO_PER = PIO_PC25;		// Enable bit C25 (USB-detect)
  start_timer0();
#endif

  lcdInit();
#if defined(PCBSKY9X)
  extern uint8_t OptrexDisplay;
  OptrexDisplay = 1;
#endif
  lcd_clear();
  lcd_putsLeft(0, BOOTLOADER_TITLE);
  lcd_invert_line(0);
  lcdRefresh();
#if defined(PCBSKY9X)
  OptrexDisplay = 0;
  lcdRefresh();
#endif

#if defined(PCBTARANIS)
  keysInit();
  I2C_EE_Init();
  init_hw_timer();
#endif

  __enable_irq();
  init10msTimer();

#if defined(PCBSKY9X)
  EblockAddress = -1;
  init_spi();
#endif

#if defined(PCBSKY9X)
  LockBits = readLockBits();
  if (LockBits) {
    clearLockBits();
  }
#endif

#if defined(PCBTARANIS)
  // SD card detect pin
  sdInit();
  usbInit();
  usbStart();
#endif

  for (;;) {
    wdt_reset();

    if (Tenms) {

      if (EE_timer) {
        if (--EE_timer == 0) {
#if defined(PCBSKY9X)
          writeBlock();
#endif
        }
      }

      Tenms = 0;

      lcd_clear();
      lcd_putsLeft(0, BOOTLOADER_TITLE);
      lcd_invert_line(0);

      uint8_t event = getEvent();

      if (state != ST_USB) {
        if (usbPlugged()) {
          state = ST_USB;
          if (!unlocked) {
            unlocked = 1;
            unlockFlash();
          }
          usbPluggedIn();
        }
      }

      if (state == ST_START) {
        lcd_putsLeft(2*FH, "\010Write Firmware");
        lcd_putsLeft(3*FH, "\010Restore EEPROM");
        lcd_putsLeft(4*FH, "\010Exit");
        lcd_invert_line(2+vpos);
        lcd_putsLeft(7*FH, INDENT "Or plug in a USB cable for mass storage");
        if (event == EVT_KEY_FIRST(BOOT_KEY_DOWN)) {
          vpos == 2 ? vpos = 0 : vpos = vpos+1;
        }
        else if (event == EVT_KEY_FIRST(BOOT_KEY_UP)) {
          vpos == 0 ? vpos = 2 : vpos = vpos-1;
        }
        else if (event == EVT_KEY_BREAK(BOOT_KEY_MENU)) {
          switch (vpos) {
            case 0:
              state = ST_FLASH_MENU;
              break;
            case 1:
              state = ST_RESTORE_MENU;
              break;
            default:
              state = ST_REBOOT;
          }
        }
      }

      if (state == ST_USB) {
        lcd_putsLeft(4*FH, "\026USB Connected");
        if (usbPlugged() == 0) {
          vpos = 0;
          if (unlocked) {
            lockFlash();
            unlocked = 0;
          }
          state = ST_START;
        }
#if defined(PCBSKY9X)
        usbMassStorage();
#endif
      }

      if (state == ST_FLASH_MENU || state == ST_RESTORE_MENU) {
        sdInit();
        memoryType = (state == ST_RESTORE_MENU ? MEM_EEPROM : MEM_FLASH);
        state = ST_DIR_CHECK;
      }

      else if (state == ST_DIR_CHECK) {
        fr = f_chdir(getBinaryPath());
        if (fr == FR_OK) {
          state = ST_OPEN_DIR;
        }
        else {
          lcd_putsLeft(2*FH, INDENT "Directory is missing!");
          if (event == EVT_KEY_BREAK(BOOT_KEY_EXIT) || event == EVT_KEY_BREAK(BOOT_KEY_MENU)) {
            vpos = 0;
            state = ST_START;
          }
        }
      }

      if (state == ST_OPEN_DIR) {
        index = 0;
        fr = f_opendir(&Dj, ".");
        if (fr == FR_OK) {
          state = ST_FILE_LIST;
          nameCount = fillNames(0);
          hpos = 0;
          vpos = 0;
        }
      }

      if (state == ST_FILE_LIST) {
        uint32_t limit = 6;
        if (nameCount < limit) {
          limit = nameCount;
        }
        maxhsize = 0;
        for (uint32_t i=0; i<limit; i++) {
          uint32_t x;
          x = strlen(Filenames[i]);
          if (x > maxhsize) {
            maxhsize = x;
          }
          if (x > DISPLAY_CHAR_WIDTH) {
            if (hpos + DISPLAY_CHAR_WIDTH > x) {
              x = x - DISPLAY_CHAR_WIDTH;
            }
            else {
              x = hpos;
            }
          }
          else {
            x = 0;
          }
          lcd_putsnAtt(INDENT_WIDTH, 16 + FH * i, &Filenames[i][x], DISPLAY_CHAR_WIDTH, 0);
        }

        if (event == EVT_KEY_REPT(BOOT_KEY_DOWN) || event == EVT_KEY_FIRST(BOOT_KEY_DOWN)) {
          if (vpos < limit - 1) {
            vpos += 1;
          }
          else {
            if (nameCount > limit) {
              index += 1;
              nameCount = fillNames(index);
            }
          }
        }
        else if (event == EVT_KEY_REPT(BOOT_KEY_UP) || event == EVT_KEY_FIRST(BOOT_KEY_UP)) {
          if (vpos > 0) {
            vpos -= 1;
          }
          else {
            if (index) {
              index -= 1;
              nameCount = fillNames(index);
            }
          }
        }
#if !defined(PCBTARANIS)
        else if (event == EVT_KEY_REPT(BOOT_KEY_RIGHT) || event == EVT_KEY_FIRST(BOOT_KEY_RIGHT)) {
          if (hpos + DISPLAY_CHAR_WIDTH < maxhsize) {
            hpos += 1;
          }
        }
        else if (event == EVT_KEY_REPT(BOOT_KEY_LEFT) || event == EVT_KEY_FIRST(BOOT_KEY_LEFT)) {
          if (hpos) {
            hpos -= 1;
          }
        }
#endif
        else if (event == EVT_KEY_BREAK(BOOT_KEY_MENU)) {
          // Select file to flash
          state = ST_FLASH_CHECK;
          Valid = 0;
        }
        else if (event == EVT_KEY_FIRST(BOOT_KEY_EXIT)) {
          state = ST_START;
          vpos = 0;
        }

        lcd_invert_line(2 + vpos);
      }

      else if (state == ST_FLASH_CHECK) {
        int result = menuFlashFile(vpos, event);
        FirmwareSize = FileSize[vpos] - BOOTLOADER_SIZE;
        if (result == 0) {
          // canceled
          state = ST_FILE_LIST;
        }
        else if (result == 1) {
          // confirmed
          firmwareAddress = FIRMWARE_ADDRESS + BOOTLOADER_SIZE;
          firmwareWritten = 0;
          eepromAddress = 0;
          eepromWritten = 0;
          state = ST_FLASHING;
        }
      }

      else if (state == ST_FLASHING) {
        // commit to flashing
        lcd_putsLeft(4*FH, "\032Writing...");
        
        if (!unlocked && (memoryType == MEM_FLASH)) {
          unlocked = 1;
          unlockFlash();
        }
        
        int progress;
        if (memoryType == MEM_FLASH) {
          writeFlashBlock();
          firmwareWritten += sizeof(Block_buffer);
          progress = (200*firmwareWritten) / FirmwareSize;
        }
        else {
          writeEepromBlock();
          eepromWritten += sizeof(Block_buffer);
          progress = (200*eepromWritten) / EESIZE;
        }

        lcd_rect( 3, 6*FH+4, 204, 7);
        lcd_hline(5, 6*FH+6, progress, FORCE);
        lcd_hline(5, 6*FH+7, progress, FORCE);
        lcd_hline(5, 6*FH+8, progress, FORCE);

        fr = f_read(&FlashFile, (BYTE *)Block_buffer, sizeof(Block_buffer), &BlockCount);
        if (BlockCount == 0) {
          state = ST_FLASH_DONE; // EOF
        }
        if (firmwareWritten >= FLASHSIZE - BOOTLOADER_SIZE) {
          state = ST_FLASH_DONE; // Backstop
        }
        if (eepromWritten >= EESIZE) {
          state = ST_FLASH_DONE; // Backstop
        }
      }

      if (state == ST_FLASH_DONE) {
        if (unlocked) {
          lockFlash();
          unlocked = 0;
        }
        lcd_putsLeft(4*FH, "\024Writing Complete");
        if (event == EVT_KEY_FIRST(BOOT_KEY_EXIT) || event == EVT_KEY_BREAK(BOOT_KEY_MENU)) {
          state = ST_START;
          vpos = 0;
        }
      }

      if (event == EVT_KEY_LONG(BOOT_KEY_EXIT)) {
        state = ST_REBOOT;
      }

      lcdRefresh();

      if (PowerUpDelay < 20) {	// 200 mS
        PowerUpDelay += 1;
      }
      else {
        sdPoll10ms();
      }
    }

    if (pwrCheck() == e_power_off && state != ST_FLASHING && state != ST_USB) {
      pwrOff();
      for (;;) {
        // Wait for power to go off
      }
    }

    if (state == ST_REBOOT) {
      if ((~readKeys() & 0x7E) == 0) {
        NVIC_SystemReset();
      }
    }
  }

  return 0;
}
Example #11
0
int
main(int argc, char *argv[])
#endif
{
  int res=0;
  char firmware_filename[50];
  int current_fw_version=0;
#ifdef WRITESERIALNUMBER
  unsigned int serial_number=0;
  unsigned int hall_board_version=0;
  unsigned int firmware_version=0;
#endif
  int inputchar=10;

  printf("\nJLAB Signal Distribution (SD) Firmware Update\n");
  printf("------------------------------------------------\n");

#ifdef VXWORKS
  strncpy(bin_name,__FUNCTION__,50);
#else
  strncpy(bin_name,argv[0],50);

#ifdef WRITESERIALNUMBER
  if(argc<5)
    {
      printf(" ERROR: Must specify four (4) arguments\n");
      Usage();
      exit(-1);
    }
  else
    {
      strncpy(firmware_filename,argv[1],50);
      serial_number = (unsigned int) strtoll(argv[2],NULL,10)&0xffffffff;
      hall_board_version = (unsigned int) strtoll(argv[3],NULL,16)&0xffffffff;
      firmware_version = (unsigned int) strtoll(argv[4],NULL,16)&0xffffffff;
    }
#else
  if(argc<2)
    {
      printf(" ERROR: Must specify two (2) arguments\n");
      Usage();
      exit(-1);
    }
  else
    {
      strncpy(firmware_filename,argv[1],50);
    }
#endif
#endif /* VXWORKS */

#ifdef WRITESERIALNUMBER
  /* Check on provided items */
  if(serial_number<1 || serial_number>255)
    {
      printf(" ERROR: Invalid Serial Number (%d).  Must be 1-255\n",serial_number);
      exit(-1);
    }

  if(hall_board_version<0x1 || hall_board_version>0xFF)
    {
      printf(" ERROR: Invalid Assigned Hall and Board Version (0x%x).\n  Must be 0x01-0xFF\n"
	     ,hall_board_version);
      exit(-1);
    }

  if(firmware_version<0x1 || firmware_version>0xFF)
    {
      printf(" ERROR: Firmware Version (0x%x).  Must be 0x01-0xFF\n",firmware_version);
      exit(-1);
    }

  printf("Firmware File                   = %s\n",firmware_filename);
  printf("Serial Number (dec)             = %4d\n",serial_number);
  printf("Assigned Hall and Board Version = 0x%02X\n",hall_board_version);
  printf("Firmware Version                = 0x%02X\n",firmware_version);
  printf("\n");

  printf(" Please verify these items before continuing... \n");
#else
  printf("Firmware File                   = %s\n",firmware_filename);
#endif
  printf("\n");

#ifndef VXWORKS
  vmeSetQuietFlag(1);
  res = vmeOpenDefaultWindows();
  if(res!=OK)
    goto CLOSE;
#endif

  res = sdFirmwareLoadFile(firmware_filename);
  if(res!=OK)
    goto CLOSE;

  res = tiInit(21<<19,0,1);
  if(res!=OK)
    {
      /* try tsInit, instead */
      res = tsInit(21<<19,0,1);
      if(res!=OK)
	goto CLOSE;
    }
  
  res = sdInit(SD_INIT_IGNORE_VERSION);
  if(res!=OK)
    goto CLOSE;

  current_fw_version = sdGetFirmwareVersion(0);
  printf("\n  Current SD Firmware Version = 0x%x\n\n",current_fw_version);

  printf(" <ENTER> to continue... or q and <ENTER> to quit without update\n");
  inputchar = getchar();

  if((inputchar == 113) ||
     (inputchar == 81))
    {
      printf(" Exiting without update\n");
      res=1;
      goto CLOSE;
    }


  res = sdFirmwareFlushFifo();
  if(res!=OK)
    goto CLOSE;

  res = sdFirmwareWriteToMemory();
  if(res!=OK)
    goto CLOSE;

  goto CLOSE;

/*   res = sdFirmwareVerifyMemory(); */
/*   if(res!=OK) */
/*     goto CLOSE; */

  sdFirmwareFlushFifo();
#ifdef WRITESERIALNUMBER
  sdFirmwareWriteSpecs(0x7F0000,serial_number,hall_board_version,firmware_version);
  sleep(3);
  sdFirmwarePrintSpecs();
#endif

 CLOSE:

  sdFirmwareFreeMemory();
#ifndef VXWORKS
  vmeCloseDefaultWindows();
#endif

  printf("\n");
  if(res==ERROR)
    printf(" ******** SD Update ended in ERROR! ******** \n");
  else if (res==OK)
    {
      printf(" ++++++++ SD Update Successful! ++++++++\n");
      printf("   Power Cycle to load new firmware\n");
    }
  

  printf("\n");
  return OK;
}
Example #12
0
int main()
{
  uint8_t index = 0;
  uint8_t maxhsize = DISPLAY_CHAR_WIDTH;
  FRESULT fr;
  uint32_t state = ST_START;
  uint32_t nameCount = 0;
  uint32_t vpos = 0;
  uint32_t hpos = 0;

#if defined(PCBTARANIS)
  wdt_reset();
  RCC_AHB1PeriphClockCmd(PWR_RCC_AHB1Periph | KEYS_RCC_AHB1Periph | LCD_RCC_AHB1Periph | BACKLIGHT_RCC_AHB1Periph | I2C_RCC_AHB1Periph | SD_RCC_AHB1Periph, ENABLE);
  RCC_APB1PeriphClockCmd(LCD_RCC_APB1Periph | BACKLIGHT_RCC_APB1Periph | INTERRUPT_5MS_APB1Periph | I2C_RCC_APB1Periph | SD_RCC_APB1Periph, ENABLE);
  RCC_APB2PeriphClockCmd(BACKLIGHT_RCC_APB2Periph, ENABLE);
#endif

  pwrInit();
  delaysInit();               //needed for lcdInit()
  lcdInit();
  backlightInit();

  lcd_clear();
  lcd_putsn(0, 0, (const char *)bootloaderVersion, 0); // trick to avoid bootloaderVersion to be optimized out ...
  lcd_putsLeft(0, BOOTLOADER_TITLE);
  lcd_invert_line(0);
  lcdRefresh();

  keysInit();
  i2cInit();

  __enable_irq();
  init10msTimer();

#if defined(PCBTARANIS)
  // SD card detect pin
  sdInit();
  usbInit();
#endif

  for (;;) {
    wdt_reset();

    if (Tenms) {
      Tenms = 0;

      lcdRefreshWait();
      lcd_clear();
      lcd_putsLeft(0, BOOTLOADER_TITLE);
      lcd_invert_line(0);

      uint8_t event = getEvent();

      if (state != ST_USB) {
        if (usbPlugged()) {
          state = ST_USB;
          if (!unlocked) {
            unlocked = 1;
            unlockFlash();
          }
          usbPluggedIn();
        }
      }

      if (state == ST_START) {
        lcd_putsLeft(2*FH, "\010Write Firmware");
        lcd_putsLeft(3*FH, "\010Restore EEPROM");
        lcd_putsLeft(4*FH, "\010Exit");
        lcd_invert_line(2+vpos);
        lcd_putsLeft(7*FH, INDENT "Or plug in a USB cable for mass storage");
        if (event == EVT_KEY_FIRST(BOOT_KEY_DOWN)) {
          vpos == 2 ? vpos = 0 : vpos = vpos+1;
        }
        else if (event == EVT_KEY_FIRST(BOOT_KEY_UP)) {
          vpos == 0 ? vpos = 2 : vpos = vpos-1;
        }
        else if (event == EVT_KEY_BREAK(BOOT_KEY_MENU)) {
          switch (vpos) {
            case 0:
              state = ST_FLASH_MENU;
              break;
            case 1:
              state = ST_RESTORE_MENU;
              break;
            default:
              state = ST_REBOOT;
          }
        }
      }

      if (state == ST_USB) {
        lcd_putsLeft(4*FH, "\026USB Connected");
        if (usbPlugged() == 0) {
          vpos = 0;
          if (unlocked) {
            lockFlash();
            unlocked = 0;
          }
          state = ST_START;
        }
#if defined(PCBSKY9X)
        usbMassStorage();
#endif
      }

      if (state == ST_FLASH_MENU || state == ST_RESTORE_MENU) {
        sdInit();
        memoryType = (state == ST_RESTORE_MENU ? MEM_EEPROM : MEM_FLASH);
        state = ST_DIR_CHECK;
      }

      else if (state == ST_DIR_CHECK) {
        fr = f_chdir(getBinaryPath());
        if (fr == FR_OK) {
          state = ST_OPEN_DIR;
        }
        else {
          lcd_putsLeft(2*FH, INDENT "Directory is missing!");
          if (event == EVT_KEY_BREAK(BOOT_KEY_EXIT) || event == EVT_KEY_BREAK(BOOT_KEY_MENU)) {
            vpos = 0;
            state = ST_START;
          }
        }
      }

      if (state == ST_OPEN_DIR) {
        index = 0;
        fr = f_opendir(&Dj, ".");
        if (fr == FR_OK) {
          state = ST_FILE_LIST;
          nameCount = fillNames(0);
          hpos = 0;
          vpos = 0;
        }
      }

      if (state == ST_FILE_LIST) {
        uint32_t limit = 6;
        if (nameCount < limit) {
          limit = nameCount;
        }
        maxhsize = 0;
        for (uint32_t i=0; i<limit; i++) {
          uint32_t x;
          x = strlen(Filenames[i]);
          if (x > maxhsize) {
            maxhsize = x;
          }
          if (x > DISPLAY_CHAR_WIDTH) {
            if (hpos + DISPLAY_CHAR_WIDTH > x) {
              x = x - DISPLAY_CHAR_WIDTH;
            }
            else {
              x = hpos;
            }
          }
          else {
            x = 0;
          }
          lcd_putsnAtt(INDENT_WIDTH, 16 + FH * i, &Filenames[i][x], DISPLAY_CHAR_WIDTH, 0);
        }

        if (event == EVT_KEY_REPT(BOOT_KEY_DOWN) || event == EVT_KEY_FIRST(BOOT_KEY_DOWN)) {
          if (vpos < limit - 1) {
            vpos += 1;
          }
          else {
            if (nameCount > limit) {
              index += 1;
              nameCount = fillNames(index);
            }
          }
        }
        else if (event == EVT_KEY_REPT(BOOT_KEY_UP) || event == EVT_KEY_FIRST(BOOT_KEY_UP)) {
          if (vpos > 0) {
            vpos -= 1;
          }
          else {
            if (index) {
              index -= 1;
              nameCount = fillNames(index);
            }
          }
        }
#if !defined(PCBTARANIS)
        else if (event == EVT_KEY_REPT(BOOT_KEY_RIGHT) || event == EVT_KEY_FIRST(BOOT_KEY_RIGHT)) {
          if (hpos + DISPLAY_CHAR_WIDTH < maxhsize) {
            hpos += 1;
          }
        }
        else if (event == EVT_KEY_REPT(BOOT_KEY_LEFT) || event == EVT_KEY_FIRST(BOOT_KEY_LEFT)) {
          if (hpos) {
            hpos -= 1;
          }
        }
#endif
        else if (event == EVT_KEY_BREAK(BOOT_KEY_MENU)) {
          // Select file to flash
          state = ST_FLASH_CHECK;
          Valid = 0;
        }
        else if (event == EVT_KEY_FIRST(BOOT_KEY_EXIT)) {
          state = ST_START;
          vpos = 0;
        }

        lcd_invert_line(2 + vpos);
      }

      else if (state == ST_FLASH_CHECK) {
        int result = menuFlashFile(vpos, event);
        FirmwareSize = FileSize[vpos] - BOOTLOADER_SIZE;
        if (result == 0) {
          // canceled
          state = ST_FILE_LIST;
        }
        else if (result == 1) {
          // confirmed
          firmwareAddress = FIRMWARE_ADDRESS + BOOTLOADER_SIZE;
          firmwareWritten = 0;
          eepromAddress = 0;
          eepromWritten = 0;
          state = ST_FLASHING;
        }
      }

      else if (state == ST_FLASHING) {
        // commit to flashing
        lcd_putsLeft(4*FH, "\032Writing...");
        
        if (!unlocked && (memoryType == MEM_FLASH)) {
          unlocked = 1;
          unlockFlash();
        }
        
        int progress;
        if (memoryType == MEM_FLASH) {
          writeFlashBlock();
          firmwareWritten += sizeof(Block_buffer);
          progress = (200*firmwareWritten) / FirmwareSize;
        }
        else {
          writeEepromBlock();
          eepromWritten += sizeof(Block_buffer);
          progress = (200*eepromWritten) / EESIZE;
        }

        lcd_rect( 3, 6*FH+4, 204, 7);
        lcd_hline(5, 6*FH+6, progress, FORCE);
        lcd_hline(5, 6*FH+7, progress, FORCE);
        lcd_hline(5, 6*FH+8, progress, FORCE);

        fr = f_read(&FlashFile, (BYTE *)Block_buffer, sizeof(Block_buffer), &BlockCount);
        if (BlockCount == 0) {
          state = ST_FLASH_DONE; // EOF
        }
        if (firmwareWritten >= FLASHSIZE - BOOTLOADER_SIZE) {
          state = ST_FLASH_DONE; // Backstop
        }
        if (eepromWritten >= EESIZE) {
          state = ST_FLASH_DONE; // Backstop
        }
      }

      if (state == ST_FLASH_DONE) {
        if (unlocked) {
          lockFlash();
          unlocked = 0;
        }
        lcd_putsLeft(4*FH, "\024Writing Complete");
        if (event == EVT_KEY_FIRST(BOOT_KEY_EXIT) || event == EVT_KEY_BREAK(BOOT_KEY_MENU)) {
          state = ST_START;
          vpos = 0;
        }
      }

      if (event == EVT_KEY_LONG(BOOT_KEY_EXIT)) {
        state = ST_REBOOT;
      }

      lcdRefresh();

      if (PowerUpDelay < 20) {	// 200 mS
        PowerUpDelay += 1;
      }
      else {
        sdPoll10ms();
      }
    }

    if (state != ST_FLASHING && state != ST_USB) {
#if defined(REV9E)
      if (pwrPressed()) {
#else
      if (pwrCheck() == e_power_off) {
#endif
        lcdOff(); // this drains LCD caps
        pwrOff();
        for (;;) {
          // Wait for power to go off
        }
      }
    }

    if (state == ST_REBOOT) {
      if (readKeys() == 0) {
        lcd_clear();
        lcdRefresh();
        lcdRefreshWait();
        RCC->CSR |= RCC_CSR_RMVF;   //clear the reset flags in RCC clock control & status register
        NVIC_SystemReset();
      }
    }
  }

  return 0;
}
Example #13
0
static void
__download()
{
  int ii, i1, i2, i3, id, slot;
  char filename[1024];
#ifdef POLLING_MODE
  rol->poll = 1;
#else
  rol->poll = 0;
#endif

  printf("\n>>>>>>>>>>>>>>> ROCID=%d, CLASSID=%d <<<<<<<<<<<<<<<<\n",rol->pid,rol->classid);
  printf("CONFFILE >%s<\n\n",rol->confFile);
  printf("LAST COMPILED: %s %s\n", __DATE__, __TIME__);

  printf("USRSTRING >%s<\n\n",rol->usrString);

  /**/
  CTRIGINIT;

  /* initialize OS windows and TS board */
#ifdef VXWORKS
  CDOINIT(TSPRIMARY);
#else
  CDOINIT(TSPRIMARY,TIR_SOURCE);
#endif


  /************/
  /* init daq */

  daqInit();
  DAQ_READ_CONF_FILE;


  /*************************************/
  /* redefine TS settings if neseccary */

  tsSetUserSyncResetReceive(1);


  /* TS 1-6 create physics trigger, no sync event pin, no trigger 2 */
vmeBusLock();
/*tsLoadTriggerTable();*/
  /*tsSetTriggerWindow(7);TS*/	// (7+1)*4ns trigger it coincidence time to form trigger type
vmeBusUnlock();


  /*********************************************************/
  /*********************************************************/



  /* set wide pulse */
vmeBusLock();
/*sergey: WAS tsSetSyncDelayWidth(1,127,1);*/
/*worked for bit pattern latch tsSetSyncDelayWidth(0x54,127,1);*/
vmeBusUnlock();

  usrVmeDmaSetConfig(2,5,1); /*A32,2eSST,267MB/s*/
  /*usrVmeDmaSetConfig(2,5,0);*/ /*A32,2eSST,160MB/s*/
  /*usrVmeDmaSetConfig(2,3,0);*/ /*A32,MBLT*/

  tdcbuf = (unsigned int *)i2_from_rol1;



  /******************/
  /* USER code here */


  /* TD setup */

  ntd = 0;
  tdInit((3<<19),0x80000,20,0);
  ntd = tdGetNtds(); /* actual number of TD boards found  */

  tdGSetBlockLevel(block_level);
  tdGSetBlockBufferLevel(buffer_level);

  //tdAddSlave(17,2); // TI Slave - Bottom Crate (payload)
  //tdAddSlave(17,5); // TI Slave - Bench (GTP)

  tdslotmask = 0;
  for(id=0; id<ntd; id++) 
  {
    slot = tdSlot(id);
    tdslotmask |= (1<<slot);
    printf("=======================> tdslotmask=0x%08x\n",tdslotmask);
  }
  printf("TDSLOTMASK: tdslotmask=0x%08x (from library 0x%08x)\n",tdslotmask,tdSlotMask());

  sprintf(filename,"%s/portnames_%s.txt",getenv("CLON_PARMS"),getenv("EXPID"));
  printf("loading portnames from file >%s<\n",filename);
  tdLoadPortNames(filename);

  /*
  tdGStatus(0);
  */

  /***************************************
   *   SD SETUP
   ***************************************/
  printf("SD init starts\n");
vmeBusLock();
  printf("SD init 1\n");
  sdInit(1);   /* Initialize the SD library */
  sdSetActiveVmeSlots(tdslotmask); /* Use the tdslotmask to configure the SD */
  sdStatus();
vmeBusUnlock();
  printf("SD init done\n");




  /* if TDs are present, set busy from SD board */
  if(ntd>0)
  {
    printf("Set BUSY from SWB for TDs\n");
vmeBusLock();
    tsSetBusySource(TS_BUSY_SWB,0);
vmeBusUnlock();
  }




  /*sergey: following piece from tsConfig.c, doing it there not always propagate correct block_level to slaves;
	doing it again here seems helps, have to investigate */
  tsSetInstantBlockLevelChange(1); /* enable immediate block level setting */
  printf("trig1: setting block_level = %d\n",block_level);
sleep(1);
  tsSetBlockLevel(block_level);
sleep(1);
  tsSetInstantBlockLevelChange(0); /* disable immediate block level setting */



  sprintf(rcname,"RC%02d",rol->pid);
  printf("rcname >%4.4s<\n",rcname);

#ifdef SSIPC
  sprintf(ssname,"%s_%s",getenv("HOST"),rcname);
  printf("Smartsockets unique name >%s<\n",ssname);
  epics_msg_sender_init(getenv("EXPID"), ssname); /* SECOND ARG MUST BE UNIQUE !!! */
#endif

  logMsg("INFO: User Download Executed\n",1,2,3,4,5,6);
}
Example #14
0
int main() {
	u16 i, newJoy = 0, oldJoy = 0, autoRepeatDelay = 0, redraw = 1;
	s16 choice = 0;
	const char *str;
	struct FileSystem fs;
	u16 numFiles;

	// Init the screen, display message
	VDP_setScreenWidth320();
	VDP_setHInterrupt(0);
	VDP_setHilightShadow(0);
	VDP_setTextPalette(PAL0);
	VDP_drawText("MakeStuff USB MegaDrive Dev Kit v2", 3, 10);
	VDP_drawText("Reading SD-card...", 11, 12);

	// Initialise the SD card
	sdInit();

	// Get the geometry of the first SD-card partition
	fatOpenFileSystem(&fs);

	// Initialise workspace for the directory list
	initFiles((u16*)0x440000);

	// Get the list of game ROMs
	fatListDirectory(&fs, fs.rootDirCluster, storeFile);

	// Sort the list alphabetically
	numFiles = dirPtr - dirList;
	quickSort((CVPtr *)dirList, 0, numFiles, (CompareFunc)myFileComp);

	// Display the list
	for ( ; ; ) {
		newJoy = JOY_readJoypad(0);
		if ( newJoy & BUTTON_UP && choice > 0 ) {
			if ( !(oldJoy & BUTTON_UP) ) {
				choice--; redraw = 1;
				autoRepeatDelay = 0;
			} else {
				if ( autoRepeatDelay == 10 ) {
					choice--; redraw = 1;
				} else {
					autoRepeatDelay++;
				}
			}
		}
		if ( newJoy & BUTTON_DOWN && choice < numFiles-1 ) {
			if ( !(oldJoy & BUTTON_DOWN) ) {
				choice++; redraw = 1;
				autoRepeatDelay = 0;
			} else {
				if ( autoRepeatDelay == 10 ) {
					choice++; redraw = 1;
				} else {
					autoRepeatDelay++;
				}
			}
		}
		if ( newJoy & BUTTON_START ) {
			doSelect(&fs, choice);
		}
		oldJoy = newJoy;
		
		VDP_waitVSync();
		if ( redraw ) {
			VDP_clearPlan(VDP_PLAN_A, 1);
			VDP_waitDMACompletion();
			for ( i = 2; i < 26; i++ ) {
				if ( i >= 11-choice && i < numFiles-choice+11 ) {
					str = dirList[choice+i-11]->fileName;
					if ( i == 11 ) {
						VDP_setTextPalette(PAL1);
						VDP_drawText(str, 2, i);
						VDP_setTextPalette(PAL0);
					} else {
						VDP_drawText(str, 2, i);
					}
				}
			}
		}
		redraw = 0;
	}
}
Example #15
0
void kmain2()
{
	kprintf("Initializing SDI... ");
	sdInit();
	kprintf("%$\x02" "Done%#\n");

	initMount();
	initSymtab();

	kprintf("Initializing ACPICA...\n");
	ACPI_STATUS status = AcpiInitializeSubsystem();
	if (ACPI_FAILURE(status))
	{
		panic("AcpiInitializeSubsystem failed");
	};
	
	status = AcpiInitializeTables(NULL, 16, FALSE);
	if (ACPI_FAILURE(status))
	{
		panic("AcpiInitializeTables failed");
	};
	
	status = AcpiLoadTables();
	if (ACPI_FAILURE(status))
	{
		panic("AcpiLoadTables failed");
	};
	
	status = AcpiEnableSubsystem(ACPI_FULL_INITIALIZATION);
	if (ACPI_FAILURE(status))
	{
		panic("AcpiEnableSubsystem failed");
	};
	
	status = AcpiInitializeObjects(ACPI_FULL_INITIALIZATION);
	if (ACPI_FAILURE(status))
	{
		panic("AcpiInitializeObjects failed");
	};
	
	if (AcpiInstallFixedEventHandler(ACPI_EVENT_POWER_BUTTON, onPowerButton, NULL) != AE_OK)
	{
		panic("failed to register power button event");
	};
	
	pciInitACPI();
	
	kprintf("Initializing the RTC... ");
	initRTC();
	kprintf("%$\x02" "Done%#\n");

	kprintf("Initializing the network interface... ");
	ipreasmInit();
	initNetIf();
	kprintf("%$\x02" "Done%#\n");
	
	kprintf("Starting the spawn process... ");
	MachineState state;
	void *spawnStack = kmalloc(0x1000);
	state.rip = (uint64_t) &spawnProc;
	state.rsp = (uint64_t) spawnStack + 0x1000 - 16;
	((uint64_t*)state.rsp)[0] = 0;
	((uint64_t*)state.rsp)[1] = 0;
	state.rdi = (uint64_t) spawnStack;
	state.rbp = 0;
	Regs regs;
	regs.cs = 8;
	regs.ds = 16;
	regs.rflags = getFlagsRegister() | (1 << 9);
	regs.ss = 0;
	threadClone(&regs, 0, &state);
	// "Done" is displayed by the spawnProc() and that's our job done pretty much.
	// Mark this thread as waiting so that it never wastes any CPU time.
	getCurrentThread()->flags = THREAD_WAITING;
};
Example #16
0
int main(){

	SD sd;
	init();
	sei();
	if(!sdInit(&sd)) err_str("sd init failed");
	printf("SD Init Successfully\n");
	#if SD_CHECK == 1
		#define E(x)	do{printf(x); while(1);}while(0)

		UInt32 p, numSec;
		Boolean ret;
		UInt16 i;
		UInt8 buf[512],data;
		printf("Performing some basic tests\n");
		numSec = sdGetNumSec(&sd);
		printf(" - card is %ld sectors (%ld MB)\n", numSec, numSec >> 11UL);
		
		ret = sdSecRead(&sd, 0, buf);
		if(!ret) E("card read fails\n");

		/*for(i = 0; i < 512; i++){

			if(i & 0x0F) printf(" ");
			else printf("\n%04X ", i);
		}
		printf("\n");

		//if(numSec > 32UL * 1024UL) numSec = 512;
		//Check full card
		
		for(p = 0; p < numSec; p++){

			ret = sdSecRead(&sd, p, buf);
			if(!ret) E("card read fails\n");

			printf("\r reading %ld/%ld", p, numSec);
			for(i = 0; i < 512; i += 16) ramWrite((p << 9) + i, buf + i, 16);
		}
		printf("\n");*/
		for(p = 1; p < numSec; p+=4096){
			printf("Sector:%lu\n",p);
			ret = sdSecRead(&sd, p, buf);
			if(!ret) E("card read fails\n");
			for(i = 0;i < 512;i++){
				*(buf+i) = 0x11;
			}
			((uint32_t *)buf)[0] = p;//~*(buf+i);
			ret = sdSecWrite(&sd, p, buf);
			if(!ret) E("card write fails\n");
			/*for(i = 0;i < 512;i+=16){
				ramRead(i,&data,1);
				if(data != buf[i]){
					printf("mismatch on %llu,data in memory is 0x%x,data in SD card is 0x%x\n",(uint64_t)p*512+i,data,buf[i]);
					while(1);
				}
			}*/
		}

		printf("Finished!\n");
		while(1);
	#endif


	socInit(&soc, socRamModeCallout, coRamAccess, readchar, writechar, rootOps, &sd);

	if(!(PIND & (1<<5))){	//hack for faster boot in case we know all variables & button is pressed
		#ifndef FAST_BOOT2
			printf("Faster boot\n");
			UInt32 i, s = 786464UL;
			UInt32 d = 0xA0E00000;
			UInt16 j;
			UInt8* b = (UInt8*)soc.blkDevBuf;

			for(i = 0; i < 4096; i++){
				sdSecRead(&sd, s++, b);
				for(j = 0; j < 512; j += 32, d+= 32){

					ramWrite(d, b + j, 32);
				}
			}
			soc.cpu.regs[15] = 0xA0E00000UL+512UL;
			printf("Faster boot start\n");
		#else
			uint64_t i;
			/*struct ArmCpu cpu;
			cpu.extra_regs = soc.cpu.extra_regs;//backup pointer
			cpu.regs = soc.cpu.regs;
			cpu.coproc = soc.cpu.coproc;
			cpu.userdata = soc.cpu.userdata;*/
			printf("Faster boot 2\n");
			UInt8* buf = (UInt8*)soc.blkDevBuf;
			UInt32 s = (uint64_t)(0x18204000)/512;//1 sector 512 bytes
			sdSecRead(&sd, s++, buf);
			if(*buf == FAST_BOOT2_MAGIC_NUMBER){
				//Magic Number
				for(i = 0; i < RAM_SIZE/512; i++){
					sdSecRead(&sd, s++, buf);
					/*for(j = 0; j < 512; j += 32){
						ramWrite(i<<9 + j,buf + j, 32);
					}*/
					ramWrite(i<<9,buf,512);
				}
				sdSecRead(&sd, s, buf);//registers
				for(i = 0;i<16;i++){
					soc.cpu.regs[i] = buf[i];
				}
				/*soc.cpu = *(struct ArmCpu *)(buf+16);//Get CPU's information
				soc.cpu.extra_regs = cpu.extra_regs;
				soc.cpu.regs = cpu.regs;
				soc.cpu.coproc = cpu.coproc;
				soc.cpu.userdata = cpu.userdata; */
				printf("Faster boot start\n");
			}else{
				printf("Magic number not match,try to boot in a normal way.\n");
			}
		#endif
	}
	#ifdef GDB_SUPPORT
		socRun(&soc,0);
	#else
		socRun(&soc);
	#endif
	while(1);

	return 0;
}