////
#ifndef PEXOR_NAME
#define PEXOR_NAME "PEXOR"
//#define DEBUG

// byte address offset for PEXOR
#define PEXOR_BASE 0x0
#define PEXOR_REQ_COMM 0x21000
#define PEXOR_REQ_ADDR 0x21004
#define PEXOR_REQ_DATA 0x21008
#define PEXOR_REP_STAT 0x2100c
#define PEXOR_REP_CLR  0x2100c
#define PEXOR_REP_STAT_0 0x21010
#define PEXOR_REP_STAT_1 0x21014
#define PEXOR_REP_STAT_2 0x21018
#define PEXOR_REP_STAT_3 0x2101c

#define PEXOR_REP_ADDR_0 0x21020
#define PEXOR_REP_ADDR_1 0x21024
#define PEXOR_REP_ADDR_2 0x21028
#define PEXOR_REP_ADDR_3 0x2102c

#define PEXOR_REP_DATA_0 0x21030
#define PEXOR_REP_DATA_1 0x21034
#define PEXOR_REP_DATA_2 0x21038
#define PEXOR_REP_DATA_3 0x2103c

#define PEXOR_RX_MONI 0x21040
#define PEXOR_RX_RST  0x21044
#define PEXOR_SFP_DISA 0x21048
#define PEXOR_SFP_FAULT 0x2104c

#define PEXOR_SFP_FIFO 0x21050

#define PEXOR_REP_TK_STAT 0x21060
#define PEXOR_REP_TK_HEAD 0x21070
#define PEXOR_REP_TK_FOOT 0x21080
#define PEXOR_REP_TK_DSIZE 0x21090
#define PEXOR_TK_DSIZE_SEL 0x210a0

#define PEXOR_TK_MEM_SIZE 0x210b0

#define PEXOR_PROG_VERSION 0x211fc

#define PEXOR_TK_MEM 0x28000

#define PEXOR_TK_MEM_0 0x100000
#define PEXOR_TK_MEM_1 0x140000
#define PEXOR_TK_MEM_2 0x180000
#define PEXOR_TK_MEM_3 0x1c0000

// Packet types
#define PEXOR_PT_AD_R_REQ 0x240
#define PEXOR_PT_AD_W_REQ 0x644

//#define PEXOR_PT_TK_R_REQ 0xA00   //#define PEXOR_PT_TK_R_REQ 0xA44
#define PEXOR_PT_TK_R_REQ 0xA11
#define PEXOR_INI_REQ 0x344
#define PEXOR_RST_REQ 0x744

#define PEXOR_PT_AD_R_REP 0x044
#define PEXOR_PT_AD_W_REP 0x440
#define PEXOR_PT_TK_R_REP 0x844
#define PEXOR_PT_INI_REP 0x244
#define PEXOR_PT_ERR_REP 0x544


// address map for slave

/* #define REG_MODID     0x3FE0 */
/* #define REG_HEADER    0x3FE4 */
/* #define REG_FOOTER    0x3FE8 */
/* #define REG_DATA_LEN  0x3FEC */

/* #define REG_VERSION 0x3FFC */

#define REG_BUF0_DATA_LEN     0xFFFD00  // buffer 0 submemory data length
#define REG_BUF1_DATA_LEN     0xFFFE00  // buffer 1 submemory data length


#define REG_DATA_REDUCTION  0xFFFFB0  // Nth bit = 1 enable data reduction of  Nth channel from block transfer readout. (bit0:time, bit1-8:adc)
#define REG_MEM_DISABLE     0xFFFFB4  // Nth bit =1  disable Nth channel from block transfer readout.(bit0:time, bit1-8:adc)
#define REG_MEM_FLAG_0      0xFFFFB8  // read only:
#define REG_MEM_FLAG_1      0xFFFFBc  // read only:


