tools/build-R2_19_3/fsboot/cbl/common.c

Go to the documentation of this file.

/*!***************************************************************************
*!
*! FILE NAME  : common.c
*!
*! DESCRIPTION: Level 2 loader common for serial and network boot.
*!
*! ---------------------------------------------------------------------------
*! (C) Copyright 1998-2006, Axis Communications AB, LUND, SWEDEN
*!***************************************************************************/

#include <e100boot.h>   
#include <ser_defs.h>
#include <config_defs.h>
#include <timer_defs.h>
#include <stdio.h>
#include <cbl.h>
#include <nand/rflflash.h>
#include <nandwr.h>

extern byte __Stext[];
extern byte __Edata[];

FILE *stdin;
FILE *stdout;
FILE *stderr;

extern udword seq;
extern char svinto_boot_version[];

byte change_baudrate;
udword new_baudrate;
reg_config_r_bootsel r_bootsel;

/************************************************************************/
/* function prototypes */

void (*send_ack)(void)              = send_net_ack;
void (*send_hex)(udword h, byte nl) = send_net_hex;
void (*send_string)(char *str)      = send_net_string;
static void read_file(byte* addr, udword size);
static int  memory_test(udword from, udword to, udword *failed_address);
static void memory_dump(udword *from, udword *to);
static void read_file(byte* addr, udword size);
static void read_file(byte* addr, udword size);
static void read_load_info(void);
static void decode_load_info(void);
static void toggle_led(void);

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

void 
next_level_boot(void)
{
  init_libc();

  {
    r_bootsel = REG_RD(config, regi_config, r_bootsel);
    
    if (r_bootsel.boot_mode == regk_config_ser) {
      send_string = send_ser_string;
      send_ack    = send_ser_ack;
      send_hex    = send_ser_hex;
    }
    else {
      net_init(2);
    }
  }

  stdout = stderr = freopen("/dev/eth0", "w", stdout);

  printf("\r\n\r\nDevice ID = %8.8x\r\n", NTOHL(tx_header.id));
  printf(svinto_boot_version);

  {
    udword sum = 0;
    byte *b;
      
    for (b=(byte*)__Stext; b != (byte*)__Edata; b++) {
      sum+=*b;
    }
    send_string("Checksum of bootloader is ");
    send_hex(sum, NL);
  }

  read_load_info();
  
  while(1) {
    ;
  }
}

static void 
toggle_led(void)
{

#if 0
  REG_SET(R_PORT_PA_DATA, data_out, 0x55);
  
  while(1) {
    REG_SET(R_PORT_PA_DATA, data_out, ~REG_GET(R_PORT_PA_READ, data_in));
    {
      volatile udword i;
      
      for(i=0; i!=2000000; i++);
    }
  }
#endif
}

static void
read_load_info(void)
{
  change_baudrate = 0;
  
  send_string("Waiting for load info.\r\n");

  send_ack();
  read_file((byte*)IO_BUF_START, IO_BUF_END - IO_BUF_START - CRC_LEN);
  send_string("Got load info.\r\n");

  decode_load_info();

#if 0  
  if (change_baudrate) {
    reg_ser_rw_rec_baud_div rw_rec_baud_div = {0,};
    reg_ser_rw_tr_baud_div  rw_tr_baud_div  = {0,};

    rw_tr_baud_div.divisor  = new_baudrate;
    rw_rec_baud_div.divisor = new_baudrate;

    REG_WR(ser, regi_ser0, rw_rec_baud_div, rw_rec_baud_div);
    REG_WR(ser, regi_ser0, rw_tr_baud_div,  rw_tr_baud_div);
    {
      udword i = 0;
      
      while (i++ < 1000000);
    }
    send_ack();
    
  }
#endif
  toggle_led();
}

static void
packet_info(packet_info_T *packet_info)
{
  
  send_string("PACKET_INFO\r\n");
  send_hex(packet_info->addr, NL);
  send_hex(packet_info->size, NL);
  
  send_ack();
  
  read_file((byte*)packet_info->addr, packet_info->size);
}

