Subversion Repositories openrisc

// Program that will erase and program a flash via cfi_ctrl module

#include "cpu-utils.h"

#include "board.h"

#include "uart.h"

#include "printf.h"

#include "cfi_ctrl.h"

// TODO: detect this manually - it is CFI after all!

#define BLOCK_SIZE_BYTES (128*1024)

//#define VERBOSE_PROGRAMMING

#define VERBOSE_VERIFY_ERRORS

//#define VERIFY_WHEN_WRITE

unsigned long programming_file_start;

unsigned long programming_file_end;

unsigned long programming_file_length;

extern unsigned long userprogram_data, _userprogram_data;

extern unsigned long end_userprogram_data, _end_userprogram_data;

// Globals

int timeout_counter;

volatile char dump;

int programming_base_offset;

#define RESET_PC 0xf0000100

int

console_get_num(void)

{

  char c = 0x30;

  int num_nums = 0;

  int num_nums_total;

  char nums[16]; // up to 16 decimal digits long

  int retval = 0;

  int decimal_multiplier;

  int i;

  printf("Enter decimal value: ");

  while (c >= 0x30 && c < 0x40)

    {

      c = uart_getc(DEFAULT_UART);

      if (c >= 0x30 && c < 0x40)

        {

          printf("%d", c-0x30);

          nums[num_nums] = c-0x30;

          num_nums++;

        }

    }

  printf("\n");

  num_nums_total = num_nums;

  while(num_nums--)

    {

      decimal_multiplier = 1;

      for(i=1;i<num_nums_total - num_nums;i++)

        decimal_multiplier *= 10;

      //printf("%d * %d\n",decimal_multiplier,nums[num_nums]);

      retval += (decimal_multiplier * nums[num_nums]);

    }

  //printf("%d\n",retval);

  return retval;

}

void

console_browse_buffer(char* buf)

{

  char c = 0;

  int offset = 0;

  const int linesize = 16;

  int i;

  printf("Press space to scroll through buffer, q to return\n");

  printf("+/- alter address offset\n");

  cfi_ctrl_enable_data_read();

  while (1)

    {

      c = uart_getc(DEFAULT_UART);

      if (c == 'q')

        return;

      else if (c == 'r')

        offset=0;

      else if (c == '+')

        {

          offset+=linesize;

          printf("%04x:\r",offset);

        }

      else if (c == '-')

        {

          if (offset >=linesize)

            offset-=linesize;

          printf("%04x:\r",offset);

        }

      else if (c == 0x20) // space, print al ine

        {

          printf("%04x:",offset);

          // print another line of the buffer

          for (i=0;i<linesize;i++)

            {

              printf(" %02x", buf[offset+i]&0xff);

            }

          printf("\n");

          offset += linesize;

        }

    }

}

void

delay(int n)

{

  volatile int i=0;

  while(i<n)

    i++;

}

void

timeout_reset(void)

{

  timeout_counter = 0;

}

int

timeout(void)

{

  timeout_counter++;

  if (timeout_counter == 20000)

    {

      printf("timeout\n");

      cfi_ctrl_reset_flash();

      return 1;

    }

  return 0;

}

void

print_cfi_status(void)

{

  char flashid[5];

  int i;

  printf("\tcfi_ctrl flash status:\n");

  printf("Device status byte: 0x%02x\n",cfi_ctrl_get_status()&0xff);

  printf("\n");

  printf("Programming file from 0x%x-0x%x, %d bytes\n",

         programming_file_start, programming_file_end,

         programming_file_length);

  //    printf("Embedded length: %d\n", (unsigned long) userprogram_data);

  printf("Page programming base: %d (set with 'o' command)\n",

         programming_base_offset);

}

void

verify_image(int base_offset, char* data, int length_bytes)

{

  int base_block = base_offset / BLOCK_SIZE_BYTES;

  int num_blocks = (length_bytes/BLOCK_SIZE_BYTES) + 1;

  int i;

  int verify_error = 0;

  printf("\tVerifying %d bytes of image from 0x%08x\n",length_bytes,

         base_offset);

  unsigned int waddr;

  short * data_shorts;

  int short_counter;

  data_shorts = (short*) data;

  // Read the pages

  cfi_ctrl_enable_data_read();

  for(waddr=base_offset, short_counter=0;

      waddr<(base_offset + length_bytes);

      waddr +=2, short_counter++)

    {

      /* Check what we wrote */

      short verify_data = REG16(CFI_CTRL_BASE+waddr);

      if (verify_data != data_shorts[short_counter])

        {

          printf("\tERROR: word verify failed at 0x%08x.\n",waddr);

          printf("\tERROR: Read 0x%04x instead of 0x%04x.\n",verify_data,

                 data_shorts[short_counter]);

          verify_error ++;

        }

    }

  if (verify_error)

    printf("\tVerify complete - %d errors were detected\n",

           verify_error);

  else

    printf("\tImage verified. Press esacpe to boot from 0x%08x.\n",RESET_PC);

}

