common.c

linux平台上的开放源代码的网络摄像机程序.实现视频捕捉,传输以及云台控制等.非常具有参考价值.

// modified by Andrey (as in old version 2 lines for port0 c115k2Hz->c19k2Hz)
// modified by Andrey (another 2 - for port 1)
// Added bcm52x1 support (txled) and leds on during memory flashing
// had to remove unnecessary - stack lower ~400-450 - fails
//
//#define DEBUG_HARDWARE
// remove later - to kernel config
//#define CONFIG_SERIAL0_BAUD_XX 0x66
//#define CONFIG_SERIAL1_BAUD_XX 0x66
//#define CONFIG_SERIAL2_BAUD_XX 0x66
//#define CONFIG_SERIAL3_BAUD_XX 0x66
//#define CONFIG_BCM5221

// try defines for baud rate
//#include <linux/config.h> //needs /target that may not exist yet
#include <../../../os/linux/include/linux/autoconf.h>

#include <serialdefines.h>
#include <sv_addr_ag.h>
#include <svinto_boot.h>	
#include <svinto_boot_version.h>

extern byte *_Stext;
extern byte *bss_start;

char pad[] = "jllkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk";

#ifdef CONFIG_BCM5221
void bcm52x1_txled();
void bcm52x1_led_force();
void bcm52x1_led_release();
#endif
#ifdef CONFIG_BCM5201
//void bcm52x1_txled();
void bcm52x1_led_force();
void bcm52x1_led_release();
#endif

unsigned short e100_get_mdio_reg(unsigned char reg_num);
void e100_set_mdio_reg(unsigned char reg_num, unsigned short data);
void mii_get(int a);


void 
send_parallel_string(char *str)
{
  
}

void
send_parallel_ack()
{
  
}

byte
crc_correct()
{
  return(FALSE);
}

void
level2_boot()
{

  int i;
  int boot_interface = ((*R_BUS_STATUS & IO_MASK(R_BUS_STATUS, boot))
			>> IO_BITNR(R_BUS_STATUS, boot)) - 1;
#if 0 // Andrey
  byte *b;
  udword sum;
#endif // Andrey

  io_buf_next    = (byte*)IO_BUF_START;
  io_buf_cur     = (byte*)IO_BUF_START;

  if (boot_interface != SERIAL) {
    ser_init();
#ifndef CONFIG_DEBUG_PORT_NONE

    *R_SER_BAUD =
#ifdef CONFIG_DEBUG_PORT0      
//      IO_STATE(R_SERIAL0_BAUD, tr_baud, c115k2Hz) |
//      IO_STATE(R_SERIAL0_BAUD, rec_baud, c115k2Hz);
//      IO_STATE(R_SERIAL0_BAUD, tr_baud, c19k2Hz) |
//      IO_STATE(R_SERIAL0_BAUD, rec_baud, c19k2Hz);
      CONFIG_SERIAL0_BAUD_XX;

#endif
#ifdef CONFIG_DEBUG_PORT1
//    IO_STATE(R_SERIAL1_BAUD, tr_baud, c115k2Hz) |
//      IO_STATE(R_SERIAL1_BAUD, rec_baud, c115k2Hz);
//    IO_STATE(R_SERIAL1_BAUD, tr_baud, c19k2Hz) |
//      IO_STATE(R_SERIAL1_BAUD, rec_baud, c19k2Hz);


      CONFIG_SERIAL1_BAUD_XX;
#endif
#ifdef CONFIG_DEBUG_PORT2
//    IO_STATE(R_SERIAL2_BAUD, tr_baud, c115k2Hz) |
//      IO_STATE(R_SERIAL2_BAUD, rec_baud, c115k2Hz);
      CONFIG_SERIAL2_BAUD_XX;

#endif
#ifdef CONFIG_DEBUG_PORT3
//    IO_STATE(R_SERIAL3_BAUD, tr_baud, c115k2Hz) |
//      IO_STATE(R_SERIAL3_BAUD, rec_baud, c115k2Hz);
      CONFIG_SERIAL3_BAUD_XX;

#endif
#endif
    for(i=0; i!= 100000; i++);
    send_serial_string("\r\n\r\nSerial interface initialized.\r\n");
    /*    print_descr((dma_descr_T*)&rx_descr);*/
    /*    print_descr((dma_descr_T*)&rx_descr2);*/
    /*    memory_dump(&_Stext, &bss_start);*/
  }
  if (boot_interface != NETWORK) {
    net_init();
    send_network_string("NTW initialized .\r\n");
  }
  
//#if 0 //was 1
  send_serial_string("\r\n\r\nDevice ID = ");
  send_serial_hex(ntohl(tx_header.id), NL);
  send_serial_string(svinto_boot_version);
//#endif

#if 0 //was 1
  sum = 0;

  for (b=(byte*)&_Stext; b != (byte*)&bss_start; b++) {
    sum+=*b;
  }

  send_serial_string("bootloader CS= ");
  send_serial_hex(sum, NL);

#endif
#if 0
  mii_get(0x1a);
  e100_set_mdio_reg(0x1a, 0x1f00);
  mii_get(0x1a);
  mii_get(0x1f);
  e100_set_mdio_reg(0x1f, 0x80);
  mii_get(0x1a);
  e100_set_mdio_reg(0x1a, 0x3010);
#endif

#ifdef CONFIG_BCM5221
  bcm52x1_txled();
#endif

  read_load_info();
  
  __asm__ volatile ("jump _boot_crt1");  
}