static void 
set_register(set_register_T *set_register)
{

  send_string("SET_REGISTER\r\n");
  send_hex(set_register->addr, NL);
  send_hex(set_register->val, NL);
  *(udword*)set_register->addr = set_register->val;

}

static void 
pause_loop(pause_loop_T *pause_loop)
{

  send_string("PAUSE_LOOP\r\n");
  send_hex(pause_loop->pause, NL);
  pause_loop = (pause_loop_T*)pause_loop->pause; /* reuse pointer as counter */
  for (;(udword)pause_loop;((udword)pause_loop)--);
}

static void 
get_register(get_register_T *get_register)
{

  send_string("GET_REGISTER\r\n");
  send_hex(get_register->addr, NL);
  send_hex(*(udword*)get_register->addr, NL);

}

static void 
mem_verify(mem_verify_T *mem_verify)
{

  send_string("MEM_VERIFY\r\n");
  send_hex(mem_verify->addr, NL);
  send_hex(mem_verify->val, NL);
  if (*(udword*)mem_verify->addr != mem_verify->val) {
    send_string("verify failed\r\n");
    read_load_info();
  }
}

static void 
mem_test(mem_test_T *mem_test)
{
  send_string("MEM_TEST\r\n");
  udword failed_address;
  send_hex(mem_test->from, NL);
  send_hex(mem_test->to, NL);
  
  if (!memory_test(mem_test->from, mem_test->to, &failed_address)) {
    send_string("### Memory test failed at ");
    send_hex(failed_address, NL);
    memory_dump((udword*)DWORD_ALIGN(failed_address - 64), (udword*)DWORD_ALIGN(failed_address + 64));
    read_load_info();
  }
  send_string("Passed memory test.\r\n");
  
}

static void 
mem_dump(mem_dump_T *mem_dump)
{
  send_string("MEM_DUMP\r\n");
  send_hex(mem_dump->from_addr, NL);
  send_hex(mem_dump->to_addr, NL);
  memory_dump((udword*)mem_dump->from_addr, (udword*)mem_dump->to_addr);
}

static void
mem_clear(mem_clear_T *mem_clear)
{
  send_string("MEM_CLEAR\r\n");
  send_hex(mem_clear->from_addr, NL);
  send_hex(mem_clear->to_addr, NL);
  {
    udword i;
    
    for (i=mem_clear->from_addr; i <= mem_clear->to_addr; i++) {
      *(byte*)i = 0x00;
    }
  }
}

static void 
jump(jump_T *jump)
{
  
  /* for the printf function in our libc */
#if 0
  REG_WR(R_DMA_CH8_FIRST, *(udword*)&tx_header.dest[0]);
  REG_WR(R_DMA_CH9_FIRST, *(uword*)&tx_header.dest[4]);
  
  send_hex(REG_RD(R_DMA_CH8_FIRST), NL);
  send_hex(REG_RD(R_DMA_CH9_FIRST), NL);
#endif
  send_string("JUMP\r\n");
  send_hex(jump->addr, NL);
  __asm__ volatile ("\n\
jump %0\n\
nop\n\
" :: "r" (jump->addr));    
}

