Subversion Repositories layer2

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

 * void - Bootloader Version 0.2.2                                            *

 ******************************************************************************

 * Copyright (C)2011  Mathias Hörtnagl <mathias.hoertnagl@gmail.com>          *

 *                                                                            *

 * This program is free software: you can redistribute it and/or modify       *

 * it under the terms of the GNU General Public License as published by       *

 * the Free Software Foundation, either version 3 of the License, or          *

 * (at your option) any later version.                                        *

 *                                                                            *

 * This program is distributed in the hope that it will be useful,            *

 * but WITHOUT ANY WARRANTY; without even the implied warranty of             *

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              *

 * GNU General Public License for more details.                               *

 *                                                                            *

 * You should have received a copy of the GNU General Public License          *

 * along with this program.  If not, see <http://www.gnu.org/licenses/>.      *

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

#include "stdio.h"

#include "stdlib.h"

#include "flash.h"

#include "ui.h"

#include "view.h"

#define DDR_ADDRESS ((volatile uint *) 0x20000000)

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

 * Upload View                                                                *

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

/* Wait until a flash write is completed and check for errors. */

void checkFlashWrite() {

   uchar state;         // Flash state.

   // Error checking.

   state = flash_wait();

   if(state & FLASH_BLOCK_LOCKED) {

      drawErrorWindow(&errErrorFlashLocked);

      return 0;

   }

   if(state & FLASH_PROGRAM_ERROR) {

      drawErrorWindow(&errErrorFlashWrite);

      return 0;

   }

}

/* NOTE: Automatic deduction of the number of blocks, that need to be erased

         has not been tested extensive. */

void upload() {

   uint size;           // Image size.

   uint step;           // Progress bar step size.

   uint cval;           // Current progress value.

   // Clear screen.

   cls();

   // User Upload Menu.

   drawWindow(&wUpload);

   // Upload Initialization.

   drawMessage(&wUpload, &msgUploadWait);

   pbUpload.val = 0;

   drawProgressBar(&wUpload, &pbUpload);

   // Receive 4 bytes of size data.

   for(uchar i=0; i < 4; i++) {

      size <<= 8;

      size += rs232_receive();

   }

   // Check for image size to fit into flash.

   if(size > FLASH_BLOCK_SIZE * FLASH_BLOCKS) {

      drawErrorWindow(&errErrorFlashSize);

      return 0;

   }

   // Flash Clean Up.

   drawMessage(&wUpload, &msgUploadErase);

   pbUpload.val = 0;                         // Reset progress bar.

   drawProgressBar(&wUpload, &pbUpload);

   // Erase affected flash blocks.

   for(uint i=0; i < (size / FLASH_BLOCK_SIZE) + 1; i++) {

      flash_block_erase(i * FLASH_BLOCK_SIZE);

      // Update the Progress Bar.

      pbUpload.val = (i >> 1);

      drawProgressBar(&wUpload, &pbUpload);

      // Check for errors while erasing.

      if(flash_wait() & FLASH_ERASE_ERROR) {

         drawErrorWindow(&errErrorFlashErase);

         return 0;

      }

   }

   // Write image size at flash address 0x0.

   for(uchar i=0; i<4; i++) {

      flash_write(i, size >> ((3-i) * 8) );

      checkFlashWrite();

   }

   // Upload data.

   drawMessage(&wUpload, &msgUploadWrite);

   pbUpload.val = 0;                         // Reset progress bar.

   step = size / 64;                         // Calculate progress step size.

   cval = step;

   // Echoing received image size.

   for(uchar i=0; i<4; i++) {

      rs232_transmit( size >> ((3-i) * 8) );

   }

   // Write each single byte to Flash.

   for(uint i=0; i < size; i++) {

      flash_write(i + 4, rs232_receive());

      // Update status bar.

      if(i == cval) {

         pbUpload.val++;

         drawProgressBar(&wUpload, &pbUpload);

         cval += step;

      }

      checkFlashWrite();

   }

   // Go back to main menu.

   boot();

}

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

 * DDR Load View                                                              *

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

