enetlib.c-fjj-bak

Ibmstb02500 miniboot 源码

   nsdelay(50);
   id_val |=( in16(ENET_IO_ADDR + 4)&0x00ff) << 8;
   nsdelay(50); 
   out16(ENET_IO_ADDR,DM9KS_PID_L);
   nsdelay(50); 
   id_val |=( in16(ENET_IO_ADDR + 4)&0x00ff) << 16;
   nsdelay(50);
   out16(ENET_IO_ADDR,DM9KS_PID_H);
   nsdelay(50); 
   id_val |=(in16(ENET_IO_ADDR + 4)&0x00ff) << 24;
   if(id_val==0x90000a46)   s1printf("\n dm9000a is found!!!!!!!!1\n");  
   out16( ENET_IO_ADDR,DM9KS_GPR);
   nsdelay(50);
   out16(( ENET_IO_ADDR+4),0x00);
   nsdelay(50);              
   out16(ENET_IO_ADDR,DM9KS_TCR2);
   nsdelay(50);
   out16(( ENET_IO_ADDR+4),0x80);
   nsdelay(50);        
   out16( ENET_IO_ADDR,DM9KS_TCR2);
   nsdelay(50);
  /* id_val = in16(ENET_IO_ADDR + 4)&0x00ff;
   s1printf("\n led mode  is %x\n",id_val);*/
   return(1);
}

/*-----------------------------------------------------------------------------+
| EnetTest.
+-----------------------------------------------------------------------------*/
int enetTest()
{

   char hw_addr[6];

   if (enetisThere(NULL, NULL, (int *)hw_addr)==1) {
#ifdef DEBUG_MSG_TEST
   s1printf("enetTest successful...\n");
#endif
      return(0);
   } else {
#ifdef DEBUG_MSG_TEST
   s1printf("enetTest unsuccessful...\n");
#endif
      return(-1);
   }
}
unsigned char ior(int reg)
{
	out16(ENET_IO_ADDR,reg);
	 nsdelay(50); 
	return (in16(ENET_IO_ADDR+4)&0xff);
}

/*
   Write a byte to I/O port
*/
static void iow(int reg, unsigned char value)
{
	
	out16(ENET_IO_ADDR,reg);
	 nsdelay(50); 
	out16((ENET_IO_ADDR+4),value); 
}

