common.c

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

{
  udword nbr_read_last;
  udword sum;
  byte *b;
  byte *from;

  /*  send_serial_string(">read_file\r\n");*/

  target_address   = addr;
  rx_descr2.buf    = (udword)addr;
  bytes_to_read    = size;
  rx_descr2.sw_len = size + CRC_LEN > 1500 ? 1500 : size + CRC_LEN;
  /*  rx_descr2.sw_len = 1500;*/

#if 0
  print_descr(&rx_descr);
  print_descr(&rx_descr2);
#endif

  *R_DMA_CH1_FIRST = (udword)&rx_descr;

  /* Restart receiver so descriptor is re-read. */
  *R_DMA_CH1_CMD   = IO_STATE(R_DMA_CH1_CMD, cmd, reset);
  while(*R_DMA_CH1_CMD & IO_STATE(R_DMA_CH1_CMD, cmd, reset))
    {
    }

  nbr_read = 0;
  nbr_read_last = 0;

  *R_DMA_CH1_CMD   = IO_STATE(R_DMA_CH1_CMD, cmd, start);

  while(1) {
    /*    send_serial_hex(rx_descr2.hw_len, NL);*/
    from = (byte*)rx_descr2.buf;
    if (read_data()) {
      if (nbr_read < size) {
	*R_DMA_CH1_CMD   = IO_STATE(R_DMA_CH1_CMD, cmd, start);
      }
#ifdef DEBUG_HARDWARE
      send_serial_hex(nbr_read, NO_NL);
      send_serial_string(",");
#endif



#if 0
      send_serial_string("Read ");
      send_serial_hex(rx_descr2.hw_len - CRC_LEN, NO_NL);
      send_serial_string(" bytes. ");
      send_serial_hex((udword)from, NO_NL);
      send_serial_string(" - ");
      send_serial_hex(rx_descr2.buf-1, NO_NL);
      send_serial_string(" (");
      send_serial_hex(nbr_read, NO_NL);
      send_serial_string("/");
      send_serial_hex(size, NO_NL);
      send_serial_string(")\r\n");
#endif
#if 0
      print_descr(&rx_descr);
      print_descr(&rx_descr2);
#endif
      nbr_read_last = nbr_read;
      /*      from = (byte*)rx_descr2.buf;*/
    
      if (nbr_read >= size) {
	break;
      }
    }
    /*    if (timeout()) {*/
    /*      *R_PORT_PA_DATA = ~(*R_PORT_PA_READ & IO_MASK(R_PORT_PA_READ, data_in));*/
    /*      seq--;*/
    /*      send_ack[interface]();*/
    /*      seq++;*/
    /*    }*/
    
  }
  
  sum = 0;
  for (b=addr; b != (byte*)(addr+size); b++) {
    /*    send_serial_hex(b, NL);*/
    /*    send_serial_hex(*b, NL);*/
    sum+=(*b);
  }
//  send_serial_string("Checksum of file is ");
  send_serial_string("CS=");
  send_serial_hex(sum, NL);

  /*  memory_dump((udword*)addr, (udword*)addr+size);*/
  /*  send_serial_string("<read_file\r\n");*/
  
}

void
print_load_info()
{

}

#if 0 //Andrey
void 
print_descr(dma_descr_T *d)
{
  
  send_serial_string("Descriptor at ");
  send_serial_hex((udword)d, NL);

  send_serial_string("ctrl   : ");
  send_serial_uword(d->ctrl);

  send_serial_string("sw_len : ");
  send_serial_uword(d->sw_len);

  send_serial_string("next   : ");
  send_serial_hex(d->next, NL);

  send_serial_string("buf    : ");
  send_serial_hex(d->buf, NL);

  send_serial_string("status : ");
  send_serial_uword(d->status);

  send_serial_string("hw_len : ");
  send_serial_uword(d->hw_len);

}

#endif //Andrey

int
memory_test(udword from, udword to, udword *failed_address)
{
  udword i;
  udword j;
  byte b;

  for (i=from; i<to; i+=4) {
    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_serial_string("### Memory test 1 failed at ");
	send_serial_hex(*failed_address, NL);
	return(FALSE);
      }
    }
  }
  
  for (i=from; i<to; i+=4) {
    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_serial_string("### Memory test 2 failed at ");
	send_serial_hex(*failed_address, NL);
	return(FALSE);
      }
    }
  }
  return(TRUE);
}

void
memory_dump(udword *from, udword *to)
{
  udword *i = from;
  int j;
  
  for (; i <= to; i+=4) {
    send_serial_hex((udword)i, NO_NL);
    send_serial_string(" :");
    for(j=0; j != 4 && (i+j <= to); j++) {
      send_serial_string(" ");
      send_serial_hex(*(udword*)(i+j), NO_NL);
    }
    send_serial_string("\r\n");
  }
  
}
#if 0
// -- testing MII registers
//unsigned short e100_get_mdio_reg(unsigned char reg_num)
void mii_get(int a) {
    send_serial_hex((udword) a, NO_NL);
    send_serial_string(" :");
    send_serial_hex((udword) e100_get_mdio_reg((unsigned char) a) , NL);

}
#endif
#if 1


