btvid2.c

developed under vxwork, support bt878 video card, use socket to stream video out.

			     );

	return temp;
}

/* For Base Address Register Checks */


#define BAR_IS_IMPLEMENTED(readback) 		readback & 0xFFFFFFFF
#define BAR_IS_MEM_ADDRESS_DECODER(readback) 	!(readback & 0x1)
#define BAR_IS_IO_ADDRESS_DECODER(readback) 	(readback & 0x0)
#define BAR_IS_32_BIT_DECODER(readback)		((readback & 0x6) >> 1) == 0x0
#define BAR_IS_64_BIT_DECODER(readback)		((readback & 0x6) >> 1) == 0x2
#define BAR_IS_PREFETCHABLE(readback)		(readback & 0x8)

#define PCI_ROUTING_TABLE_SIGNATURE		0x52495024
#define PCI_ROUTING_TABLE_SIG_BYTE0		0x24
#define PCI_ROUTING_TABLE_SIG_BYTE1		0x50
#define PCI_ROUTING_TABLE_SIG_BYTE2		0x49
#define PCI_ROUTING_TABLE_SIG_BYTE3		0x52



/*

 Design Notes on Microcode

 PACKED RGB32 320x240 NTSC MODE MICROCODE
 ----------------------------------------

 BYTE3	BYTE2	BYTE1	BYTE0
 alpha	RED	GREEN	BLUE

 ODD LINES first (120 x 320)

 00320 ... 00639
 00960 ... 01179
 01500 ... 01819
 ...
 70480 ... 70799

 
 EVEN LINES second (120 x 320)
 
 00000 ... 00319
 00640 ... 00959
 01180 ... 01499
 ... 
 70160 ... 70479  ---- GENERATES FRAME INTA


 490 microcode instructions per frame

 X

 NUMFRAMES
 -----------
 490 * NUMFRAMES microcode instructions


 2
 ------------------------------------------------------- FIELD SYNC
 001 DMA_MC_SYNC_FM1_WORD_0,
 002 DMA_MC_SYNC_WORD_1,

 120 x 2 = 240
 ------------------------------------------------------- BEG ODD LINE FIELD
 001 DMA_MC_WRITE_1280_LINE,
 002 &(frame_buffer[0][320]),
 ------------------------------------------------------- END ODD LINE FIELD

 4
 ------------------------------------------------------- VRE & FIELD SYNC
 001 DMA_MC_SYNC_VRE_WORD_0,
 002 DMA_MC_SYNC_WORD_1,
 003 DMA_MC_SYNC_FM1_WORD_0,
 004 DMA_MC_SYNC_WORD_1,

 120 x 2 = 240
 ------------------------------------------------------- BEG EVEN LINE FIELD
 001 DMA_MC_WRITE_1280_LINE,
 002 &(frame_buffer[0][0]),
 ------------------------------------------------------- END EVEN LINE FIELD
 
 2
 ------------------------------------------------------- VRO SYNC
 001 DMA_MC_SYNC_VRO_WORD_0,
 002 DMA_MC_SYNC_WORD_1,

 001 JUMP
 002 ADDRESS
*/


/******************************** BEG DMA MC ****************/

/**** MC TAGS FOR DEBUGGING ****/
#define DMA_MC_SYNC	0x00080000      
#define DMA_MC_WRITE	0x00010000
#define DMA_MC_SKIP	0x00020000
#define DMA_MC_JUMP	0x00B40000 /* Clears all for next frame */

#define DMA_MC_SYNC_FM1_WORD_0		(0x80008006 | DMA_MC_SYNC)
#define DMA_MC_SYNC_FM1_WORD_0_IRQ	(0x81008006 | DMA_MC_SYNC)
#define DMA_MC_SYNC_WORD_1		(0x00000000)

#define DMA_MC_SKIP_1280_LINE		(0x2C000500 | DMA_MC_SKIP)
#define DMA_MC_SKIP_640_SOL		(0x28000280 | DMA_MC_SKIP)
#define DMA_MC_SKIP_640_EOL		(0x24000280 | DMA_MC_SKIP)
#define DMA_MC_SKIP_320_SOL		(0x28000140 | DMA_MC_SKIP)
#define DMA_MC_SKIP_320			(0x20000140 | DMA_MC_SKIP)
#define DMA_MC_SKIP_320_EOL		(0x24000140 | DMA_MC_SKIP)
#define DMA_MC_SKIP_1280_LINE_IRQ	(0x2D000500 | DMA_MC_SKIP)
#define DMA_MC_SKIP_40_SOL		(0x28000028 | DMA_MC_SKIP)
#define DMA_MC_SKIP_40_EOL        	(0x24000028 | DMA_MC_SKIP)