#define REG_BUF0     0xFFFFD0 // base address for buffer 0 : 0x0000
#define REG_BUF1     0xFFFFD4  // base address for buffer 1 : 0x20000
#define REG_SUBMEM_NUM   0xFFFFD8 //num of channels 8
#define REG_SUBMEM_OFF   0xFFFFDC // offset of channels 0x4000

#define REG_MODID     0xFFFFE0
#define REG_HEADER    0xFFFFE4
#define REG_FOOTER    0xFFFFE8
#define REG_DATA_LEN  0xFFFFEC

#define REG_RST 0xFFFFF4
#define REG_LED 0xFFFFF8
#define REG_VERSION 0xFFFFFC

typedef struct
{
  char *name;


  long volatile *pexor_base;
  long volatile *req_comm;
  long volatile *req_addr;
  long volatile *req_data;
  long volatile *rep_stat;
  long volatile *rep_clr;
  long volatile *rep_stat_0;
  long volatile *rep_stat_1;
  long volatile *rep_stat_2;
  long volatile *rep_stat_3;

  long volatile *rep_addr_0;
  long volatile *rep_addr_1;
  long volatile *rep_addr_2;
  long volatile *rep_addr_3;

  long volatile *rep_data_0;
  long volatile *rep_data_1;
  long volatile *rep_data_2;
  long volatile *rep_data_3;

  long volatile *rx_moni;
  long volatile *rx_rst;
  long volatile *sfp_disa;        
  long volatile *sfp_fault;        
  long volatile *sfp_fifo;        
  long volatile *sfp_tk_stat, *sfp_tk_head, *sfp_tk_foot;        
  long volatile *sfp_tk_dsize, *sfp_tk_sel;
  long volatile *tk_mem_size;
  long volatile *tk_mem_0,*tk_mem_1,*tk_mem_2,*tk_mem_3;        
  long volatile *tk_mem;

  long volatile *pexor_version;


} s_pexor ;

//  long l_pack_ad_r_req;
//  long l_pack_ad_w_req;
  //  long l_pack_tk_r_req = 0xa00;
//  long l_pack_ini_req;