#if 0 // Andrey
void 
toggle_led()
{
  volatile udword i;

  *R_PORT_PA_DATA = 0x55;
  
  while(1) {
    *R_PORT_PA_DATA = ~(*R_PORT_PA_READ & IO_MASK(R_PORT_PA_READ, data_in));
    for(i=0; i!=2000000; i++);
  }
}
#endif // Andrey
void
read_load_info()
{

  send_serial_string("Waiting for load info.\r\n");

  seq--;
  send_ack[interface]();
  seq++;
  
  read_file((byte*)IO_BUF_START, IO_BUF_END - IO_BUF_START + 1 - CRC_LEN);
  send_serial_string("Got load info.\r\n");
  decode_load_info();
#if 0 // Andrey
  toggle_led();
#endif // Andrey
}

void 
decode_load_info()
{
  udword         *type_p = (udword*)IO_BUF_START;
  packet_info_T  *packet_info;
  set_register_T *set_register;
  get_register_T *get_register;
  pause_loop_T   *pause_loop;
  mem_verify_T   *mem_verify;
  udword          failed_address;
  mem_test_T     *mem_test;
  jump_T         *jump;
  udword         i;

  while (type_p != (udword*)(IO_BUF_END + 1 - CRC_LEN)) { /* !!! */
    /*    send_serial_hex(type_p);*/
    *type_p = ntohl(*type_p);
    /*    send_serial_hex(*type_p, NL);*/
    type_p++;
  }
  /*  memory_dump(IO_BUF_START, IO_BUF_END);*/
  type_p = (udword*)IO_BUF_START;
  
  while (*type_p) {
    switch (*type_p) {
    case PACKET_INFO:
      send_serial_string("PACKET_INFO\r\n");
      packet_info = (packet_info_T*)type_p;
      send_serial_hex(packet_info->addr, NL);
      send_serial_hex(packet_info->size, NL);

      seq--;
      send_ack[interface]();
      seq++;
      
      read_file((byte*)packet_info->addr, packet_info->size);
      (byte*)type_p += sizeof(packet_info_T);
      break;
      
    case SET_REGISTER:
      send_serial_string("SET_REGISTER\r\n");
      set_register = (set_register_T*)type_p;
      send_serial_hex(set_register->addr, NL);
      send_serial_hex(set_register->val, NL);
      *(udword*)set_register->addr = set_register->val;
      (byte*)type_p += sizeof(set_register_T);
      break;

    case GET_REGISTER:
      send_serial_string("GET_REGISTER\r\n");
      get_register = (get_register_T*)type_p;
      send_serial_hex(get_register->addr, NL);
      send_serial_hex(*(udword*)get_register->addr, NL);
      (byte*)type_p += sizeof(get_register_T);
      break;

    case PAUSE_LOOP:
      send_serial_string("PAUSE_LOOP\r\n");
      pause_loop = (pause_loop_T*)type_p;
      send_serial_hex(pause_loop->pause, NL);
      for (i = pause_loop->pause;i;i--);
      (byte*)type_p += sizeof(pause_loop_T);
      break;

    case MEM_VERIFY:
      send_serial_string("MEM_VERIFY\r\n");
      mem_verify = (mem_verify_T*)type_p;
      send_serial_hex(mem_verify->addr, NL);
      send_serial_hex(mem_verify->val, NL);
      if (*(udword*)mem_verify->addr != mem_verify->val) {
	send_serial_string("verify failed\r\n");
	read_load_info();
      }
      (byte*)type_p += sizeof(mem_verify_T);
      break;

    case MEM_TEST:
      send_serial_string("MEM_TEST\r\n");
      mem_test = (mem_test_T*)type_p;
      send_serial_hex(mem_test->from, NL);
      send_serial_hex(mem_test->to, NL);

      if (!memory_test(mem_test->from, mem_test->to, &failed_address)) {
	send_serial_string("### Memory test failed at ");
	send_serial_hex(failed_address, NL);
	memory_dump((udword*)DWORD_ALIGN(failed_address - 64), (udword*)DWORD_ALIGN(failed_address + 64));
	read_load_info();
      }
      send_serial_string("Passed memory test.\r\n");
    
      (byte*)type_p += sizeof(mem_test_T);
      break;
      
    case MEM_DUMP:
      send_serial_string("MEM_DUMP\r\n");
      send_serial_hex(((mem_dump_T*)(type_p))->from_addr, NL);
      send_serial_hex(((mem_dump_T*)(type_p))->to_addr, NL);
      memory_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 MEM_CLEAR:
      send_serial_string("MEM_CLEAR\r\n");
      send_serial_hex(((mem_clear_T*)(type_p))->from_addr, NL);
      send_serial_hex(((mem_clear_T*)(type_p))->to_addr, NL);
      for (i=((mem_clear_T*)(type_p))->from_addr; i <= ((mem_clear_T*)(type_p))->to_addr; i++) {
	*(byte*)i = 0x00;
      }
      (byte*)type_p += sizeof(mem_clear_T);
      break;

    case FLASH:
      bcm52x1_led_force();
      send_serial_string("FLASH\r\n");
      send_serial_hex(((flash_T*)(type_p))->source, NL);
      send_serial_hex(((flash_T*)(type_p))->dest, NL);
      send_serial_hex(((flash_T*)(type_p))->size, NL);
      flash_write((unsigned char *)((flash_T*)(type_p))->source,
		  ((flash_T*)(type_p))->dest,
		  ((flash_T*)(type_p))->size);
      (byte*)type_p += sizeof(flash_T);
      bcm52x1_led_release();

      break;
	    

    case JUMP:
      send_serial_string("JUMP\r\n");
      jump = (jump_T*)type_p;
      send_serial_hex(jump->addr, NL);
      __asm__ volatile ("jump %0" :: "r" (jump->addr));    
      (byte*)type_p += sizeof(jump_T);
      break;
      
    default:
      send_serial_string("### Unknown type : ");
      send_serial_hex(*type_p, NL);
      read_load_info();
      break;
      
    }
  }
  
  send_serial_string("END\r\n");
}

void 
read_file(byte* addr, udword size)