#define DMA_MC_SKIP_2560_LINE     	(0x2C000A00 | DMA_MC_SKIP)
#define DMA_MC_SKIP_1280_SOL      	(0x28000500 | DMA_MC_SKIP)
#define DMA_MC_SKIP_1280_EOL      	(0x24000500 | DMA_MC_SKIP)
#define DMA_MC_SKIP_2560_LINE_IRQ 	(0x2D000A00 | DMA_MC_SKIP)

#define DMA_MC_WRITE_2560_LINE     	(0x1C000A00 | DMA_MC_WRITE)
#define DMA_MC_WRITE_1280_SOL      	(0x18000500 | DMA_MC_WRITE)
#define DMA_MC_WRITE_1280_EOL      	(0x14000500 | DMA_MC_WRITE)
#define DMA_MC_WRITE_2560_LINE_IRQ 	(0x1D000A00 | DMA_MC_WRITE)

#define DMA_MC_WRITE_1280_LINE     	(0x1C000500 | DMA_MC_WRITE)
#define DMA_MC_WRITE_80_LINE       	(0x1C000050 | DMA_MC_WRITE)
#define DMA_MC_WRITE_640_SOL       	(0x18000280 | DMA_MC_WRITE)
#define DMA_MC_WRITE_640_EOL       	(0x14000280 | DMA_MC_WRITE)
#define DMA_MC_WRITE_320_SOL       	(0x18000140 | DMA_MC_WRITE)
#define DMA_MC_WRITE_320           	(0x10000140 | DMA_MC_WRITE)
#define DMA_MC_WRITE_320_EOL       	(0x14000140 | DMA_MC_WRITE)
#define DMA_MC_WRITE_1280_LINE_IRQ 	(0x1D000500 | DMA_MC_WRITE)

#define DMA_MC_SYNC_VRE_WORD_0     	(0x80008004 | DMA_MC_SYNC)
#define DMA_MC_SYNC_VRE_WORD_0_IRQ 	(0x81008004)

#define DMA_MC_SYNC_VRO_WORD_0     	(0x8000800C | DMA_MC_SYNC)
#define DMA_MC_SYNC_VRO_WORD_0_IRQ 	(0x8100800C)

#define DMA_MC_JUMP_TO_BEG     		(0x70000000 | DMA_MC_JUMP)
#define DMA_MC_JUMP_TO_BEG_IRQ 		(0x71000000 | DMA_MC_JUMP)

#define DMA_MC_HALT 			(0xFFFFFFFF)


/**** TEST SCANLINE BUFFER ****/
unsigned int test_buffer[320];


/**** TEST MICROCODE 1 ****/

/* For one 640 pixel by 480 line NTSC frame

  2
  ---------------------
  DMA_MC_SYNC_FM1_WORD_0,
  DMA_MC_SYNC_WORD_1,

  240 x 1 = 240
  -------------
  DMA_MC_SKIP_1280_LINE,

  4
  ---------------------
  DMA_MC_SYNC_VRE_WORD_0,
  DMA_MC_SYNC_WORD_1,
  DMA_MC_SYNC_FM1_WORD_0,
  DMA_MC_SYNC_WORD_1,

  240 x 1 = 240
  -------------
  DMA_MC_SKIP_1280_LINE,

  4
  ---------------------
  DMA_MC_SYNC_VRO_WORD_0,
  DMA_MC_SYNC_WORD_1,

  DMA_MC_JUMP_TO_BEG, 
  (unsigned int)&(dma_test_microcode[0])

*/
unsigned int dma_test_microcode[970];


/**** RGB32 MICROCODE BUFFER ****

 488 * NUMFRAMES microcode instructions + 2 for jump

****/
#define MCSIZE 488
unsigned int dma_microcode[(NUMFRAMES*MCSIZE)+2];

/*
 126 * NUMFRAMES
*/
#define PUNYMCSIZE 126
unsigned int dma_puny_microcode[(NUMFRAMES*PUNYMCSIZE)+2];


/**** RGB32 MICROCODE BUFFER ****

 968 * NUMFRAMES microcode instructions

****/
#define LGMCSIZE 968
unsigned int dma_large_microcode[(NUMFRAMES*LGMCSIZE)+2];


/******************************** END DMA MC ****************/


#define IR_TABLE_SIGNATURE 0x52495024