int PEXOR_GetPointer( long PEXOR_BASE_OFF, volatile long *pl_virt_sram, s_pexor *ps_pexor ){
/*   smem_remove("Mem"); */
/* 	smem = smem_create("Mem", */
/* 			(char *) 0x51000000, */
/* 			(char *) 0x10000000, */
/* 			(SM_READ | SM_WRITE) ); */


/*   l_pack_ad_r_req = 0x240; */
/*   l_pack_ad_w_req = 0x644; */
/*   //  l_pack_tk_r_req = 0xa00; */
/*   l_pack_ini_req = 0x344; */

  long *ph_pexor_seq= (long *) (PEXOR_BASE_OFF + (long) pl_virt_sram);
  ps_pexor->pexor_base = (long *) ((long) ph_pexor_seq + (long)PEXOR_BASE );
  ps_pexor->req_comm = (long *) ((long) ph_pexor_seq + (long)PEXOR_REQ_COMM );
  ps_pexor->req_addr   = (long *) ((long)ph_pexor_seq +  (long) PEXOR_REQ_ADDR);
  ps_pexor->req_data   = (long *) ((long)ph_pexor_seq +  (long) PEXOR_REQ_DATA);
  ps_pexor->rep_stat   = (long *) ((long)ph_pexor_seq +  (long) PEXOR_REP_STAT);
  ps_pexor->rep_clr    = (long *) ((long)ph_pexor_seq +  (long) PEXOR_REP_CLR);
  ps_pexor->rep_stat_0 = (long *) ((long)ph_pexor_seq +  (long) PEXOR_REP_STAT_0);
  ps_pexor->rep_stat_1 = (long *) ((long)ph_pexor_seq +  (long) PEXOR_REP_STAT_1);
  ps_pexor->rep_stat_2 = (long *) ((long)ph_pexor_seq +  (long) PEXOR_REP_STAT_2);
  ps_pexor->rep_stat_3 = (long *) ((long)ph_pexor_seq +  (long) PEXOR_REP_STAT_3);
				  			  	 		 
  ps_pexor->rep_addr_0 = (long *) ((long)ph_pexor_seq +  (long) PEXOR_REP_ADDR_0);
  ps_pexor->rep_addr_1 = (long *) ((long)ph_pexor_seq +  (long) PEXOR_REP_ADDR_1);
  ps_pexor->rep_addr_2 = (long *) ((long)ph_pexor_seq +  (long) PEXOR_REP_ADDR_2);
  ps_pexor->rep_addr_3 = (long *) ((long)ph_pexor_seq +  (long) PEXOR_REP_ADDR_3);
				  			  	 		 
  ps_pexor->rep_data_0 = (long *) ((long)ph_pexor_seq +  (long) PEXOR_REP_DATA_0);
  ps_pexor->rep_data_1 = (long *) ((long)ph_pexor_seq +  (long) PEXOR_REP_DATA_1);
  ps_pexor->rep_data_2 = (long *) ((long)ph_pexor_seq +  (long) PEXOR_REP_DATA_2);
  ps_pexor->rep_data_3 = (long *) ((long)ph_pexor_seq +  (long) PEXOR_REP_DATA_3);
				  			  				
  ps_pexor->rx_moni    = (long *) ((long)ph_pexor_seq +  (long) PEXOR_RX_MONI);
  ps_pexor->rx_rst     = (long *) ((long)ph_pexor_seq +  (long) PEXOR_RX_RST);
  ps_pexor->sfp_disa   = (long *) ((long)ph_pexor_seq +  (long) PEXOR_SFP_DISA);
  ps_pexor->sfp_fault  = (long *) ((long)ph_pexor_seq +  (long) PEXOR_SFP_FAULT);
  ps_pexor->sfp_fifo   = (long *) ((long)ph_pexor_seq +  (long) PEXOR_SFP_FIFO);
  ps_pexor->sfp_tk_stat = (long *) ((long)ph_pexor_seq +  (long) PEXOR_REP_TK_STAT);
  ps_pexor->sfp_tk_head = (long *) ((long)ph_pexor_seq +  (long) PEXOR_REP_TK_HEAD);
  ps_pexor->sfp_tk_foot = (long *) ((long)ph_pexor_seq +  (long) PEXOR_REP_TK_FOOT);
  ps_pexor->sfp_tk_dsize = (long *) ((long)ph_pexor_seq +  (long) PEXOR_REP_TK_DSIZE);
  ps_pexor->sfp_tk_sel  = (long *) ((long)ph_pexor_seq +  (long) PEXOR_TK_DSIZE_SEL);
  ps_pexor->sfp_tk_sel  = (long *) ((long)ph_pexor_seq +  (long) PEXOR_TK_DSIZE_SEL);

  ps_pexor->tk_mem_size  = (long *) ((long)ph_pexor_seq +  (long) PEXOR_TK_MEM_SIZE);

  ps_pexor->tk_mem_0     = (long *) ((long)ph_pexor_seq +  (long) PEXOR_TK_MEM_0);
  ps_pexor->tk_mem_1     = (long *) ((long)ph_pexor_seq +  (long) PEXOR_TK_MEM_1);
  ps_pexor->tk_mem_2     = (long *) ((long)ph_pexor_seq +  (long) PEXOR_TK_MEM_2);
  ps_pexor->tk_mem_3     = (long *) ((long)ph_pexor_seq +  (long) PEXOR_TK_MEM_3);

  ps_pexor->pexor_version    = (long *) ((long)ph_pexor_seq +  (long) PEXOR_PROG_VERSION);

  //  printf ("pl_virt_sram: 0x%x \n", pl_virt_sram);

  //  printf ("REP CLR: rep stat (bytes): 0x%x  0x%x \n",ps_pexor->rx_moni,*ps_pexor->rx_moni);
  //  printf ("REP CLR: rep stat (bytes): 0x%x  0x%x \n",ps_pexor->req_comm,*ps_pexor->req_comm);
	return(1);
}