static void 
decode_load_info(void)
{
  udword *type_p = (udword*)IO_BUF_START;
  udword i;
  /* dword counter last in buffer */
  udword dword_cnt = NTOHL(*(udword*)(IO_BUF_END-CRC_LEN-sizeof(udword))); 
  
  /* ntohl the commands in command buffer */
  for(i=0; i<=dword_cnt; i++) {
    type_p[i] = NTOHL(type_p[i]);
  }

  /* loop through and execute all commands */
  while (*type_p != END_OF_CMDS) {

    switch (*type_p) {

    case PACKET_INFO: {
      packet_info((packet_info_T*)type_p);
      (byte*)type_p += sizeof(packet_info_T);
      break;
    }

    case SET_REGISTER: {
      set_register((set_register_T*)type_p);
      (byte*)type_p += sizeof(set_register_T);
      break;
    }    
      
    case GET_REGISTER: {
      get_register((get_register_T*)type_p);
      (byte*)type_p += sizeof(get_register_T);
      break;
    }

    case PAUSE_LOOP: {
      pause_loop((pause_loop_T*)type_p); 
      (byte*)type_p += sizeof(pause_loop_T);
      break;
    }

    case MEM_VERIFY: {
      mem_verify((mem_verify_T*)type_p);
      (byte*)type_p += sizeof(mem_verify_T);
      break;
    }

    case MEM_TEST: {
      mem_test((mem_test_T*)type_p);
      (byte*)type_p += sizeof(mem_test_T);
      break;
    }

    case MEM_DUMP: {
      mem_dump((mem_dump_T*)type_p);
      (byte*)type_p += sizeof(mem_dump_T);
      break;
    }

    case MEM_CLEAR: {
      mem_clear((mem_clear_T*)type_p);
      (byte*)type_p += sizeof(mem_clear_T);
      break;
    }

    case FLASH: {
      send_string("FLASH\r\n");
      send_hex((udword)((flash_T*)(type_p))->source, NL);
      send_hex((udword)((flash_T*)(type_p))->dest, NL);
      send_hex((udword)((flash_T*)(type_p))->size, NL);
      if (flash_write((unsigned)((flash_T*)(type_p))->source,
                      (unsigned)((flash_T*)(type_p))->dest,
                      ((flash_T*)(type_p))->size) != ERR_FLASH_OK) {
        read_load_info();
      }
      (byte*)type_p += sizeof(flash_T);
      break;
    }

      
    case NAND_FLASH: {
      send_string("NAND_FLASH\r\n");
      send_hex((udword)((nand_flash_T*)(type_p))->source, NL);
      send_hex((udword)((nand_flash_T*)(type_p))->dest, NL);
      send_hex((udword)((nand_flash_T*)(type_p))->maxdest, NL);
      send_hex((udword)((nand_flash_T*)(type_p))->size, NL);
      rflflash_init();
      rflflash_write(((nand_flash_T*)(type_p))->source, 
                     ((nand_flash_T*)(type_p))->dest,
                     ((nand_flash_T*)(type_p))->maxdest, 
                     ((nand_flash_T*)(type_p))->size);
      
      (byte*)type_p += sizeof(nand_flash_T);
      break;
    }

    case NAND_FLASH_DUMP: {
      send_string("NAND_FLASH_DUMP\r\n");
      send_hex((udword)((mem_dump_T*)(type_p))->from_addr, NL);
      send_hex((udword)((mem_dump_T*)(type_p))->to_addr, NL);
      rflflash_dump((udword)((mem_dump_T*)(type_p))->from_addr,
                    (udword)((mem_dump_T*)(type_p))->to_addr);
      (byte*)type_p += sizeof(mem_dump_T);
      break;
    }

    case NAND_FLASH_IGNORE_BAD: {
      send_string("NAND_FLASH_IGNORE_BAD\r\n");
      rflflash_ignore_bad();
      (byte*)type_p++;
      break;
    }

    case NAND_FLASH_MARK_BAD: {
      send_string("NAND_FLASH_MARK_BAD\r\n");
      send_hex((udword)((mem_dump_T*)(type_p))->from_addr, NL);
      send_hex((udword)((mem_dump_T*)(type_p))->to_addr, NL);
      rflflash_mark_bad((udword)((mem_dump_T*)(type_p))->from_addr,
                       (udword)((mem_dump_T*)(type_p))->to_addr);
      (byte*)type_p += sizeof(mem_dump_T);
      break;
    }

    case NAND_FLASH_ERASE: {
      send_string("NAND_FLASH_ERASE\r\n");
      send_hex((udword)((mem_dump_T*)(type_p))->from_addr, NL);
      send_hex((udword)((mem_dump_T*)(type_p))->to_addr, NL);
      rflflash_nand_do_erase((udword)((mem_dump_T*)(type_p))->from_addr,
                          (udword)((mem_dump_T*)(type_p))->to_addr);
      (byte*)type_p += sizeof(mem_dump_T);
      break;
    }

    case NAND_FLASH_OOB_DUMP: {
      send_string("NAND_FLASH_OOB_DUMP\r\n");
      send_hex((udword)((mem_dump_T*)(type_p))->from_addr, NL);
      send_hex((udword)((mem_dump_T*)(type_p))->to_addr, NL);
      rflflash_dump_oob((udword)((mem_dump_T*)(type_p))->from_addr,
                        (udword)((mem_dump_T*)(type_p))->to_addr,
                        0);
      (byte*)type_p += sizeof(mem_dump_T);
      break;
    }

    case NAND_FLASH_OOB_DUMP_BAD: {
      send_string("NAND_FLASH_OOB_DUMP_BAD\r\n");
      send_hex((udword)((mem_dump_T*)(type_p))->from_addr, NL);
      send_hex((udword)((mem_dump_T*)(type_p))->to_addr, NL);
      rflflash_dump_oob((udword)((mem_dump_T*)(type_p))->from_addr,
                        (udword)((mem_dump_T*)(type_p))->to_addr,
                        1);
      (byte*)type_p += sizeof(mem_dump_T);
      break;
    }

#if 0
      /* for testing */
    case STUPID_NAND_FLASH: {
      send_string("STUPID_NAND_FLASH\r\n");
      nandwr();
      (byte*)type_p += sizeof(flash_T);
      break;
    }
#endif
      
    case RESTART_FS: {
      send_string("RESTART_FS\r\n");
      {
        reg_timer_rw_wd_ctrl rw_wd_ctrl = {
          .cmd = regk_timer_yes,
          .cnt = 0
        };
        REG_WR(timer, regi_timer, rw_wd_ctrl, rw_wd_ctrl);
      }
      (byte*)type_p++;
      break;
    }

    case JUMP: {
      jump((jump_T*)type_p);
      (byte*)type_p += sizeof(jump_T);
      break;
    }

    case LOOP: {
      send_string("LOOP\r\n");
      bne_T *bne = (bne_T*)type_p;
      send_hex(bne->addr, NL);
      send_hex(bne->target, NL);
      if (*(udword*)bne->addr) {
        (*(udword*)bne->addr)--;
        (byte*)type_p = bne->target;
      }
      else {
        (byte*)type_p += sizeof(bne_T);
      }
      break;
    }

    case BAUDRATE: {
      send_string("BAUDRATE\r\n");
      send_hex(((br_T*)type_p)->baudrate, NL);
      new_baudrate = ((br_T*)type_p)->baudrate;
      break;
    }

    default: {
      send_string("### Unknown type : ");
      send_hex(*type_p, NL);
      read_load_info();
      break;
    }
    }
  }
  
  send_string("END\r\n");
}