UINT find_int_routing_table(void)
{
  unsigned int testval;
  int length, i, j;
  unsigned char byte;
  unsigned short word;

  for(ir_table_addr=0x000F0000;
      ir_table_addr<0x00100000;
      ir_table_addr+=4)
  {
    if((*((unsigned int *)ir_table_addr)) == IR_TABLE_SIGNATURE)
      break;
  }
 
  logMsg("IR Table found at 0x%x\n", ir_table_addr,0,0,0,0,0);

  testval = *((unsigned int *)(ir_table_addr+4));

  length = testval & 0x0000FFFF;

  logMsg("Version = 0x%x, Length = 0x%x\n", ((unsigned short)(testval>>16)), length,0,0,0,0);

  testval = *((unsigned int *)(ir_table_addr)); ir_table_addr+=4;
  logMsg("Signature=0x%x\n", testval,0,0,0,0,0);

  testval = *((unsigned int *)(ir_table_addr)); ir_table_addr+=4;
  logMsg("Version = 0x%x, Length = 0x%x\n", ((unsigned short)(testval>>16)), (testval & 0x0000FFFF),0,0,0,0);

  testval = *((unsigned int *)(ir_table_addr)); ir_table_addr+=4;
  logMsg("PCI IR Bus = 0x%x, PCI IR Dev Func = 0x%x, PCI Exclusive IRQs\n", (testval>>24), ((testval>>16)&0x000000FF), (testval & 0x0000FFFF),0,0,0);

  testval = *((unsigned int *)(ir_table_addr)); ir_table_addr+=4;
  logMsg("Compatible IR=0x%x\n", testval,0,0,0,0,0);
  
  testval = *((unsigned int *)(ir_table_addr)); ir_table_addr+=4;
  logMsg("IR Miniport Data=0x%x\n", testval,0,0,0,0,0);

  testval = *((unsigned int *)(ir_table_addr)); ir_table_addr+=4;
  testval = *((unsigned int *)(ir_table_addr)); ir_table_addr+=4;
  testval = *((unsigned int *)(ir_table_addr)); ir_table_addr+=4;
  logMsg("Checksum=0x%x\n", (testval&0x000000FF),0,0,0,0,0);

  for(i=32;i<(length/4);i+=16)
  {
    printf("\n");
    printf("\n");
    printf("Card %d:\n",((i-32)/16));
    testval = *((unsigned int *)(ir_table_addr+i)); ir_table_addr+=4;
    printf("PCI Bus=0x%x, PCI Dev=0x%x, Link Val=0x%x\n", (testval>>24), (testval>>16)&0x000000FF, (testval>>8)&0x000000FF);
    byte = testval&0x000000FF;
    testval = *((unsigned int *)(ir_table_addr+i)); ir_table_addr+=4;
    word=((byte<<8)|(testval>>24));
    printf("IRQ-INTA Bitmap=0x%x\n", word);
    printf("IRQ list = ");
    for(j=0;j<16;j++)
    {
      if(word & (1<<j))
        printf("%d,",j);
    }
    printf("\n");
    testval = *((unsigned int *)(ir_table_addr+i)); ir_table_addr+=4;

    testval = *((unsigned int *)(ir_table_addr+i)); ir_table_addr+=4;
    printf("Slot = %d\n",((testval>>8)&0x000000FF));
  }

  return ir_table_addr;
 
}



void print_mc(int mc)
{
  int i;

  if(mc == RGB32_640x480_MICROCODE)
  {
    for(i=0;i<(sizeof(dma_large_microcode)/(sizeof(unsigned int)));i++)
    {
      logMsg("%4d 0x%8x @ 0x%8x\n", i, dma_large_microcode[i], &(dma_large_microcode[i]),0,0,0);
    }
  }
  if(mc == TEST_MICROCODE)
  {
    for(i=0;i<(sizeof(dma_test_microcode)/(sizeof(unsigned int)));i++)
    {
      logMsg("%4d 0x%8x @ 0x%8x\n", i, dma_test_microcode[i], &(dma_test_microcode[i]),0,0,0);
    }
  }

  else if(mc == RGB32_320x240_MICROCODE)
  {
    for(i=0;i<(sizeof(dma_microcode)/(sizeof(unsigned int)));i++)
    {
      logMsg("%4d 0x%8x @ 0x%8x\n", i, dma_microcode[i], &(dma_microcode[i]),0,0,0);
    }
  }

}



/**** RGB32 FRAME BUFFER for 640x480 frame 

 LGFRAME 307200

 ****/
UINT large_frame_buffer[NUMFRAMES][307200];


/**** RGB32 FRAME BUFFER for 320x240 frame ****/
UINT frame_buffer[NUMFRAMES][76800];
UINT y8_frame_buffer[NUMFRAMES][19200];
UINT save_buffer[76800];
unsigned char rgb_buffer[230400];
UINT y8_save_buffer[19200];

/**** Y8 FRAME BUFFER for 80x60 frame ****/
UINT puny_frame_buffer[NUMFRAMES][1200];