int PEXOR_Read( s_pexor *ps_pexor, long *addr, long *data ){

  *data =  * ( ps_pexor->pexor_base + (*addr >>2) );
  //  printf ("PEXOR_Read: 0x%x  0x%x \n",(ps_pexor->pexor_base),*(ps_pexor->pexor_base) );
  //  printf ("PEXOR_Read: 0x%x  0x%x \n",(ps_pexor->pexor_base+(addr>>2)),*(ps_pexor->pexor_base+(addr>>2) ) );
}


int PEXOR_Slave_Read( s_pexor *ps_pexor, long l_sfp, long l_slave, long l_addr, long *data ){
  long l_comm, l_address;
  long a,b,c;
  int status;

  status=1;
  l_comm = PEXOR_PT_AD_R_REQ | (0x1<<16+l_sfp);
  l_address = l_addr+ (l_slave << 24);

  PEXOR_RX_Clear_Ch(ps_pexor, l_sfp); 

  PEXOR_TX( ps_pexor, l_comm, l_address, 0x0) ; 
  if(PEXOR_RX( ps_pexor, l_sfp, &a , &b, &c)==1) {
#ifdef DEBUT
    printf ("PEXOR_Slave_Read: Reply to PEXOR from SFP: 0x%x ", l_sfp);
    printf (" 0x%x 0x%x 0x%x \n", a,b,c);
#endif
    *data = c;
    if( (a&0xfff) == PEXOR_PT_AD_R_REP){
      if(a&0x4000!=0){
	printf ("PEXOR_Slave_Read: ERROR: Packet Structure : Command Reply 0x%x \n", a);
	status=-1;
      }
    } else {
      printf ("PEXOR_Slave_Read: ERROR : Access to empty slave or address: Module  0x%x Address 0x%x  Command Reply  0x%x \n", ( l_address&0xff000000) >> 24 , l_address&0xffffff, a );
      status=-1;
    }
  }else{
    status=-1;
    printf ("PEXOR_Slave_Read: no reply: 0x%x 0x%x 0x%x \n", a,b,c);
  }

  return status;
}


int PEXOR_Slave_Write( s_pexor *ps_pexor, long l_sfp, long l_slave, long l_addr, long l_data ){
  long l_comm, l_address;
  long a,b,c;
  int status;

  status=1;
  l_comm = PEXOR_PT_AD_W_REQ | (0x1<<16+l_sfp);
  l_address = l_addr+ (l_slave << 24);

  PEXOR_RX_Clear(ps_pexor); 

  PEXOR_TX( ps_pexor, l_comm, l_address, l_data) ; 
  if(PEXOR_RX( ps_pexor, l_sfp, &a , &b, &c)==1) {
#ifdef DEBUT
    printf ("PEXOR_Slave_Write: Reply to PEXOR from SFP: 0x%x ", l_sfp);
    printf (" 0x%x 0x%x 0x%x \n", a,b,c);
#endif
    if( (a&0xfff) == PEXOR_PT_AD_W_REP){
      if(a&0x4000!=0){
	printf ("PEXOR_Slave_Write: ERROR: Packet Structure : Command Reply 0x%x \n", a);
	status=-1;
      }
    } else {
      printf ("PEXOR_Slave_Write: ERROR : Access to empty slave or address: Module  0x%x Address 0x%x  Command Reply  0x%x \n", ( l_address&0xff000000) >> 24 , l_address&0xffffff, a );
      status=-1;
    }
  }else{
    status=-1;
    printf ("PEXOR_Slave_Write: no reply: 0x%x 0x%x 0x%x \n", a,b,c);
  }

  return status;
}