static void 
read_file(byte* addr, udword size)
{
  udword nbr_read_last;
  byte *b;
  byte *from;
  
  //  send_string(">read_file\r\n");
  
  nbr_read = 0;
  nbr_read_last = 0;
  
  if (r_bootsel.boot_mode != regk_config_ser) {
    //    net_init();    
    rx_descr2.buf    = (char*)addr;
    bytes_to_read    = size;
    rx_descr2.after  = rx_descr2.buf+(size + CRC_LEN > 1500 ? 1500 : size + CRC_LEN);
    
    init_dma1();
    
    while (nbr_read < size) {

      if (rx_descr2.in_eop == regk_dma_yes) { /* got a packet? */

        /* was it to us? */
        volatile unsigned bip = handle_network_read() - sizeof(struct packet_header_T);
        nbr_read_last = nbr_read;

#if 0
        {
          send_string("Read ");
          send_hex(bip, NO_NL);
          send_string(" bytes. ");
          send_hex((udword)from, NO_NL);
          send_string(" - ");
          send_hex(rx_descr2.buf-1, NO_NL);
          send_string(" (");
          send_hex(nbr_read, NO_NL);
          send_string("/");
          send_hex(size, NO_NL);
          send_string(")\r\n");
          from +=bip;
        }
#endif
      }

      if (timeout()) {
        send_net_ack();
      }

    }
  }
  else  {  /* interface != NETWORK */
    bytes_to_read    = size;

    while (nbr_read < size) {  
      reg_ser_rs_stat_din rs_stat_din = REG_RD(ser, regi_ser0, rs_stat_din);
      
      if (rs_stat_din.dav == regk_ser_yes) {
        *(char*)(addr + nbr_read++)  = rs_stat_din.data; 
        last_timeout = REG_RD(timer, regi_timer, r_time);
      }
      
#if 0
      if (timeout()) {
        send_ser_ack();
      }
#endif
    }
  }

  if(0)
  {
    udword sum;
    
    sum = 0;
    for (b=addr; b != (byte*)(addr+size); b++) {
      sum^=(*b);
      sum = sum<<1 | sum>>31;   /* rotl */
    }
    send_string("Checksum of file is ");
    send_hex(sum, NL);
  }

  /*  send_string("<read_file\r\n");*/
  
}