/*-----------------------------------------------------------------------------+
| enetInit.
+-----------------------------------------------------------------------------*/
int enetInit(unsigned long *srcaddr,
    unsigned long *dstaddr, int *parmp)
{
   static unsigned version_printed = 0;

   /* registers */
   unsigned short revision_register;
   unsigned short memory_info_register;
   unsigned long  temp;
   unsigned long  msr;
   unsigned char io_mode; 

   const char *    version_string;
   int   memory, i;

#if 0
   s1printf("\n\n");
   s1printf("ENET Device is not available at this time\n");
   s1printf("Please reset your board to continue...\n");
   s1printf("\n\n - Processor Halted... \n");
   ppcHalt();

   return(0);  /*** WORKING ON IT *****/
#endif

#ifdef DEBUG_MSG_INIT
   s1printf("enetInit Entered...\n");
#endif

   msr=ppcAndMsr(~ppcMsrEE);

   (void)memcpy(dev.name, name, sizeof(name));
#ifdef DEBUG_MSG_INIT
    s1printf("device name = %s\n", dev.name);
#endif

    if (version_printed++ == 0) {
#ifdef DEBUG_MSG_INIT
            s1printf("version %s", version);
#endif
    }

    /* fill in some of the fields */
    dev.base_addr = ENET_IO_ADDR;
    dev.irq       = ENET_INT;
    (void)memcpy(dev.dev_addr, parmp, 6);
    
    	iow(DM9KS_GPR, 0);	/* GPR (reg_1Fh)bit GPIO0=0 pre-activate PHY */
	nsdelay(2000);		/* wait 2ms for PHY power-on ready */

	/* do a software reset and wait 20us */
	iow(DM9KS_NCR, 3);
	nsdelay(2000);		/* wait 20us at least for software reset ok */
	iow(DM9KS_NCR, 3);	/* NCR (reg_00h) bit[0] RST=1 & Loopback=1, reset on. Added by SPenser */
	nsdelay(2000);		/* wait 20us at least for software reset ok */

	/* I/O mode */
	io_mode = ior(DM9KS_ISR) >> 6; /* ISR bit7:6 keeps I/O mode */
	// s1printf("io_mode is  %x", io_mode);

	/* Set PHY mode is auto*/
	
	set_PHY_mode(8);

	/* Program operating register */
	iow(DM9KS_NCR, 0);
	iow(DM9KS_TCR, 0);		/* TX Polling clear */
	iow(DM9KS_BPTR, 0x3f);	/* Less 3kb, 600us */
	iow(DM9KS_SMCR, 0);		/* Special Mode */
	iow(DM9KS_NSR, 0x2c);	/* clear TX status */
	iow(DM9KS_ISR, 0x0f); 	/* Clear interrupt status */

	/* Added by jackal at 03/29/2004 */

	iow(DM9KS_TCCR, 0x07);	/* TX UDP/TCP/IP checksum enable */
	iow(DM9KS_RCSR, 0x02);	/*Receive checksum enable */



	iow(DM9KS_TCR2, 0x90);
	iow(DM9KS_ETXCSR, 0x83);

 
	/* Set address filter table */
	dm9000_hash_table();

	
   dev.tbusy      = 0;
   dev.interrupt  = 0;
   dev.start      = 1;
   dev.phyaddr    = 0x00;  // YYD
 
   /*--------------------------------------------------------------------------+
   | Enable and configure the pocessor interrupts in level 1.
   +--------------------------------------------------------------------------*/
   temp = ppcMfuiccr();
   ppcMtuiccr(temp & (~(0x80000000>>ENET_INT)));
   temp = ppcMfuictr();
   ppcMtuictr(temp & (~(0x80000000>>ENET_INT)));
   temp = ppcMfuicpr();
   ppcMtuicpr(temp & (~(0x80000000>>ENET_INT)));
   ppcMtuicsr(0x80000000>>ENET_INT);
   temp = ppcMfuicer();
   ppcMtuicer(temp | (0x80000000>>ENET_INT));
   ip_addr=srcaddr;
  // s1printf("&&&&&&&&&&&&&ip addr is %x \n",*ip_addr);
   (void)ppcMtmsr(msr);
    
   /* Activate DM9000A/DM9010 */
iow(DM9KS_RXCR, DM9KS_REG05 | 1);	/* RX enable */
iow(DM9KS_IMR, DM9KS_REGFF); 	// Enable TX/RX interrupt mask
   
   return(0);
}



