target/linux/at91-2.6/image/dfboot/src/main.c

   1 /*----------------------------------------------------------------------------
   2  *         ATMEL Microcontroller Software Support  -  ROUSSET  -
   3  *----------------------------------------------------------------------------
   4  * The software is delivered "AS IS" without warranty or condition of any
   5  * kind, either express, implied or statutory. This includes without
   6  * limitation any warranty or condition with respect to merchantability or
   7  * fitness for any particular purpose, or against the infringements of
   8  * intellectual property rights of others.
   9  *----------------------------------------------------------------------------
  10  * File Name            : main.c
  11  * Object               :
  12  * Creation             : HIi   10/10/2003
  13  * Modif                : HIi   15/06/2004 :    add crc32 to verify the download
  14  *                                              from dataflash
  15  *                      : HIi   21/09/2004 :    Set first PLLA to 180Mhz and MCK to
  16  *                                              60Mhz to speed up dataflash boot (15Mhz)
  17  *                      : MLC   12/04/2005 :    Modify SetPLL() to avoid errata
  18  *                      : USA   30/12/2005 :    Change to page Size 1056
  19  *                                              Change startaddress to C0008400
  20  *                                              Change SPI Speed to ~4 Mhz
  21  *                                              Add retry on CRC Error
  22  *----------------------------------------------------------------------------
  23  */
  24 #include "config.h"
  25 #include "stdio.h"
  26 #include "AT91RM9200.h"
  27 #include "lib_AT91RM9200.h"
  28 #include "com.h"
  29 #include "main.h"
  30 #include "dataflash.h"
  31 #include "AT91C_MCI_Device.h"
  32
  33 #define DEBUGOUT
  34 #define XMODEM
  35 #define MEMDISP
  36
  37 #ifdef  PAGESZ_1056
  38 #define PAGESIZE        1056
  39 #else
  40 #define PAGESIZE        1024
  41 #endif
  42
  43 #define AT91C_SDRAM_START 0x20000000
  44 #define AT91C_BOOT_ADDR 0x21F00000
  45 #define AT91C_BOOT_SIZE 128*PAGESIZE
  46 #ifdef  PAGESZ_1056
  47 #define AT91C_BOOT_DATAFLASH_ADDR 0xC0008400
  48 #else
  49 #define AT91C_BOOT_DATAFLASH_ADDR 0xC0008000
  50 #endif
  51 #define AT91C_PLLA_VALUE 0x237A3E5A  // crystal= 18.432MHz - fixes BRG error at 115kbps
  52 //#define AT91C_PLLA_VALUE 0x2026BE04   // crystal= 18.432MHz
  53 //#define AT91C_PLLA_VALUE 0x202CBE01   // crystal= 4MHz
  54
  55
  56
  57 #define DISP_LINE_LEN 16
  58
  59 // Reason for boot failure
  60 #define IMAGE_BAD_SIZE                  0
  61 #define IMAGE_READ_FAILURE      1
  62 #define IMAGE_CRC_ERROR         2
  63 #define IMAGE_ERROR                     3
  64 #define SUCCESS                         -1
  65
  66 /* prototypes*/
  67 extern void AT91F_ST_ASM_HANDLER(void);
  68 extern void Jump(unsigned int addr);
  69
  70 const char *menu_dataflash[] = {
  71 #ifdef XMODEM
  72         "1: P DFboot\n",
  73         "2: P U-Boot\n",
  74 #endif
  75         "3: P SDCard\n",
  76 #ifdef  PAGESZ_1056
  77         "4: R UBOOT\n",
  78 #else
  79         "4: R UBOOT\n",
  80 #endif
  81 #ifdef XMODEM
  82         "5: P DF [addr]\n",
  83 #endif
  84         "6: RD DF [addr]\n",
  85         "7: E DF\n"
  86 };
  87 #ifdef XMODEM
  88 #define MAXMENU 7
  89 #else
  90 #define MAXMENU 4
  91 #endif
  92
  93 char message[20];
  94 #ifdef XMODEM
  95 volatile char XmodemComplete = 0;
  96 #endif
  97 unsigned int StTick = 0;
  98
  99 AT91S_RomBoot const *pAT91;
 100 #ifdef XMODEM
 101 AT91S_SBuffer sXmBuffer;
 102 AT91S_SvcXmodem svcXmodem;
 103 AT91S_Pipe xmodemPipe;
 104 #endif
 105 AT91S_CtlTempo ctlTempo;
 106
 107
 108 //*--------------------------------------------------------------------------------------
 109 //* Function Name       : GetTickCount()
 110 //* Object              : Return the number of systimer tick
 111 //* Input Parameters    :
 112 //* Output Parameters   :
 113 //*--------------------------------------------------------------------------------------
 114 unsigned int GetTickCount(void)
 115 {
 116         return StTick;
 117 }
 118
 119 #ifdef XMODEM
 120 //*--------------------------------------------------------------------------------------
 121 //* Function Name       : AT91_XmodemComplete()
 122 //* Object              : Perform the remap and jump to appli in RAM
 123 //* Input Parameters    :
 124 //* Output Parameters   :
 125 //*--------------------------------------------------------------------------------------
 126 static void AT91_XmodemComplete(AT91S_PipeStatus status, void *pVoid)
 127 {
 128         /* stop the Xmodem tempo */
 129         svcXmodem.tempo.Stop(&(svcXmodem.tempo));
 130         XmodemComplete = 1;
 131 }
 132
 133
 134 //*--------------------------------------------------------------------------------------
 135 //* Function Name       : AT91F_XmodemProtocol(AT91S_PipeStatus status, void *pVoid)
 136 //* Object              : Xmodem dispatcher
 137 //* Input Parameters    :
 138 //* Output Parameters   :
 139 //*--------------------------------------------------------------------------------------
 140 static void XmodemProtocol(AT91S_PipeStatus status, void *pVoid)
 141 {
 142         AT91PS_SBuffer pSBuffer = (AT91PS_SBuffer) xmodemPipe.pBuffer->pChild;
 143         AT91PS_USART   pUsart     = svcXmodem.pUsart;
 144
 145         if (pSBuffer->szRdBuffer == 0) {
 146                 /* Start a tempo to wait the Xmodem protocol complete */
 147                 svcXmodem.tempo.Start(&(svcXmodem.tempo), 10, 0, AT91_XmodemComplete, pUsart);
 148         }
 149 }
 150 #endif
 151
 152 //*--------------------------------------------------------------------------------------
 153 //* Function Name       : irq1_c_handler()
 154 //* Object              : C Interrupt handler for Interrutp source 1
 155 //* Input Parameters    : none
 156 //* Output Parameters   : none
 157 //*--------------------------------------------------------------------------------------
 158 void AT91F_ST_HANDLER(void)
 159 {
 160         volatile unsigned int csr = *AT91C_DBGU_CSR;
 161 #ifdef XMODEM
 162         unsigned int error;
 163 #endif
 164
 165         if (AT91C_BASE_ST->ST_SR & 0x01) {
 166                 StTick++;
 167                 ctlTempo.CtlTempoTick(&ctlTempo);
 168                 return;
 169         }
 170
 171 #ifdef XMODEM
 172         error = AT91F_US_Error((AT91PS_USART)AT91C_BASE_DBGU);
 173         if (csr & error) {
 174                 /* Stop previous Xmodem transmition*/
 175                 *(AT91C_DBGU_CR) = AT91C_US_RSTSTA;
 176                 AT91F_US_DisableIt((AT91PS_USART)AT91C_BASE_DBGU, AT91C_US_ENDRX);
 177                 AT91F_US_EnableIt((AT91PS_USART)AT91C_BASE_DBGU, AT91C_US_RXRDY);
 178
 179         }
 180
 181         else if (csr & (AT91C_US_TXRDY | AT91C_US_ENDTX | AT91C_US_TXEMPTY |
 182                         AT91C_US_RXRDY | AT91C_US_ENDRX | AT91C_US_TIMEOUT |
 183                         AT91C_US_RXBUFF)) {
 184                 if ( !(svcXmodem.eot) )
 185                         svcXmodem.Handler(&svcXmodem, csr);
 186         }
 187 #endif
 188 }
 189
 190
 191 //*-----------------------------------------------------------------------------
 192 //* Function Name       : AT91F_DisplayMenu()
 193 //* Object              :
 194 //* Input Parameters    :
 195 //* Return value                :
 196 //*-----------------------------------------------------------------------------
 197 static int AT91F_DisplayMenu(void)
 198 {
 199         int i, mci_present = 0;
 200         printf("\nDF LOADER %s %s %s\n",AT91C_VERSION,__DATE__,__TIME__);
 201         AT91F_DataflashPrintInfo();
 202         mci_present = AT91F_MCI_Init();
 203         for(i = 0; i < MAXMENU; i++) {
 204                 puts(menu_dataflash[i]);
 205         }
 206         return mci_present;
 207 }
 208
 209
 210 //*-----------------------------------------------------------------------------
 211 //* Function Name       : AsciiToHex()
 212 //* Object              : ascii to hexa conversion
 213 //* Input Parameters    :
 214 //* Return value                :
 215 //*-----------------------------------------------------------------------------
 216 static unsigned int AsciiToHex(char *s, unsigned int *val)
 217 {
 218         int n;
 219
 220         *val=0;
 221
 222         if(s[0] == '0' && ((s[1] == 'x') || (s[1] == 'X')))
 223                 s+=2;
 224         n = 0;
 225         while((n < 8) && (s[n] !=0))
 226         {
 227                 *val <<= 4;
 228                 if ( (s[n] >= '0') && (s[n] <='9'))
 229                         *val += (s[n] - '0');
 230                 else
 231                         if ((s[n] >= 'a') && (s[n] <='f'))
 232                                 *val += (s[n] - 0x57);
 233                         else
 234                                 if ((s[n] >= 'A') && (s[n] <='F'))
 235                                         *val += (s[n] - 0x37);
 236                         else
 237                                 return 0;
 238                 n++;
 239         }
 240
 241         return 1;
 242 }
 243
 244
 245 #ifdef MEMDISP
 246 //*-----------------------------------------------------------------------------
 247 //* Function Name       : AT91F_MemoryDisplay()
 248 //* Object              : Display the content of the dataflash
 249 //* Input Parameters    :
 250 //* Return value                :
 251 //*-----------------------------------------------------------------------------
 252 static int AT91F_MemoryDisplay(unsigned int addr, unsigned int length)
 253 {
 254         unsigned long   i, nbytes, linebytes;
 255         char    *cp;
 256 //      unsigned int    *uip;
 257 //      unsigned short  *usp;
 258         unsigned char   *ucp;
 259         char linebuf[DISP_LINE_LEN];
 260
 261 //      nbytes = length * size;
 262         nbytes = length;
 263         do
 264         {
 265 //              uip = (unsigned int *)linebuf;
 266 //              usp = (unsigned short *)linebuf;
 267                 ucp = (unsigned char *)linebuf;
 268
 269                 printf("%08x:", addr);
 270                 linebytes = (nbytes > DISP_LINE_LEN)?DISP_LINE_LEN:nbytes;
 271                 if((addr & 0xF0000000) == 0x20000000) {
 272                         for(i = 0; i < linebytes; i ++) {
 273                                 linebuf[i] =  *(char *)(addr+i);
 274                         }
 275                 } else {
 276                         read_dataflash(addr, linebytes, linebuf);
 277                 }
 278                 for (i=0; i<linebytes; i++)
 279                 {
 280 /*                      if (size == 4)
 281                                 printf(" %08x", *uip++);
 282                         else if (size == 2)
 283                                 printf(" %04x", *usp++);
 284                         else
 285 */
 286                                 printf(" %02x", *ucp++);
 287 //                      addr += size;
 288                         addr++;
 289                 }
 290                 printf("    ");
 291                 cp = linebuf;
 292                 for (i=0; i<linebytes; i++) {
 293                         if ((*cp < 0x20) || (*cp > 0x7e))
 294                                 printf(".");
 295                         else
 296                                 printf("%c", *cp);
 297                         cp++;
 298                 }
 299                 printf("\n");
 300                 nbytes -= linebytes;
 301         } while (nbytes > 0);
 302         return 0;
 303 }
 304 #endif
 305
 306 //*--------------------------------------------------------------------------------------
 307 //* Function Name       : AT91F_SetPLL
 308 //* Object              : Set the PLLA to 180Mhz and Master clock to 60 Mhz
 309 //* Input Parameters    :
 310 //* Output Parameters   :
 311 //*--------------------------------------------------------------------------------------
 312 static unsigned int AT91F_SetPLL(void)
 313 {
 314         AT91_REG tmp;
 315         AT91PS_PMC pPmc = AT91C_BASE_PMC;
 316         AT91PS_CKGR pCkgr = AT91C_BASE_CKGR;
 317
 318         pPmc->PMC_IDR = 0xFFFFFFFF;
 319
 320         /* -Setup the PLL A */
 321         pCkgr->CKGR_PLLAR = AT91C_PLLA_VALUE;
 322
 323         while (!(*AT91C_PMC_SR & AT91C_PMC_LOCKA));
 324
 325         /* - Switch Master Clock from PLLB to PLLA/3 */
 326         tmp = pPmc->PMC_MCKR;
 327         /* See Atmel Errata #27 and #28 */
 328         if (tmp & 0x0000001C) {
 329                 tmp = (tmp & ~0x0000001C);
 330                 pPmc->PMC_MCKR = tmp;
 331                 while (!(*AT91C_PMC_SR & AT91C_PMC_MCKRDY));
 332         }
 333         if (tmp != 0x00000202) {
 334                 pPmc->PMC_MCKR = 0x00000202;
 335                 if ((tmp & 0x00000003) != 0x00000002)
 336                         while (!(*AT91C_PMC_SR & AT91C_PMC_MCKRDY));
 337         }
 338
 339         return 1;
 340 }
 341
 342
 343 //*--------------------------------------------------------------------------------------
 344 //* Function Name       : AT91F_ResetRegisters
 345 //* Object              : Restore the initial state to registers
 346 //* Input Parameters    :
 347 //* Output Parameters   :
 348 //*--------------------------------------------------------------------------------------
 349 static unsigned int AT91F_ResetRegisters(void)
 350 {
 351         volatile int i = 0;
 352
 353         /* set the PIOs in input*/
 354         /* This disables the UART output, so dont execute for now*/
 355
 356 #ifndef DEBUGOUT
 357         *AT91C_PIOA_ODR = 0xFFFFFFFF;   /* Disables all the output pins */
 358         *AT91C_PIOA_PER = 0xFFFFFFFF;   /* Enables the PIO to control all the pins */
 359 #endif
 360
 361         AT91F_AIC_DisableIt (AT91C_BASE_AIC, AT91C_ID_SYS);
 362         /* close all peripheral clocks */
 363
 364 #ifndef DEBUGOUT
 365         AT91C_BASE_PMC->PMC_PCDR = 0xFFFFFFFC;
 366 #endif
 367         /* Disable core interrupts and set supervisor mode */
 368         __asm__ ("msr CPSR_c, #0xDF"); //* ARM_MODE_SYS(0x1F) | I_BIT(0x80) | F_BIT(0x40)
 369         /* Clear all the interrupts */
 370         *AT91C_AIC_ICCR = 0xffffffff;
 371
 372         /* read the AIC_IVR and AIC_FVR */
 373         i = *AT91C_AIC_IVR;
 374         i = *AT91C_AIC_FVR;
 375
 376         /* write the end of interrupt control register */
 377         *AT91C_AIC_EOICR        = 0;
 378
 379         return 1;
 380 }
 381
 382
 383 static int AT91F_LoadBoot(void)
 384 {
 385 //      volatile unsigned int crc1 = 0, crc2 = 0;
 386         volatile unsigned int SizeToDownload = 0x21400;
 387         volatile unsigned int AddressToDownload = AT91C_BOOT_ADDR;
 388
 389 #if 0
 390         /* Read vector 6 to extract size to load */
 391         if (read_dataflash(AT91C_BOOT_DATAFLASH_ADDR, 32,
 392                            (char *)AddressToDownload) != AT91C_DATAFLASH_OK)
 393         {
 394                 printf("Bad Code Size\n");
 395                 return IMAGE_BAD_SIZE;
 396         }
 397         /* calculate the size to download */
 398         SizeToDownload = *(int *)(AddressToDownload + AT91C_OFFSET_VECT6);
 399 #endif
 400
 401 //      printf("\nLoad UBOOT from dataflash[%x] to SDRAM[%x]\n",
 402 //             AT91C_BOOT_DATAFLASH_ADDR, AT91C_BOOT_ADDR);
 403         if (read_dataflash(AT91C_BOOT_DATAFLASH_ADDR, SizeToDownload + 8,
 404                            (char *)AddressToDownload) != AT91C_DATAFLASH_OK)
 405         {
 406                 printf("F DF RD\n");
 407                 return IMAGE_READ_FAILURE;
 408         }
 409 #if 0
 410         pAT91->CRC32((const unsigned char *)AT91C_BOOT_ADDR,
 411                      (unsigned int)SizeToDownload , (unsigned int *)&crc2);
 412         crc1 = (int)(*(char *)(AddressToDownload + SizeToDownload)) +
 413                (int)(*(char *)(AddressToDownload + SizeToDownload + 1) << 8) +
 414                (int)(*(char *)(AddressToDownload + SizeToDownload + 2) << 16) +
 415                (int)(*(char *)(AddressToDownload + SizeToDownload + 3) << 24);
 416
 417         /* Restore the value of Vector 6 */
 418         *(int *)(AddressToDownload + AT91C_OFFSET_VECT6) =
 419                 *(int *)(AddressToDownload + SizeToDownload + 4);
 420
 421         if (crc1 != crc2) {
 422                 printf("DF CRC bad %x != %x\n",crc1,crc2);
 423                 return  IMAGE_CRC_ERROR;
 424         }
 425 #endif
 426         return SUCCESS;
 427 }
 428
 429 static int AT91F_StartBoot(void)
 430 {
 431         int     sts;
 432         if((sts = AT91F_LoadBoot()) != SUCCESS) return sts;
 433 //      printf("\n");
 434 //      printf("PLLA[180MHz], MCK[60Mhz] ==> Start UBOOT\n");
 435         if (AT91F_ResetRegisters())
 436         {
 437                 printf("Jump");
 438                 Jump(AT91C_BOOT_ADDR);
 439 //              LED_blink(0);
 440         }
 441         return  IMAGE_ERROR;
 442 }
 443
 444 #if 0
 445 static void     AT91F_RepeatedStartBoot(void)
 446 {
 447         int     i;
 448         for(i = 0; i < CRC_RETRIES; i++) {
 449                 if(AT91F_StartBoot() != IMAGE_CRC_ERROR){
 450 //                      LED_blink(1);
 451                         return;
 452                 }
 453         }
 454         return;
 455 }
 456 #endif
 457
 458 #define TRUE 1
 459 #define FALSE 0
 460 #define TRX_MAGIC 0x30524448  /* "HDR0" */
 461 #define TRX_VERSION 1
 462
 463 struct trx_header {
 464         unsigned int magic;
 465         unsigned int len;
 466         unsigned int crc32;
 467         unsigned int flag_version;
 468         unsigned int offsets[3];
 469 };
 470
 471 #define AT91C_MCI_TIMEOUT 1000000
 472
 473 extern AT91S_MciDevice MCI_Device;
 474 extern void AT91F_MCIDeviceWaitReady(unsigned int);
 475 extern int AT91F_MCI_ReadBlockSwab(AT91PS_MciDevice, int, unsigned int *, int);
 476
 477 int Program_From_MCI(void)
 478 {
 479   int i;
 480   unsigned int Max_Read_DataBlock_Length;
 481   int block = 0;
 482   int buffer = AT91C_DOWNLOAD_BASE_ADDRESS;
 483   int bufpos = AT91C_DOWNLOAD_BASE_ADDRESS;
 484   int NbPage = 0;
 485   struct trx_header *p;
 486
 487         p = (struct trx_header *)bufpos;
 488
 489         Max_Read_DataBlock_Length = MCI_Device.pMCI_DeviceFeatures->Max_Read_DataBlock_Length;
 490
 491         AT91F_MCIDeviceWaitReady(AT91C_MCI_TIMEOUT);
 492
 493   AT91F_MCI_ReadBlockSwab(&MCI_Device, block*Max_Read_DataBlock_Length, (unsigned int *)bufpos, Max_Read_DataBlock_Length);
 494
 495   if (p->magic != TRX_MAGIC) {
 496                 printf("Inv IMG 0x%08x\n", p->magic);
 497                 return FALSE;
 498                 }
 499
 500         printf("RDSD");
 501         AT91C_BASE_PIOC->PIO_CODR = AT91C_PIO_PC7 | AT91C_PIO_PC15 | AT91C_PIO_PC8 | AT91C_PIO_PC14;
 502         for (i=0; i<(p->len/512); i++) {
 503                 AT91F_MCI_ReadBlockSwab(&MCI_Device, block*Max_Read_DataBlock_Length, (unsigned int *)bufpos, Max_Read_DataBlock_Length);
 504                 block++;
 505                 bufpos += Max_Read_DataBlock_Length;
 506                 }
 507
 508         NbPage = 0;
 509         i = dataflash_info[0].Device.pages_number;
 510         while(i >>= 1)
 511                 NbPage++;
 512         i = ((p->offsets[1] - p->offsets[0])/ 512) + 1 + (NbPage << 13) + (dataflash_info[0].Device.pages_size << 17);
 513         *(int *)(buffer + p->offsets[0] + AT91C_OFFSET_VECT6) = i;
 514
 515         printf(" WDFB");
 516         AT91C_BASE_PIOC->PIO_CODR = AT91C_PIO_PC7 | AT91C_PIO_PC15 | AT91C_PIO_PC14;
 517         AT91C_BASE_PIOC->PIO_SODR = AT91C_PIO_PC8;
 518         write_dataflash(0xc0000000, buffer + p->offsets[0], p->offsets[1] - p->offsets[0]);
 519         printf(" WUB");
 520         AT91C_BASE_PIOC->PIO_CODR = AT91C_PIO_PC7 | AT91C_PIO_PC15;
 521         AT91C_BASE_PIOC->PIO_SODR = AT91C_PIO_PC8 | AT91C_PIO_PC14;
 522         write_dataflash(0xc0008000, buffer + p->offsets[1], p->offsets[2] - p->offsets[1]);
 523         printf(" WKRFS");
 524         AT91C_BASE_PIOC->PIO_CODR = AT91C_PIO_PC8 | AT91C_PIO_PC15;
 525         AT91C_BASE_PIOC->PIO_SODR = AT91C_PIO_PC7 | AT91C_PIO_PC14;
 526         write_dataflash(0xc0042000, buffer + p->offsets[2], p->len - p->offsets[2]);
 527         AT91C_BASE_PIOC->PIO_CODR = AT91C_PIO_PC8 | AT91C_PIO_PC14;
 528         AT91C_BASE_PIOC->PIO_SODR = AT91C_PIO_PC7 | AT91C_PIO_PC15;
 529         return TRUE;
 530 }
 531
 532 //*----------------------------------------------------------------------------
 533 //* Function Name       : main
 534 //* Object              : Main function
 535 //* Input Parameters    : none
 536 //* Output Parameters   : True
 537 //*----------------------------------------------------------------------------
 538 int main(void)
 539 {
 540 #ifdef XMODEM
 541         AT91PS_Buffer           pXmBuffer;
 542         AT91PS_SvcComm          pSvcXmodem;
 543 #endif
 544         AT91S_SvcTempo          svcBootTempo;    // Link to a AT91S_Tempo object
 545         unsigned int            ix;
 546         volatile unsigned int AddressToDownload, SizeToDownload;
 547         unsigned int DeviceAddress = 0;
 548         char command = 0;
 549 #ifdef XMODEM
 550         volatile int i = 0;
 551         unsigned int crc1 = 0, crc2 = 0;
 552         volatile int device;
 553         int NbPage;
 554 #endif
 555         volatile int Nb_Device = 0;
 556         int mci_present = 0;
 557
 558         pAT91 = AT91C_ROM_BOOT_ADDRESS;
 559
 560         if (!AT91F_SetPLL())
 561         {
 562                 printf("F SetPLL");
 563                 while(1);
 564         }
 565
 566         at91_init_uarts();
 567
 568         /* Tempo Initialisation */
 569         pAT91->OpenCtlTempo(&ctlTempo, (void *) &(pAT91->SYSTIMER_DESC));
 570         ctlTempo.CtlTempoStart((void *) &(pAT91->SYSTIMER_DESC));
 571
 572         // Attach the tempo to a tempo controler
 573         ctlTempo.CtlTempoCreate(&ctlTempo, &svcBootTempo);
 574 //      LED_init();
 575 //      LED_blink(2);
 576
 577 #ifdef XMODEM
 578         /* Xmodem Initialisation */
 579         pXmBuffer = pAT91->OpenSBuffer(&sXmBuffer);
 580         pSvcXmodem = pAT91->OpenSvcXmodem(&svcXmodem,
 581                      (AT91PS_USART)AT91C_BASE_DBGU, &ctlTempo);
 582         pAT91->OpenPipe(&xmodemPipe, pSvcXmodem, pXmBuffer);
 583 #endif
 584
 585         /* System Timer initialization */
 586         AT91F_AIC_ConfigureIt(
 587                 AT91C_BASE_AIC,                        // AIC base address
 588                 AT91C_ID_SYS,                          // System peripheral ID
 589                 AT91C_AIC_PRIOR_HIGHEST,               // Max priority
 590                 AT91C_AIC_SRCTYPE_INT_LEVEL_SENSITIVE, // Level sensitive
 591                 AT91F_ST_ASM_HANDLER
 592         );
 593         /* Enable ST interrupt */
 594         AT91F_AIC_EnableIt(AT91C_BASE_AIC, AT91C_ID_SYS);
 595
 596 #ifndef PRODTEST
 597         /* Start tempo to start Boot in a delay of
 598          * AT91C_DELAY_TO_BOOT sec if no key pressed */
 599         svcBootTempo.Start(&svcBootTempo, AT91C_DELAY_TO_BOOT,
 600                            0, AT91F_StartBoot, NULL);
 601 #endif
 602
 603         while(1)
 604         {
 605                 while(command == 0)
 606                 {
 607                         AddressToDownload = AT91C_DOWNLOAD_BASE_ADDRESS;
 608                         SizeToDownload = AT91C_DOWNLOAD_MAX_SIZE;
 609                         DeviceAddress = 0;
 610
 611                         /* try to detect Dataflash */
 612                         if (!Nb_Device)
 613                                 Nb_Device = AT91F_DataflashInit();
 614
 615                         mci_present = AT91F_DisplayMenu();
 616
 617 #ifdef PRODTEST
 618                         if (mci_present) {
 619                                 if (Program_From_MCI())
 620                                         AT91F_StartBoot();
 621                         }
 622 #endif
 623
 624                         message[0] = 0;
 625                         AT91F_ReadLine ("Enter: ", message);
 626
 627 #ifndef PRODTEST
 628                         /* stop tempo ==> stop autoboot */
 629                         svcBootTempo.Stop(&svcBootTempo);
 630 #endif
 631
 632                         command = message[0];
 633                         for(ix = 1; (message[ix] == ' ') && (ix < 12); ix++);   // Skip some whitespace
 634
 635                         if(!AsciiToHex(&message[ix], &DeviceAddress) )
 636                                 DeviceAddress = 0;                      // Illegal DeviceAddress
 637
 638                         switch(command)
 639                         {
 640 #ifdef XMODEM
 641                                 case '1':
 642                                 case '2':
 643                                 case '5':
 644                                         if(command == '1') {
 645                                                 DeviceAddress = 0xC0000000;
 646 //                                              printf("Download DataflashBoot.bin to [0x%x]\n", DeviceAddress);
 647                                         } else if(command == '2') {
 648                                                 DeviceAddress = AT91C_BOOT_DATAFLASH_ADDR;
 649 //                                              printf("Download u-boot.bin to [0x%x]\n", DeviceAddress);
 650                                         } else {
 651 //                                              printf("Download Dataflash to [0x%x]\n", DeviceAddress);
 652                                         }
 653                                         switch(DeviceAddress & 0xFF000000)
 654                                         {
 655                                                 case CFG_DATAFLASH_LOGIC_ADDR_CS0:
 656                                                         if (dataflash_info[0].id == 0){
 657                                                                 printf("No DF");
 658                                                                 AT91F_WaitKeyPressed();
 659                                                                 command = 0;
 660                                                         }
 661
 662                                                         device = 0;
 663                                                 break;
 664
 665                                                 case CFG_DATAFLASH_LOGIC_ADDR_CS3:
 666                                                         if (dataflash_info[1].id == 0){
 667                                                                 printf("No DF");
 668                                                                 AT91F_WaitKeyPressed();
 669                                                                 command = 0;
 670                                                         }
 671                                                         device = 1;
 672                                                 break;
 673
 674                                                 default:
 675                                                         command = 0;
 676                                                 break;
 677                                         }
 678                                 break;
 679 #endif
 680
 681                                 case '3':
 682                                         if (mci_present)
 683                                                 Program_From_MCI();
 684                                         command = 0;
 685                                         break;
 686
 687                                 case '4':
 688                                         AT91F_StartBoot();
 689                                         command = 0;
 690                                 break;
 691
 692 #ifdef MEMDISP
 693                                 case '6':
 694                                         do
 695                                         {
 696                                                 AT91F_MemoryDisplay(DeviceAddress, 256);
 697                                                 AT91F_ReadLine (NULL, message);
 698                                                 DeviceAddress += 0x100;
 699                                         }
 700                                         while(message[0] == '\0');
 701                                         command = 0;
 702                                 break;
 703 #endif
 704
 705                                 case '7':
 706                                         switch(DeviceAddress & 0xFF000000)
 707                                         {
 708                                                 case CFG_DATAFLASH_LOGIC_ADDR_CS0:
 709                                                         break;
 710                                                 case CFG_DATAFLASH_LOGIC_ADDR_CS3:
 711                                                         break;
 712                                                 default:
 713                                                         command = 0;
 714                                                         break;
 715                                         }
 716
 717                                         if (command != 0) {
 718                                                 AT91F_ReadLine ("RDY ERA\nSure?",
 719                                                                 message);
 720                                                 if(message[0] == 'Y' || message[0] == 'y') {
 721                                                         erase_dataflash(DeviceAddress & 0xFF000000);
 722 //                                                      printf("Erase complete\n\n");
 723                                                 }
 724 //                                              else
 725 //                                                      printf("Erase aborted\n");
 726                                         }
 727                                         command = 0;
 728
 729                                 break;
 730
 731                                 default:
 732                                         command = 0;
 733                                 break;
 734                         }
 735                 }
 736 #ifdef XMODEM
 737                 for(i = 0; i <= AT91C_DOWNLOAD_MAX_SIZE; i++)
 738                         *(unsigned char *)(AddressToDownload + i) = 0;
 739
 740                 xmodemPipe.Read(&xmodemPipe, (char *)AddressToDownload,
 741                                 SizeToDownload, XmodemProtocol, 0);
 742                 while(XmodemComplete !=1);
 743                 SizeToDownload = (unsigned int)((svcXmodem.pData) -
 744                                  (unsigned int)AddressToDownload);
 745
 746                 /* Modification of vector 6 */
 747                 if ((DeviceAddress == CFG_DATAFLASH_LOGIC_ADDR_CS0)) {
 748                         // Vector 6 must be compliant to the BootRom description (ref Datasheet)
 749                         NbPage = 0;
 750                 i = dataflash_info[device].Device.pages_number;
 751                 while(i >>= 1)
 752                         NbPage++;
 753                         i = (SizeToDownload / 512)+1 + (NbPage << 13) +
 754                             (dataflash_info[device].Device.pages_size << 17); //+4 to add crc32
 755                     SizeToDownload = 512 * (i &0xFF);
 756                 }
 757                 else
 758                 {
 759                         /* Save the contents of vector 6 ==> will be restored
 760                          * at boot time (AT91F_StartBoot) */
 761                         *(int *)(AddressToDownload + SizeToDownload + 4) =
 762                                 *(int *)(AddressToDownload + AT91C_OFFSET_VECT6);
 763                         /* Modify Vector 6 to contain the size of the
 764                          * file to copy (Dataflash -> SDRAM)*/
 765                         i = SizeToDownload;
 766                 }
 767
 768                 *(int *)(AddressToDownload + AT91C_OFFSET_VECT6) = i;
 769 //              printf("\nModification of Arm Vector 6 :%x\n", i);
 770
 771 //              printf("\nWrite %d bytes in DataFlash [0x%x]\n",SizeToDownload, DeviceAddress);
 772                 crc1 = 0;
 773                 pAT91->CRC32((const unsigned char *)AddressToDownload, SizeToDownload , &crc1);
 774
 775                 /* Add the crc32 at the end of the code */
 776                 *(char *)(AddressToDownload + SizeToDownload)     = (char)(crc1 & 0x000000FF);
 777                 *(char *)(AddressToDownload + SizeToDownload + 1) = (char)((crc1 & 0x0000FF00) >> 8);
 778                 *(char *)(AddressToDownload + SizeToDownload + 2) = (char)((crc1 & 0x00FF0000) >> 16);
 779                 *(char *)(AddressToDownload + SizeToDownload + 3) = (char)((crc1 & 0xFF000000) >> 24);
 780
 781                 /* write dataflash */
 782                 write_dataflash (DeviceAddress, AddressToDownload, (SizeToDownload + 8));
 783
 784                 /* clear the buffer before read */
 785                 for(i=0; i <= SizeToDownload; i++)
 786                         *(unsigned char *)(AddressToDownload + i) = 0;
 787
 788                 /* Read dataflash to check the validity of the data */
 789                 read_dataflash (DeviceAddress, (SizeToDownload + 4), (char *)(AddressToDownload));
 790
 791                 printf("VFY: ");
 792                 crc2 = 0;
 793
 794                 pAT91->CRC32((const unsigned char *)AddressToDownload, SizeToDownload , &crc2);
 795                 crc1 = (int)(*(char *)(AddressToDownload + SizeToDownload))          +
 796                            (int)(*(char *)(AddressToDownload + SizeToDownload + 1) << 8) +
 797                            (int)(*(char *)(AddressToDownload + SizeToDownload + 2) << 16) +
 798                            (int)(*(char *)(AddressToDownload + SizeToDownload + 3) << 24);
 799
 800                 if (crc1 != crc2)
 801                         printf("ERR");
 802                 else
 803                         printf("OK");
 804
 805                 command = 0;
 806                 XmodemComplete = 0;
 807                 AT91F_WaitKeyPressed();
 808 #endif
 809         }
 810 }
 811