void write_y8_save_buffer(void)
{
  int fd, i;
  char *savebuffbyteptr = (char *)&(y8_save_buffer[0]);

  fd = open("/tgtsvr/testy8frame.out", O_RDWR|O_CREAT, 0644);

  write(fd,"P5\n",3);
  write(fd,"#test\n",6);
  write(fd,"320 240\n",8);
  write(fd,"255\n",4);

  /* Write out RED channel */
  for(i=0;i<76800;i++)
  {
    write(fd,(savebuffbyteptr+1),1);
    savebuffbyteptr+=4;
  }
  
  close(fd);

}


void write_save_buffer(int bo)
{
  int fd, i;
  char *savebuffbyteptr = (char *)&(save_buffer[0]);

  wvEvent(1,0,0);	

  fd = open("/tgtsvr/testframe.out", O_RDWR|O_CREAT, 0644);

  write(fd,"P6\n",3);
  write(fd,"#test\n",6);
  write(fd,"320 240\n",8);
  write(fd,"255\n",4);

  if(bo == 0)
  {
    /* Write out NO-ALPHA, RED, GREEN, BLUE pixels */
    for(i=0;i<76800;i++)
    {
      write(fd,(savebuffbyteptr+2),1);
      write(fd,(savebuffbyteptr+1),1);
      write(fd,(savebuffbyteptr),1);
      savebuffbyteptr+=4;
    }
  }
  else
  {
    /* Write out NO-ALPHA, RED, GREEN, BLUE pixels */
    for(i=0;i<76800;i++)
    {
      write(fd,(savebuffbyteptr+1),1);
      write(fd,(savebuffbyteptr+2),1);
      write(fd,(savebuffbyteptr+3),1);
      savebuffbyteptr+=4;
    }
  }
  
  close(fd);

}



UINT check_buffers(int fsize)
{
  int i,j;
  unsigned int test = 0;

  for(i=0;i<NUMFRAMES;i++)
  {
    if(fsize==1)
    {
      for(j=0;j<307199;j++)
        test |= large_frame_buffer[i][j];
    }
    else if(fsize==0)
    {
      for(j=0;j<7679;j++)
        test |= frame_buffer[i][j];
    }
  }

  printf("OR of all pixels = %d\n", test);

  return test;

}


void clear_buffers(int fsize)
{
  int i,j;

  for(i=0;i<NUMFRAMES;i++)
  {
    bzero(&(large_frame_buffer[i]),(307200*4));
    bzero(&(frame_buffer[i]), (76800*4));
  }

  bzero(&(test_buffer[0]),(320*4));

}


void initialize_test_mc(void)
{
  int j;

  dma_test_microcode[0] = DMA_MC_SYNC_FM1_WORD_0;
  dma_test_microcode[1] = DMA_MC_SYNC_WORD_1;

  /* Initialize the 240 lines of ODD and EVEN microcode */

  /* odd lines */
  for(j=2;j<482;j+=2)
  {
    dma_test_microcode[j] = DMA_MC_SKIP_1280_SOL;
    dma_test_microcode[j+1] = DMA_MC_SKIP_1280_EOL;
  }

  j=482;
  dma_test_microcode[j] = DMA_MC_SYNC_VRE_WORD_0; j++;
  dma_test_microcode[j] = DMA_MC_SYNC_WORD_1; j++;

  dma_test_microcode[j] = DMA_MC_SYNC_FM1_WORD_0; j++;
  dma_test_microcode[j] = DMA_MC_SYNC_WORD_1; j++;
  
  /* even line */
  for(j=486;j<966;j+=2)
  {
    dma_test_microcode[j] = DMA_MC_SKIP_1280_SOL;
    dma_test_microcode[j+1] = DMA_MC_SKIP_1280_EOL;
  }

  j=966;
  dma_test_microcode[j] = DMA_MC_SYNC_VRO_WORD_0_IRQ; j++;
  dma_test_microcode[j] = DMA_MC_SYNC_WORD_1; j++;

  dma_test_microcode[j] = DMA_MC_JUMP_TO_BEG; j++;
  dma_test_microcode[j] = (unsigned int)&(dma_test_microcode[0]); j++;

}


void initialize_frame_mc(int fsize)
{
  int mcidx, i,j, k;

  if(fsize==NTSC_80_X_60)
  {
    /* For NUMFRAMES Frames */
    for(i=0;i<NUMFRAMES;i++)
    {

      mcidx = PUNYMCSIZE * i; j = 0;

      /* FIELD SYNC */  
      dma_puny_microcode[mcidx+j] = DMA_MC_SYNC_FM1_WORD_0; j++;
      dma_puny_microcode[mcidx+j] = DMA_MC_SYNC_WORD_1; j++;

      /* Initialize 30 lines of ODD microcode */
      for(j=2,k=0;j<32;j+=2,k++)
      {
  
        /* odd line */
        if(replace_write_with_skip)
        {