/*-----------------------------------------------------------------------------+
 . Function: Enet_send_macframe
 .
 . Purpose:
 .      This sends the actual packet to the SMC9xxx chip.
 .
 . Algorithm:
 .      First, see if a buf is available.
 .      Now, find the packet number that the chip allocated
 .      Point the data pointers at it in memory
 .      Set the length word in the chip's memory
 .      Dump the packet to chip memory
 .      Check if a last byte is needed ( odd length packet )
 .              if so, set the control flag right
 .      Tell the card to send it
 .      Enable the transmit interrupt, so I know if it failed
+-----------------------------------------------------------------------------*/
int enet_send_macframe(char * frame, int frame_len)
{

   struct enet_frame    *ef_ptr=(struct enet_frame *)frame;

   char                    packet_no;
   unsigned int            length;
   char                    *buf;
   char                    mask;
   unsigned  int  delay_time=3;

#ifdef DEBUG_MSG_MACFRAME
   s1printf("%s: SEND_MACFRAME: Entered...\n", dev.name);
#endif
//s1printf("111111111111111\n");
/*while (delay_time>0)
{
   if(tx_num==0)break;
   delay_time--;
   nsdelay(1000000);
 }*/  
// s1printf("222222222222222\n");
   /*--------------------------------------------------------------------------+
   | Copy in our address into the frame.
   +--------------------------------------------------------------------------*/
   (void)memcpy(ef_ptr->source_addr, hwd_addr, ENET_ADDR_LENGTH);
   /*--------------------------------------------------------------------------+
   | If frame is too long or too short, modify length.
   +--------------------------------------------------------------------------*/
   if (frame_len>ENET_MAX_MTU) {
      frame_len=ENET_MAX_MTU;
   } else if (frame_len<ENET_MINPACKET) {
      frame_len=ENET_MINPACKET;
   }

   if ( !frame_len ) {
      s1printf("%s: SEND_MACFRAME: In XMIT with no packet to send \n", dev.name);
      return(1);
   }
   length = frame_len;
   buf = frame;




	char * data_ptr;
	int i, tmplen;
	char temp_char;

	/*if (db->tx_pkt_cnt >= 2) return 1;
	
	/* packet counting */
	/*db->tx_pkt_cnt++;

	db->stats.tx_packets++;
	db->stats.tx_bytes+=skb->len;

	if (db->tx_pkt_cnt >= 2)
		netif_stop_queue(dev);*/


	/* Disable all interrupt */
	iow(DM9KS_IMR, DM9KS_DISINTR);
	
	/* Set TX length to reg. 0xfc & 0xfd */
	iow(DM9KS_TXPLL, (length & 0xff));
	iow(DM9KS_TXPLH, (length >> 8) & 0xff);

	/* Move data to TX SRAM */
	data_ptr = (char *)frame;

	 // Write data into SRAM trigger
	out16(ENET_IO_ADDR,DM9KS_MWCMD);
	//db->sent_pkt_len = skb->len;
#ifdef DEBUG_MSG_MACFRAME
   s1printf("%s: SEND_MACFRAME: Begin...\n", dev.name);
#endif
	
			tmplen = (length + 1) / 2;
			for (i = 0; i < tmplen; i++)
			{
         		        temp_char=data_ptr[i*2];
         		        data_ptr[i*2]=data_ptr[i*2+1];
         		        data_ptr[i*2+1]=temp_char;
         			out16((ENET_IO_ADDR+4),((u16 *)data_ptr)[i]);
         			
                        }
	
          
	/* Saved the time stamp */
	/*dev->trans_start = jiffies;

	/* Free this SKB */
	/*dev_kfree_skb(skb);

	/* Re-enable interrupt */
	iow(DM9KS_IMR, DM9KS_REGFF);
	tx_num=1;
	iow(DM9KS_TCR, 0x01);
	
#ifdef DEBUG_MSG_MACFRAME
   s1printf("%s: SEND_MACFRAME: leave...\n", dev.name);
#endif
	return 0;

}

/*-----------------------------------------------------------------------------+
| EnetSend.
+-----------------------------------------------------------------------------*/
int enetSend(char *p,
    int len, int *parmp)
{

   struct enet_frame    *e_frame=(struct enet_frame *)outframe;
   struct arp_frame     *a_frame;
   unsigned char        *datap=e_frame->enet_data;
   unsigned long        msr;
   struct ip            *ip_ptr=(struct ip *)p;
   unsigned long        target_address=ip_ptr->ip_dst.s_addr;
   unsigned long        fake_length;

#ifdef DEBUG_MSG_ENETSEND
   s1printf("%s: ENETSEND: Entered....\n", dev.name);
#endif

   /*--------------------------------------------------------------------------+
   | Disable interrupts.
   +--------------------------------------------------------------------------*/
   msr=ppcAndMsr(~ppcMsrEE);
   if (outframe_len!=0) {
      (void)s1printf("%s: ENETSEND: hold frame collision, outbound frame.\n",dev.name);
      outframe_len=0;
   }
   e_frame->type=ENET_IPTYPE;
  //  (void)s1printf("\ntarget_address is %x\n",target_address);

   /*--------------------------------------------------------------------------+
   | Destination is a broadcast address.
   +--------------------------------------------------------------------------*/
   if (target_address==0xFFFFFFFF) {
      (void)memset(e_frame->dest_addr, 0xFF, ENET_ADDR_LENGTH);
       // s1printf("\nThis is a fffffff packet!!!!!!!!!!\n");
   } else {
   	//target_address=0xc0a80933;
   	//s1printf("\nThis is a NOT fffffff packet!!!!!!!!!!\n");
      if (enetarp_resolve(target_address, (char *)e_frame->dest_addr)==0) {
         unsigned char        outbarp[ENET_MINPACKET];
         //s1printf("\nThis is a arp packet!!!!!!!!!!\n");
         /*--------------------------------------------------------------------+
         | Build arp packet and send it instead of data packet.
         +--------------------------------------------------------------------*/