int PEXOR_TK_TX_Mem_Read( s_pexor *ps_pexor, long *addr, long *data ){

  *data =  * ( ps_pexor->tk_mem + (*addr >>2) );
  //  printf ("PEXOR_Read: 0x%x  0x%x \n",(ps_pexor->tk_mem),*(ps_pexor->tk_mem) );
  //  printf ("PEXOR_Read: 0x%x  0x%x \n",(ps_pexor->tk_mem+(addr>>2)),*(ps_pexor->tk_mem+(addr>>2) ) );
}

int PEXOR_TK_Mem_Write( s_pexor *ps_pexor, long *addr, long *data ){

   *( ps_pexor->tk_mem + (*addr >>2) )= *data;
  //  printf ("PEXOR_Read: 0x%x  0x%x \n",(ps_pexor->pexor_base),*(ps_pexor->pexor_base) );
  //  printf ("PEXOR_Read: 0x%x  0x%x \n",(ps_pexor->pexor_base+(addr>>2)),*(ps_pexor->pexor_base+(addr>>2) ) );
}

int PEXOR_RX_Clear( s_pexor *ps_pexor ){

  //  while( (*ps_pexor->rep_stat&0xcccc)!=0x0 ){
  while( (*ps_pexor->rep_stat)!=0x0 ){
    *ps_pexor->rep_clr=0xf;
    //    sleep(1);
#ifdef DEBUG
    //    printf ("PEXOR_RX_Clear: rep_stat: 0x%x 0x%x \n",ps_pexor->rep_stat, *ps_pexor->rep_stat );
#endif
  }
  return(1);
}



int PEXOR_RX_Clear_Ch( s_pexor *ps_pexor, long ch ){
  long val;
  val = 0x1<<ch;
  while( (*(ps_pexor->rep_stat_0+ch)&0xf000)!=0x0|(*(ps_pexor->sfp_tk_stat+ch)&0xf000)!=0x0 ){
  //  while( (*ps_pexor->rep_stat)!=0x0 ){
    //    *ps_pexor->rep_clr=0xf;
    *ps_pexor->rep_clr=val;
    //    sleep(1);
#ifdef DEBUG
    //    printf ("PEXOR_RX_Clear: rep_stat: ch 0x%x 0x%x  0x%x \n",ch, *(ps_pexor->sfp_tk_stat+ch), *(ps_pexor->rep_stat_0+ch) );
#endif
  }
  return(1);
}

int PEXOR_RX_Clear_Pattern( s_pexor *ps_pexor, long l_ptn ){
  long mask;
  mask=(l_ptn<<8)|(l_ptn<<4)|l_ptn;
  //  while( (*ps_pexor->rep_stat&0xcccc)!=0x0 ){
  while( ((*ps_pexor->rep_stat)&mask)!=0x0 ){
    *ps_pexor->rep_clr=l_ptn;
    //    sleep(1);
#ifdef DEBUG
    //    printf ("PEXOR_RX_Clear: rep_stat: 0x%x 0x%x \n",ps_pexor->rep_stat, *ps_pexor->rep_stat );
#endif
  }
  return(1);
}



int PEXOR_TX_Reset_Ch( s_pexor *ps_pexor, long ch ){
  long val;
  val = 0x1<<(ch+4);
  *ps_pexor->rx_rst= val;
  return(1);
}

int PEXOR_SERDES_Reset( s_pexor *ps_pexor){
  long val;
  *ps_pexor->rx_rst= 0x100;
  *ps_pexor->rx_rst= 0x0;
  sleep(1);
  return(1);
}



int PEXOR_TX( s_pexor *ps_pexor,  long comm, long addr, long data ){
  *ps_pexor->req_addr = addr;
  *ps_pexor->req_data = data;
  *ps_pexor->req_comm = comm;
  return(1);
}