//-- use MII to control LEDs
#define GET_BIT(bit,val)   (((val) >> (bit)) & 0x01)
#define MDIO_START                          0x1
#define MDIO_READ                           0x2
#define MDIO_WRITE                          0x1
#define MDIO_PREAMBLE              0xfffffffful
#define MDIO_PHYS_ADDR                      0x0
//#include <asm/delay.h>

//unsigned short e100_get_mdio_reg(unsigned char reg_num);
//void e100_set_mdio_reg(unsigned char reg_num, unsigned short data);
void e100_send_mdio_cmd(unsigned short cmd, int write_cmd);
void e100_send_mdio_bit(unsigned char bit);
unsigned char e100_receive_mdio_bit(void);
void udelay(int n) {
 int i,j;
 for (i=0;i<n;i++) for (j=0;j<100;j++);
}
#endif
#if 0

unsigned short
e100_get_mdio_reg(unsigned char reg_num)
{
	unsigned short cmd;    /* Data to be sent on MDIO port */
	unsigned short data;   /* Data read from MDIO */
	int bitCounter;
	
	/* Start of frame, OP Code, Physical Address, Register Address */
	cmd = (MDIO_START << 14) | (MDIO_READ << 12) | (MDIO_PHYS_ADDR << 7) |
		(reg_num << 2);
	
	e100_send_mdio_cmd(cmd, 0);
	
	data = 0;
	
	/* Data... */
	for (bitCounter=15; bitCounter>=0 ; bitCounter--) {
		data |= (e100_receive_mdio_bit() << bitCounter);
	}
	/* Idle */
	e100_receive_mdio_bit();
	return data;
}
#endif
#if 1
void
e100_set_mdio_reg(unsigned char reg_num, unsigned short data)
{
	unsigned short cmd;    /* Data to be sent on MDIO port */
	int bitCounter;
	
	/* Start of frame, OP Code, Physical Address, Register Address */
	cmd = (MDIO_START << 14) | (MDIO_WRITE << 12) | (MDIO_PHYS_ADDR << 7) |
	        (reg_num<< 2);

	e100_send_mdio_cmd(cmd, 1);

	/* Data... */
	for (bitCounter=15; bitCounter>=0 ; bitCounter--) {
		e100_send_mdio_bit(GET_BIT(bitCounter, data));
	}
	/* Idle */
	e100_receive_mdio_bit();
}
#endif
#if 1
void
e100_send_mdio_cmd(unsigned short cmd, int write_cmd)
{
	int bitCounter;
	unsigned char data = 0x2;
//    send_serial_hex((udword) cmd, NO_NL);
//    send_serial_string("-");
//    send_serial_hex((udword) write_cmd, NL);
	
	/* Preamble */
	for (bitCounter = 31; bitCounter>= 0; bitCounter--)
		e100_send_mdio_bit(GET_BIT(bitCounter, MDIO_PREAMBLE));

	for (bitCounter = 15; bitCounter >= 2; bitCounter--)
		e100_send_mdio_bit(GET_BIT(bitCounter, cmd));

	/* Turnaround */
	for (bitCounter = 1; bitCounter >= 0 ; bitCounter--)
		if (write_cmd)
			e100_send_mdio_bit(GET_BIT(bitCounter, data));
		else
			e100_receive_mdio_bit();
}

void
e100_send_mdio_bit(unsigned char bit)
{
	*R_NETWORK_MGM_CTRL =
		IO_STATE(R_NETWORK_MGM_CTRL, mdoe, enable) |
		IO_FIELD(R_NETWORK_MGM_CTRL, mdio, bit);
	udelay(1);
	*R_NETWORK_MGM_CTRL =
		IO_STATE(R_NETWORK_MGM_CTRL, mdoe, enable) |
		IO_MASK(R_NETWORK_MGM_CTRL, mdck) |
		IO_FIELD(R_NETWORK_MGM_CTRL, mdio, bit);
	udelay(1);
}

unsigned char
e100_receive_mdio_bit()
{
	unsigned char bit;
	*R_NETWORK_MGM_CTRL = 0;
	bit = IO_EXTRACT(R_NETWORK_STAT, mdio, *R_NETWORK_STAT);
	udelay(1);
	*R_NETWORK_MGM_CTRL = IO_MASK(R_NETWORK_MGM_CTRL, mdck);
	udelay(1);
	return bit;
}

#endif
#ifdef CONFIG_BCM5221
void bcm52x1_txled(){
 e100_set_mdio_reg(0x1a, 0x1f00);
}
void bcm52x1_led_force() {
  e100_set_mdio_reg(0x1b, 0x00aa); // force LEDs on
}

void bcm52x1_led_release(){
  e100_set_mdio_reg(0x1b, 0x008a); // release LEDs
}
#endif

#ifdef CONFIG_BCM5201
void bcm52x1_led_force() {
  e100_set_mdio_reg(0x1b, 0xff20); // force LEDs on
}

void bcm52x1_led_release(){
  e100_set_mdio_reg(0x1b, 0xff00); // release LEDs
}
#endif