#if 0
static void 
print_descr(dma_descr_data *d)
{
  
  send_string("Descriptor at ");
  send_hex((udword)d, NL);
  
  send_string("ctrl   : ");
  send_hex(d->ctrl, NL);
  
  send_string("sw_len : ");
  send_hex(d->sw_len, NL);
  
  send_string("next   : ");
  send_hex(d->next, NL);
  
  send_string("buf    : ");
  send_hex(d->buf, NL);
  
  send_string("status : ");
  send_hex(d->status, NL);
  
  send_string("hw_len : ");
  send_hex(d->hw_len, NL);
  
}
#endif

static int
memory_test(udword from, udword to, udword *failed_address)
{
  udword i;
  udword j;
  byte b;
  
  /* 
     At each dword (but bytewise) write the inverse of the adress,
     check that it worked, then write the inverse of the last byte
     written. Exit on fail. The memory after a successfull test will
     be: 

     0xC0000000 : 0xC0000000 0xC0000004 0xC0000008 0xC000000C
     0xC0000010 : 0xC0000010 0xC0000014 0xC0000018 0xC000001C
     */

send_string("\nMemory test 1:");
  for (i=from; i<to; i+=4) {
if((i & 0xfffff) == 0) send_string(".");
    for (j=0; (j != sizeof(udword)) && (i+j < to); j++) {
      b = ((~i)>>(j*8)) & 0xff;
      *(volatile byte*)(i+j) = b;
      if (*(volatile byte*)(i+j) == b) {
        *(volatile byte*)(i+j) = ~b;
      }
      else {
        *failed_address = i+j;
                send_string("### Memory test 1 failed at ");
                send_hex(*failed_address, NL);
        return(FALSE);
      }
    }
  }

  /* Now check for mirrored memory. Run through entire region, check
     bytewise that the dwords contain the address to the dword. Exit
     on fail. */
  
send_string("\nMemory test 2:");
  for (i=from; i<to; i+=4) {
if((i & 0xfffff) == 0) send_string(".");
    for (j=0; (j != sizeof(udword)) && (i+j < to); j++) {
      b = ((i)>>(j*8)) & 0xff;
      if (*(volatile byte*)(i+j) != b) {
        *failed_address = i+j;
        send_string("### Memory test 2 failed at ");
        send_hex(*failed_address, NL);
        return(FALSE);
      }
    }
  }

  return(TRUE);
}

static void
memory_dump(udword *from, udword *to)
{
  udword *i = from;
  int j;
  
  for (; i <= to; i+=4) {
    printf("%8.8x :", i);
    for(j=0; j != 4 && (i+j <= to); j++) {
      printf(" %8.8x", *(udword*)(i+j));
    }
    printf("\r\n");
  }
}

---