int PEXOR_RX( s_pexor *ps_pexor, int sfp_id,  long *comm, long *addr, long *data ){
  int stat;
  int loop=0;
  int loop_max=1000000;

  stat=-1;
  if(sfp_id==0){
    while( ((*ps_pexor->rep_stat_0 & 0x3000)>>12)!=2 && loop < loop_max){
      //      sleep(1);
      loop++;
      //      printf ("PEXOR_RX: rep_stat: sfp0:0x%x  loop %d \n", *ps_pexor->rep_stat_0, loop);
    }
      *comm =  *ps_pexor->rep_stat_0;
      *addr =  *ps_pexor->rep_addr_0;
      *data =  *ps_pexor->rep_data_0;

  }  else if(sfp_id==1){
    while( ((*ps_pexor->rep_stat_1 & 0x3000)>>12)!=2  && loop < loop_max ){
      //      sleep(1);
      loop++;
      //      printf ("PEXOR_RX: rep_stat: sfp1:0x%x \n", *ps_pexor->rep_stat_1);
    }
    *comm =  *ps_pexor->rep_stat_1;
    *addr =  *ps_pexor->rep_addr_1;
    *data =  *ps_pexor->rep_data_1;

  }  else if(sfp_id==2){
    while( ((*ps_pexor->rep_stat_2 & 0x3000)>>12)!=2   && loop < loop_max){
      //      sleep(1);
      loop++;
      //      printf ("PEXOR_RX: rep_stat: sfp2:0x%x \n", *ps_pexor->rep_stat_2);
    }
    *comm =  *ps_pexor->rep_stat_2;
    *addr =  *ps_pexor->rep_addr_2;
    *data =  *ps_pexor->rep_data_2;
  }  else if(sfp_id==3){
    while( ((*ps_pexor->rep_stat_3 & 0x3000)>>12)!=2   && loop < loop_max){
      //      sleep(1);
      loop++;
      //      printf ("PEXOR_RX: rep_stat: sfp3:0x%x \n", *ps_pexor->rep_stat_3);
    }
    *comm =  *ps_pexor->rep_stat_3;
    *addr =  *ps_pexor->rep_addr_3;
    *data =  *ps_pexor->rep_data_3;
  }
  if(loop!=loop_max) stat =1;
  return(stat);
}


long PEXOR_TK_Data_Size( s_pexor *ps_pexor, long l_sfp,  long slave_id ){
  long comm, addr, data;

  *(ps_pexor->sfp_tk_sel+l_sfp) = slave_id;
  return(  *(ps_pexor->sfp_tk_dsize + l_sfp) );
}

long PEXOR_TK_Mem_Size( s_pexor *ps_pexor, long l_sfp ){
  long comm, addr, data;
  return ( *(ps_pexor->tk_mem_size+l_sfp)) ;
}

long PEXOR_TK_Mem_Read( s_pexor *ps_pexor, long l_sfp, long **pl_dat  ){
  long mem_size, mem_size_32b;
  long MEM_SIZE_MAX=0x10000;
  long *pl_dat_start;
  int i;
  pl_dat_start = *pl_dat;
  mem_size=*(ps_pexor->tk_mem_size+l_sfp);
  printf ("PEXOR_TK_Mem_Read:  %x \n", mem_size);

  mem_size_32b = (mem_size>>2);
  if(mem_size > MEM_SIZE_MAX) {
    printf ("PEXOR_TK_Mem_Read: sfp x%x  memory overflow!! (size = %x ) \n", l_sfp, mem_size);
  } else {
    if (l_sfp==0) {
      for (i=0; i < mem_size_32b ; i++)	*((*pl_dat)++)=*(ps_pexor->tk_mem_0 +i);
    } else if (l_sfp==1) {
      for (i=0; i < mem_size_32b ; i++)	*((*pl_dat)++)=*(ps_pexor->tk_mem_1 +i);
    } else if (l_sfp==2) {
      for (i=0; i < mem_size_32b ; i++)	*((*pl_dat)++)=*(ps_pexor->tk_mem_2 +i);
    } else if (l_sfp==3) {
      for (i=0; i < mem_size_32b ; i++) *((*pl_dat)++)=*(ps_pexor->tk_mem_3 +i);
    }
  }
  *pl_dat=pl_dat_start;
  return (mem_size ) ;
}