/* Load Flash contents into DDR.

   Input:

      start    Image start address on flash.

      size     Image size.

 */

void load(uint start, uint size) {

   uint step;           // Progress bar step size.

   uint cval;           // Current progress value.

   cls();

   // User Upload Menu.

   drawWindow(&wDDRUpload);

   // Upload Initialization.

   pbUpload.val = 0;

   drawProgressBar(&wDDRUpload, &pbUpload);

   step = size / 64;

   cval = step;

   // Copy flash data to DDR2 memory.

   // NOTE: Missing bytes, if binary file is not 4 bytes aligned.

   for(uint i=0; i < (size / 4); i++) {

      DDR_ADDRESS[i] = flash_read(i + start);

      // Update status bar.

      if(i == cval) {

         pbUpload.val++;

         drawProgressBar(&wUpload, &pbUpload);

         cval += step;

      }

   }

}

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

 * Memory View                                                                *

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

#define NUM_OF_WORDS 77

/* TODO: Cleaner generic version.

   Quick and dirty implementation of an memory matrix view. Shows the next

   'NUM_OF_WORDS' starting at location 'adr' of the Flash and the DDR memory

   device. */

void show_memory_contents(uint adr) {

   uchar b;

   uchar t;

   b = 0; t = 0;

   for(uint i=adr; i < adr + NUM_OF_WORDS; i++) {

      if(b == 0) {

         gotoxy(6, 4 + t++);

         printf("$y%x:$w ", FLASH_MEMORY + (i << 2));

      }

      printf("%x ", flash_read(i));

      if(b++ == 6) b = 0;

   }

   b = 0; t = 0;

   for(uint i=adr; i < adr + NUM_OF_WORDS; i++) {

      if(b == 0) {

         gotoxy(6, 20 + t++);

         printf("$y%x:$w ", DDR_ADDRESS + i);

      }

      printf("%x ", DDR_ADDRESS[i]);

      if(b++ == 6) b = 0;

   }

}

/* View the memory contents of the Flash and DDR devices. Navigate through the

   address space with ARROW UP and DOWN keys. Returns to the boot loader on

   ESC key pressed. */

void view_memories() {

   uint adr = 0;

   cls();

   drawWindow(&wFlashMemory);

   drawWindow(&wDDRMemory);

   // Show contetnts starting at address 0 at the beginning.

   show_memory_contents(0);

   while(TRUE) {

      switch(getc()->chr) {

         case KEY_ARROWD:

            adr += NUM_OF_WORDS;

            show_memory_contents(adr);

            break;

         case KEY_ARROWU:

            if(adr >= NUM_OF_WORDS) adr -= NUM_OF_WORDS;

            show_memory_contents(adr);

            break;

         case KEY_ESC:

            boot();

            break;

         default:

            break;

      }

   }

}

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

 * Boot View                                                                  *

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

/* Wait for completed flash initialization. Set up main menu box. */

int main() {

   uchar s;

   // Clear screen.

   cls();

   // Wait for flash hardware initialization end.

   s = flash_wait();

   // Flash not ready.

   if( !(s & FLASH_READY) ) {

      drawErrorWindow(&errFlashNotReady);

      return 0;

   }

   // Flash command error.

   if(s & FLASH_CMD_ERROR) {

      drawErrorWindow(&errFlashState);

      flash_clear_sr();

      //boot();

      return 0;

   }

   // User Main Menu.

   drawWindow(&wBoot);

   while(TRUE) {

      switch(getc()->chr) {

         case KEY_ARROWD:

            menuKeyDown(&wBoot, &menu);

            break;

         case KEY_ARROWU:

            menuKeyUp(&wBoot, &menu);

            break;

         case KEY_ENTER:

            switch(menu.index) {

               case OPTION_UPLOAD:

                  upload();

                  break;

               case OPTION_MEMORY:

                  view_memories();

                  break;

               case OPTION_START:

                  load(1, flash_read(0));

                  start();

                  break;

               default:

                  break;

            }

            break;

         default:

            break;

      }

   }

}