void

program_image(int base_offset, char* data, int length_bytes)

{

  int base_block = base_offset / BLOCK_SIZE_BYTES;

  int num_blocks = (length_bytes/BLOCK_SIZE_BYTES) + 1;

  int i;

  unsigned int waddr;

  short * data_shorts;

  int short_counter;

  printf("\tErasing blocks (%d - %d)\n",base_block,

         base_block + num_blocks-1);

  // Erase the appropriate blocks

  for(i=base_block;i<base_block + num_blocks;i++)

    {

      printf("\tErasing block %d\n",i);

      cfi_ctrl_unlock_block(i*BLOCK_SIZE_BYTES);

      if (cfi_ctrl_erase_block(i*BLOCK_SIZE_BYTES))

        {

          printf("\tErase failed, trying again\n");

          i--; // Try erasing again

          continue;

        }

    }

  printf("\tErase complete\n");

  printf("\n\tProgramming %d bytes\n", length_bytes);

  data_shorts = (short*) data;

  // Program the pages

  for(waddr=base_offset, short_counter=0;

      waddr<(base_offset + length_bytes);

      waddr +=2, short_counter++)

    {

      if (cfi_ctrl_write_short(data_shorts[short_counter],waddr))

        {

          printf("\tERROR: word program failed at 0x%08x\n",waddr);

          return;

        }

      else

        {

#ifdef VERIFY_WHEN_WRITE

          /* Check what we wrote */

          cfi_ctrl_enable_data_read();

          short verify_data = REG16(CFI_CTRL_BASE+waddr);

          if (verify_data != data_shorts[short_counter])

            {

              printf("\tERROR: word verify failed at 0x%08x.\n",waddr);

              printf("\tERROR: Read 0x%04x instead of 0x%04x.\n",verify_data,

                     data_shorts[short_counter]);

              return;

            }

#endif

        }

    }

  printf("\tProgramming %d bytes complete\n", length_bytes);

}

#define printhelp() printf("\nUsage: \n \

\t[p]rogram\t\terase req. blocks, write image to flash\n \

\t[o]ffset\t\tset page offset to write to\n \

\t[v]erify\t\tverify written program\n \

\t[s]tatus\t\tprint status of CFI flash\n \

\t[e]rase\t\t\terase block of CFI flash\n \

\t[r]ead\t\t\tread, browse page of CFI flash\n \

\t[i]nspect\t\tinspect page of image in RAM\n \

\t[R]eset\t\t\treset CFI flash controller\n \

\t[ESC]\t\t\treset by jumping to 0x%08x\n \

\n",RESET_PC)

int

main()

{

  uart_init(0); // init the UART before we can printf

  volatile char c;

  int i,j;

  programming_base_offset = 0;

  programming_file_start = (unsigned long) &userprogram_data;

  programming_file_end = (unsigned long) &end_userprogram_data;

  programming_file_length = programming_file_end - programming_file_start;

  printf("\n\n\tcfi_ctrl flash programming app\n\n");

  printf("\ttype 'h' for help menu\n\n");

  while(1){

    printf(" > ");

    c = uart_getc(DEFAULT_UART);

    printf("%c",c);

    printf("\n");

    if (c == 'h')

      printhelp();

    else if (c == 's')

      print_cfi_status();

    else if (c == 'c')

      cfi_ctrl_clear_status();

    else if (c == 'p')

      program_image(programming_base_offset,

                    (char *) &userprogram_data,

                    programming_file_length);

    else if (c == 'v')

      verify_image(programming_base_offset,

                   (char *) &userprogram_data,

                   programming_file_length);

    else if (c == 'o')

      {

        printf("Enter byte offset to program from.\n");

        programming_base_offset = console_get_num();

      }

    // Support/debug commands:

    else if (c == 'e')

      {

        printf("Erase a block.\n");

        i = console_get_num();

        // program a specific page

        cfi_ctrl_erase_block_no_wait(i*BLOCK_SIZE_BYTES);

      }

    else if (c == 'r')

      {

        printf("Inspect memory.\n");

        i = console_get_num();

        // read a page

        console_browse_buffer((char*)CFI_CTRL_BASE + i);

      }

    else if (c == 'i')

      {

        printf("Inspect image to program.\n");

        console_browse_buffer((char*) &userprogram_data);

      }

    else if (c == 'R')

      {

        printf("Reset command to controller\n");

        cfi_ctrl_reset_flash();

      }

    else if (c == 0x1b) // Esacpe key

      {

        // Reset

        void (*reset_function) (void) =

          (void *)RESET_PC;

        (*reset_function)();

      }

  }

  return 0;

}