int PEXOR_RX_Status( s_pexor *ps_pexor ){
  //  printf ("0x%x 0x%x \n", ps_pexor->rep_stat,*ps_pexor->rep_stat);
  printf ("PEXOR_RX_Status: rep_stat: sfp0:0x%x sfp1:0x%x sfp2:0x%x sfp3:0x%x \n",
	  *ps_pexor->rep_stat_0,*ps_pexor->rep_stat_1 ,
	  *ps_pexor->rep_stat_2,*ps_pexor->rep_stat_3);
  return(1);
}

int PEXOR_Port_Monitor( s_pexor *ps_pexor ){
  long tmp, fault, moni;
  int flag=-1;
  int loop=0;
  int loopmax=10;
  //  printf ("0x%x 0x%x \n", ps_pexor->rep_stat,*ps_pexor->rep_stat);
    while((loop < loopmax)&&(flag==-1)){
      tmp=~(*ps_pexor->sfp_fault);
      fault=(tmp&0x1)*0xff+(tmp&0x2)*0xff00/2+(tmp&0x4)*0xff0000/4+(tmp&0x8)*0xff000000/8;
      moni=(*ps_pexor->rx_moni)&fault;

      if( (  ( (moni&0xff)!=0) && ((moni&0xff)!=0xbc))||( ((moni&0xff00)!=0) && ((moni&0xff00)!=0xbc00) ) ||
	  ( ((moni&0xff0000)!=0) && ((moni&0xff0000)!=0xbc0000) ) ||( ((moni&0xff000000)!=0) &&( (moni&0xff000000)!=0xbc000000)) )
	{
	  PEXOR_SERDES_Reset(ps_pexor);

	}else{
	  flag=1;
	}
    }
     
    if(flag==-1){
      printf ("PEXOR_RX_Monitor Error: loop %d 0x%8x 0x%8x 0x%8x  \n",loop, fault, moni ,moni&fault);
    }
  return(flag);
}


int PEXOR_Show_Version( s_pexor *ps_pexor ){
  long tmp, year,month,day,version[2];
  tmp=(*ps_pexor-> pexor_version);
  year=((tmp&0xff000000)>>24)+0x2000;
  month=(tmp&0xff0000)>>16;
  day=(tmp&0xff00)>>8;
  version[0]=(tmp&0xf0)>>4;
  version[1]=(tmp&0xf);

  printf ("PEXOR program compiled at Year=%x Month=%x Date=%x Version=%x.%x \n", year,month,day,version[0],version[1]);
     
  return(1);
}

int PEXOR_SFP_Active( s_pexor *ps_pexor, long l_sfp  ){
  long l_comm;
  long l_slave=100;
  long a,b,c;
  long l_num;
  long active;
  long loop;
  long loopmax=10;

  active=((~*ps_pexor->sfp_fault)>>l_sfp)&0x1;
  l_num=-1;
  loop=0;
  if(active==1&&loop<loopmax){
    l_comm = PEXOR_INI_REQ| (0x1<<16+l_sfp);
    PEXOR_RX_Clear_Ch(ps_pexor, l_sfp); 
    while(l_num==-1){
      PEXOR_TX(ps_pexor, l_comm, 0, l_slave) ;
      //  printf (" SFP%d: ",l_sfp);
      if(PEXOR_RX(ps_pexor, l_sfp, &a , &b, &c)==-1) {
	//    printf ("no reply: 0x%x 0x%x 0x%x \n", a,b,c);
	l_num=-1;
      }else{
	//    printf ("Reply: 0x%x 0x%x 0x%x \n", a,b,c);
	//    printf ("     : No of slaves  : 0x%x\n", b);
	l_num=b;
      }
      loop++;
    }
  }
  //  printf (" SFP0 %x    : No of slaves  : %i \n", l_sfp, l_num);
     
  return(l_num);
}



int PEXOR_SFP_Disable( s_pexor *ps_pexor,  long disa ){
  //  *ps_pexor->sfp_disa = disa;

  printf ("PEXOR_SFP_Disable: x%x  x%x  \n", ps_pexor->sfp_disa, *ps_pexor->sfp_disa);
/*   printf ("PEXOR_SFP_-4 x%x  x%x  \n", (ps_pexor->sfp_fifo-4), *(ps_pexor->sfp_fault-4)); */
/*   printf ("PEXOR_SFP_-3: x%x  x%x  \n", (ps_pexor->sfp_fifo-3), *(ps_pexor->sfp_fault-3)); */
/*   printf ("PEXOR_SFP_-2: x%x  x%x  \n", (ps_pexor->sfp_fifo-2), *(ps_pexor->sfp_fault-2)); */
/*   printf ("PEXOR_SFP_-1: x%x  x%x  \n", (ps_pexor->sfp_fifo-1), *(ps_pexor->sfp_fault-1)); */
/*   printf ("PEXOR_SFP_FIFO: x%x  x%x  \n", ps_pexor->sfp_fifo, *ps_pexor->sfp_fifo); */
  return(1);
}

int PEXOR_SFP_Show_FIFO( s_pexor *ps_pexor, long ch ){
  int i;
  long tmp;
  i=0;
  printf ("PEXOR_SFP_Show_FIFO: \n");
  tmp=*(ps_pexor->sfp_fifo+ch);
  while((tmp&0xf00)!=0x500){
    printf ("x%x  x%2x \n", i, 0xfff&tmp);
    tmp=*(ps_pexor->sfp_fifo+ch);
    i++;
  }
  printf ("x%x  x%2x \n", i, 0xfff&tmp);
  return(1);
}

int PEXOR_SFP_Clear_FIFO( s_pexor *ps_pexor ){
  *ps_pexor->sfp_fifo = 0xf;
  return(1);
}


  
int PEXOR_Set_LED( s_pexor *ps_pexor, long l_led){
  int i,j;
  long a;
  long l_slave[4];

  for(i=0;i<4;i++){
    l_slave[i]=PEXOR_SFP_Active(ps_pexor, i);
    if(l_slave[i]>0){
      printf ("SFP port: %i\n", i );
      for(j=0;j<l_slave[i];j++){
	PEXOR_Slave_Read( ps_pexor, i, j, REG_VERSION, &a );
	PEXOR_Slave_Write( ps_pexor, i, j, REG_LED, l_led );
	printf ("  Module ID: 0x%x Program Version: 0x%x LED off\n",j , a );
      }
    }
  }
}


int PEXOR_LED_On( s_pexor *ps_pexor ){
  PEXOR_Set_LED( ps_pexor, 0x0 );
}
int PEXOR_LED_Off( s_pexor *ps_pexor ){
  PEXOR_Set_LED( ps_pexor, 0x100 );
}


int PEXOR_Set_Data_Reduction( s_pexor *ps_pexor, long l_flag){
  int i,j;
  long a;
  long l_slave[4];

  for(i=0;i<4;i++){
    l_slave[i]=PEXOR_SFP_Active(ps_pexor, i);
    if(l_slave[i]>0){
#ifdef DEBUG
      printf ("SFP port: %i\n", i );
#endif
      for(j=0;j<l_slave[i];j++){
	PEXOR_Slave_Read( ps_pexor, i, j, REG_VERSION, &a );
	PEXOR_Slave_Write( ps_pexor, i, j, REG_DATA_REDUCTION, l_flag );
#ifdef DEBUG
	printf ("  Module ID: 0x%x Program Version: 0x%x Data Reduction 0x%\n",j , l_flag );
#endif
      }
    }
  }
}



#endif