socket.c

用C8051F020实现的基于TCP/IP协议的虚功率源。C8051F020外接LCD,键盘,USB接口

		wait_1ms(1);
#ifdef DEBUG
		PutStringLn("send_in() at S_START : size == 0");
#endif
		goto S_START;
	}
	else if (size < len)	len = size;

	send_ptr = (u_char *)( SBUFBASEADDRESS[s] + (UINT)(wr_ptr.lVal & SMASK[s]));    // Calculate pointer to data copy
	write_data(s, buf, send_ptr, len);                                              // data copy

	while (COMMAND(s) & CSEND)                                                      // Confirm send command
		if (select(s, SEL_CONTROL) != SOCK_ESTABLISHED) return -1;                  // Error

	wr_ptr.lVal = wr_ptr.lVal + len;                                                // tx_wr_ptr update
	*TX_WR_PTR(s) = wr_ptr.cVal[0];
	*(TX_WR_PTR(s) + 1) = wr_ptr.cVal[1];
	*(TX_WR_PTR(s) + 2) = wr_ptr.cVal[2];
	*(TX_WR_PTR(s) + 3) = wr_ptr.cVal[3];

	COMMAND(s) = CSEND;                                                             // SEND

    return	(len);
}

int recv(SOCKET s, const u_char xdata* buf, u_int len)
{
	u_char k;
	u_int size;
	un_l2cval wr_ptr, rd_ptr;
	u_char * recv_ptr;

R_START:
	EX0 = 0;
	k = *SHADOW_RXWR_PTR(s);   	// Must read the shadow register for reading 4byte pointer registers
	wait_1us(2);                    // wait for reading 4byte pointer registers safely
	wr_ptr.cVal[0] = *RX_WR_PTR(s);
	wr_ptr.cVal[1] = *(RX_WR_PTR(s) + 1);
	wr_ptr.cVal[2] = *(RX_WR_PTR(s) + 2);
	wr_ptr.cVal[3] = *(RX_WR_PTR(s) + 3);

	k = *SHADOW_RXRD_PTR(s);        // Must read the shadow register for reading 4byte pointer registers
	wait_1us(2);                    // wait for reading 4byte pointer registers safely
	rd_ptr.cVal[0] = *RX_RD_PTR(s);
	rd_ptr.cVal[1] = *(RX_RD_PTR(s) + 1);
	rd_ptr.cVal[2] = *(RX_RD_PTR(s) + 2);
	rd_ptr.cVal[3] = *(RX_RD_PTR(s) + 3);
	EX0 = 1;

	// calculate received data size
	if ( len <= 0 ) return (0);
	else if (wr_ptr.lVal >= rd_ptr.lVal) size = wr_ptr.lVal - rd_ptr.lVal;
	else size = 0 - rd_ptr.lVal + wr_ptr.lVal;

	
	if (size < len)                                                                 // Wait until receiving is done when received data size is less then len
	{
		if (select(s, SEL_CONTROL) != SOCK_ESTABLISHED) return -1;              // Error
		wait_1ms(1);  
#ifdef DEBUG
//		printf("size < len\r\n");
		PutStringLn("size < len");
#endif
		goto R_START;
	}

	recv_ptr = (u_char *) (RBUFBASEADDRESS[s] + (UINT)(rd_ptr.lVal & RMASK[s]));    // Calculate pointer to be copied received data

	read_data(s, recv_ptr, buf, len);                                               // Copy receibed data

	rd_ptr.lVal += len;                                                             // Update rx_rd_ptr
	*RX_RD_PTR(s) = rd_ptr.cVal[0];
	*(RX_RD_PTR(s) + 1) = rd_ptr.cVal[1];
	*(RX_RD_PTR(s) + 2) = rd_ptr.cVal[2];
	*(RX_RD_PTR(s) + 3) = rd_ptr.cVal[3];

	COMMAND(s) = CRECV;                                                             // RECV

    return	(len);
}

#endif	// __TCP__

#ifdef	__UDP__

u_int sendto(SOCKET s, const u_char xdata * buf, u_int len, u_char * addr, u_int port)
{
	int ptr, size;

	while(COMMAND(s) & CSEND)				    // Wait until previous send commnad has completed
		if(select(s,SEL_CONTROL) == SOCK_CLOSED) return -1; // Errors.

	if (port != 0)                                              // Designate destination port number
	{						
		*DST_PORT_PTR(s) = (u_char)((port & 0xff00) >> 8);
		*(DST_PORT_PTR(s) + 1) = (u_char)(port & 0x00ff);
	}

	*DST_IP_PTR(s) = addr[0];                                   // Designate destination IP address
	*(DST_IP_PTR(s) + 1) = addr[1];
	*(DST_IP_PTR(s) + 2) = addr[2];
	*(DST_IP_PTR(s) + 3) = addr[3];


#ifdef DEBUG
//	printf("sendto Parameter\r\n");
//	printf("Destination Port : %d\r\n", (u_int)*(DST_PORT_PTR(s)));
//	printf("Destination IP : %d.%d.%d.%d\r\n", *DST_IP_PTR(s) ,*DST_IP_PTR(s)+1, *DST_IP_PTR(s)+2, *DST_IP_PTR(s)+3);
	PutStringLn("sendto Parameter");
	PutString("Destination Port : ");PutHTOA(*DST_PORT_PTR(s));PutHTOA(*(DST_PORT_PTR(s)+1));PutStringLn("");
	PutString("Destination IP : "); 
	PutHTOA(*DST_IP_PTR(s)); PutByte('.'); PutHTOA(*(DST_IP_PTR(s)+1)); PutByte('.'); PutHTOA(*(DST_IP_PTR(s)+2)); PutByte('.'); PutHTOA(*(DST_IP_PTR(s)+3));
	PutStringLn("");
#endif
	if (len <= 0) return (0);
	else 
	{
		ptr = 0;
		do{
			size = sendto_in(s, buf + ptr, len);
			if(size == -1) return -1;	// Error
			len = len - size;
			ptr += size;
		}while ( len > 0);
	}
	return ptr;
}

u_int sendto_in(SOCKET s, const u_char xdata * buf, u_int len)
{
	u_char k;
	u_int size;
	un_l2cval wr_ptr, rd_ptr;
	u_char * send_ptr;

S2_START:
	if(select(s,SEL_CONTROL)==SOCK_CLOSED) return -1;	// Error
	EX0 = 0;
	k = *SHADOW_TXWR_PTR(s);
	wait_1us(2);
	wr_ptr.cVal[0] = *TX_WR_PTR(s);
	wr_ptr.cVal[1] = *(TX_WR_PTR(s) + 1);
	wr_ptr.cVal[2] = *(TX_WR_PTR(s) + 2);
	wr_ptr.cVal[3] = *(TX_WR_PTR(s) + 3);

	k = *SHADOW_TXRD_PTR(s);
	wait_1us(2);
	rd_ptr.cVal[0] = *TX_RD_PTR(s);
	rd_ptr.cVal[1] = *(TX_RD_PTR(s) + 1);
	rd_ptr.cVal[2] = *(TX_RD_PTR(s) + 2);
	rd_ptr.cVal[3] = *(TX_RD_PTR(s) + 3);
        EX0 = 1;

	// Calculate free buffer size to send
	if (wr_ptr.lVal >= rd_ptr.lVal) size = SSIZE[s] - (wr_ptr.lVal - rd_ptr.lVal);
	else size = SSIZE[s] - (0 - rd_ptr.lVal + wr_ptr.lVal);
	
	if (size > SSIZE[s])                                                            // Recalulate after some delay because of error in pointer caluation
	{
		wait_1ms(1);
#ifdef DEBUG
		PutString("sendto_in() at S2_START : ");PutHTOA(s); PutString(" : "); PutLTOA(wr_ptr.lVal) ; PutString(" : ");PutLTOA(rd_ptr.lVal) ;PutStringLn("");
#endif
		goto S2_START;
	}

	if (size == 0)                                                                  // Wait when previous sending has not finished yet and there's no free buffer
	{
		wait_1ms(1);
#ifdef DEBUG
		PutString("sendto_in() at S2_START : size == 0");
#endif
		goto S2_START;
	} 
	else if (size < len)	len = size;

	send_ptr = (u_char *)(SBUFBASEADDRESS[s] + (UINT)(wr_ptr.lVal & SMASK[s]));     // Calculate pointer to copy data pointer

	write_data(s, buf, send_ptr, len);                                              // Copy data

	while (COMMAND(s) & CSEND)							// Confirm previous send command
		if(select(s,SEL_CONTROL)==SOCK_CLOSED) return -1;                       // Error

	wr_ptr.lVal = wr_ptr.lVal + len;                                                // Update tx_wr_ptr
	*TX_WR_PTR(s) = wr_ptr.cVal[0];
	*(TX_WR_PTR(s) + 1) = wr_ptr.cVal[1];
	*(TX_WR_PTR(s) + 2) = wr_ptr.cVal[2];
	*(TX_WR_PTR(s) + 3) = wr_ptr.cVal[3];

	COMMAND(s) = CSEND;                                                             // SEND

    return	(len);
}

u_int recvfrom(SOCKET s, const u_char xdata * buf, u_int len,u_char * addr, u_int * port)
{
	struct _UDPHeader                      // When receiving UDP data, header added by W3100A
	{
		union 
		{
			struct
			 { 
				u_int size; 
				u_char addr[4]; 
				u_int port;
			}header;
			u_char stream[8];
        	}u;
	}xdata UDPHeader;

	u_int ret;
	u_char * recv_ptr;
	un_l2cval wr_ptr, rd_ptr;
	u_long size;
	u_char k;

	if(select(s,SEL_CONTROL)==SOCK_CLOSED) return -1;
	EX0 = 0;
	k = *SHADOW_RXWR_PTR(s);
	wait_1us(2);
	wr_ptr.cVal[0] = *RX_WR_PTR(s);
	wr_ptr.cVal[1] = *(RX_WR_PTR(s) + 1);
	wr_ptr.cVal[2] = *(RX_WR_PTR(s) + 2);
	wr_ptr.cVal[3] = *(RX_WR_PTR(s) + 3);

	k = *SHADOW_RXRD_PTR(s);
	wait_1us(2);
	rd_ptr.cVal[0] = *RX_RD_PTR(s);
	rd_ptr.cVal[1] = *(RX_RD_PTR(s) + 1);
	rd_ptr.cVal[2] = *(RX_RD_PTR(s) + 2);
	rd_ptr.cVal[3] = *(RX_RD_PTR(s) + 3);
	EX0 = 1;

	// Calculate received data size
	if(len <=0) return 0;
	else if (wr_ptr.lVal >= rd_ptr.lVal) size = wr_ptr.lVal - rd_ptr.lVal;
	else size = 0 - rd_ptr.lVal + wr_ptr.lVal;

	if(size == 0) return 0;
	
	recv_ptr = (u_char *)(RBUFBASEADDRESS[s] + (UINT)(rd_ptr.lVal & RMASK[s]));     // Calulate received data pointer

	if ((OPT_PROTOCOL(s) & 0x07) == SOCK_DGRAM)                                     // Handle UDP data
	{
		read_data(s,recv_ptr,UDPHeader.u.stream,8);                             // W3100A UDP header copy
  		addr[0] = UDPHeader.u.header.addr[0];                                   // Read IP address of the peer
		addr[1] = UDPHeader.u.header.addr[1];
		addr[2] = UDPHeader.u.header.addr[2];
		addr[3] = UDPHeader.u.header.addr[3];                                   // Read Port number of the peer
		*port = UDPHeader.u.stream[6];
		*port = (*port << 8) + UDPHeader.u.stream[7];

#ifdef DEBUG
//		printf("UDP msg arrived\r\n");
//		printf("source Port : %d\r\n", *port);
//		printf("source IP : %d.%d.%d.%d\r\n", addr[0], addr[1], addr[2], addr[3]);
		PutStringLn("UDP msg arrived");
		PutString("UDP Header Size : 0x");PutITOA(UDPHeader.u.header.size);PutStringLn("");
		PutString("Source Port : ");PutITOA(*port);PutStringLn("");
		PutString("Destination IP : ");PutHTOA(addr[0]);PutByte('.');PutHTOA(addr[1]);PutByte('.');PutHTOA(addr[2]);PutByte('.');PutHTOA(addr[3]);PutStringLn("");
#endif  
		size = UDPHeader.u.header.size - 8;
		rd_ptr.lVal += 8;		
		recv_ptr = (u_char *)(RBUFBASEADDRESS[s] + (UINT)(rd_ptr.lVal & RMASK[s]));
		ret = read_data(s, recv_ptr, buf,size);
		rd_ptr.lVal += ret;
#ifdef DEBUG
{
 		int i;	
//		printf("%.8lx : %.8lx : %.8lx\r\n", recv_ptr, buf, rd_ptr.lVal);
//		for (i = 0; i < ret; i++) printf("%c", buf[i]);
		PutLTOA((u_long)(recv_ptr)); PutString(" : ");PutLTOA((u_long)buf); PutString(" : ");PutLTOA(rd_ptr.lVal); PutStringLn("");
		for (i = 0; i < ret; i++) PutByte(buf[i]);
		PutStringLn("");
}
#endif
	}
#ifdef __IP_RAW__	
	else if ((OPT_PROTOCOL(s) & 0x07) == SOCK_IPL_RAW)                                  // When received IP layer RAW mode data
	{
//		for(i = 0; i < 4; i++) addr[i] = recv_ptr[2+i];                             // IP layer header copy
		read_data(s,recv_ptr,UDPHeader.u.stream,6);
		addr[0] = UDPHeader.u.header.addr[0];
		addr[1] = UDPHeader.u.header.addr[1];
		addr[2] = UDPHeader.u.header.addr[2];
		addr[3] = UDPHeader.u.header.addr[3];
#ifdef DEBUG
//		printf("ICMP msg received\r\n");
		PutStringLn("ICMP msg received");
		PutString("IP RAW Packet Data Size = ");PutITOA(UDPHeader.u.header.size);PutStringLn("");
		PutString("Destination IP : ");PutHTOA(addr[0]);PutByte('.');PutHTOA(addr[1]);PutByte('.');PutHTOA(addr[2]);PutByte('.');PutHTOA(addr[3]);PutStringLn("");		
#endif
		rd_ptr.lVal += 6;                                                           // Increment read pointer by 6, because already read as IP RAW header size
		recv_ptr = (u_char *)(RBUFBASEADDRESS[s] + (UINT)(rd_ptr.lVal & RMASK[s])); // Calculate IP layer raw mode data pointer
		ret = read_data(s, recv_ptr, buf, UDPHeader.u.header.size);                                     // data copy.
		rd_ptr.lVal += (ret-4);
	} 
#endif	// end __IP_RAW__

	*RX_RD_PTR(s)       = rd_ptr.cVal[0];		// Update rx_rd_ptr
	*(RX_RD_PTR(s) + 1) = rd_ptr.cVal[1];
	*(RX_RD_PTR(s) + 2) = rd_ptr.cVal[2];
	*(RX_RD_PTR(s) + 3) = rd_ptr.cVal[3];

#ifdef DEBUG
	EX0 = 0;
	k = *SHADOW_RXWR_PTR(s);
	wait_1us(2);
	wr_ptr.cVal[0] = *RX_WR_PTR(s);
	wr_ptr.cVal[1] = *(RX_WR_PTR(s) + 1);
	wr_ptr.cVal[2] = *(RX_WR_PTR(s) + 2);
	wr_ptr.cVal[3] = *(RX_WR_PTR(s) + 3);

	k = *SHADOW_RXRD_PTR(s);
	wait_1us(2);
	rd_ptr.cVal[0] = *RX_RD_PTR(s);
	rd_ptr.cVal[1] = *(RX_RD_PTR(s) + 1);
	rd_ptr.cVal[2] = *(RX_RD_PTR(s) + 2);
	rd_ptr.cVal[3] = *(RX_RD_PTR(s) + 3);
	EX0 = 1;

//	printf("%.8lx : %.8lx\r\n", wr_ptr.lVal, rd_ptr.lVal);
	PutLTOA(wr_ptr.lVal); PutString(" : ");PutLTOA(rd_ptr.lVal); PutStringLn("");
#endif


	COMMAND(s) = CRECV;                                                                 // RECV
    return	(ret);	// Real received size return
}

#endif	// __UDP__

void close(SOCKET s)
{
	u_int len;

	if (select(s, SEL_CONTROL) == SOCK_CLOSED) return;	   // Already closed

	// When closing, if there's data which have not processed, Insert some source codes to handle this
	// Or before application call close(), handle those data first and call close() later.


	len = select(s, SEL_SEND);
	if (len == SSIZE[s])
	{
		I_STATUS[s] =0;
		COMMAND(s) = CCLOSE;                               // CLOSE
		while(!(I_STATUS[s] & SCLOSED));
	}
}

u_int select(SOCKET s, u_char func)
{
	u_int val;
	un_l2cval rd_ptr, wr_ptr, ack_ptr;
	u_char k;

	switch (func) {
	case SEL_CONTROL :                                     // socket status information
		val = SOCK_STATUS(s);
		break;

	case SEL_SEND :                                        // Calculate send free buffer size
		EX0 = 0;
		k = *SHADOW_TXWR_PTR(s);
		wait_1us(2);
		wr_ptr.cVal[0] = *TX_WR_PTR(s);
		wr_ptr.cVal[1] = *(TX_WR_PTR(s) + 1);
		wr_ptr.cVal[2] = *(TX_WR_PTR(s) + 2);
		wr_ptr.cVal[3] = *(TX_WR_PTR(s) + 3);

		if( (OPT_PROTOCOL(s)& 0x07) != SOCK_STREAM)
		{
			k = *SHADOW_TXRD_PTR(s);
			wait_1us(2);
			ack_ptr.cVal[0] = *TX_RD_PTR(s);
			ack_ptr.cVal[1] = *(TX_RD_PTR(s) + 1);
			ack_ptr.cVal[2] = *(TX_RD_PTR(s) + 2);
			ack_ptr.cVal[3] = *(TX_RD_PTR(s) + 3);
		}
		else
		{
			k = *SHADOW_TXACK_PTR(s);
			wait_1us(2);
			ack_ptr.cVal[0] = *TX_ACK_PTR(s);
			ack_ptr.cVal[1] = *(TX_ACK_PTR(s) + 1);
			ack_ptr.cVal[2] = *(TX_ACK_PTR(s) + 2);
			ack_ptr.cVal[3] = *(TX_ACK_PTR(s) + 3);
		}
		EX0 = 1;

		if (wr_ptr.lVal >= ack_ptr.lVal) val = SSIZE[s] - (wr_ptr.lVal - ack_ptr.lVal);
		else val = SSIZE[s] - (0 - ack_ptr.lVal + wr_ptr.lVal);
		break;
	case SEL_RECV :                                        // Calculate received data size	
		EX0 = 0;
		k = *SHADOW_RXWR_PTR(s);
		wait_1us(2);
		wr_ptr.cVal[0] = *RX_WR_PTR(s);
		wr_ptr.cVal[1] = *(RX_WR_PTR(s) + 1);
		wr_ptr.cVal[2] = *(RX_WR_PTR(s) + 2);
		wr_ptr.cVal[3] = *(RX_WR_PTR(s) + 3);

		k = *SHADOW_RXRD_PTR(s);
		wait_1us(2);
		rd_ptr.cVal[0] = *RX_RD_PTR(s);
		rd_ptr.cVal[1] = *(RX_RD_PTR(s) + 1);
		rd_ptr.cVal[2] = *(RX_RD_PTR(s) + 2);
		rd_ptr.cVal[3] = *(RX_RD_PTR(s) + 3);
		EX0 = 1;

		if (wr_ptr.lVal == rd_ptr.lVal){ val = 0;}
		else if (wr_ptr.lVal > rd_ptr.lVal) val = wr_ptr.lVal - rd_ptr.lVal;
		else val = 0 - rd_ptr.lVal + wr_ptr.lVal;
		
#ifdef DEBUG
		PutString("wr_ptr.lVal = ");PutLTOA(wr_ptr.lVal);PutString(" : rd_ptr.lVal = ");PutLTOA(rd_ptr.lVal);PutString(" : size = ");PutITOA(val);PutStringLn("");
#endif		
		break;
	default :
		val = -1;
		break;
	}

    return	( val );
}

u_int read_data(SOCKET s, u_char xdata* src, u_char xdata* dst, u_int len)
{
	u_int i, size, size1;

	if (len == 0) return 0;

	if( (((u_int)src & RMASK[s]) + len)  > RSIZE[s] ) 
	{
		size = RSIZE[s] - ((u_int)src & RMASK[s]);
		for (i = 0; i < size; i++) *dst++ = *src++;
		size1 = len - size;
		src =  RBUFBASEADDRESS[s];
		for (i = 0; i < size1; i++) *dst++ = *src++;
	}
	else
        	for (i = 0; i < len; i++) *dst++ = *src++;
	return len;
}

u_int write_data(SOCKET s, u_char xdata* src, u_char xdata* dst, u_int len)
{
	u_int i, size, size1;

	if (len == 0) return 0;

	if ( (((u_int)dst & SMASK[s]) + len) > SSIZE[s] ) 
	{
		size = SSIZE[s] - ((UINT)dst & SMASK[s]);

		for (i = 0; i < size; i++) *dst++ = *src++;
		size1 = len - size;
		dst = (SBUFBASEADDRESS[s]);
		for (i = 0; i < size1; i++) *dst++ = *src++;
	} 
	else
		for (i = 0; i < len; i++) *dst++ = *src++;

	return len;
}

void wait_1ms(int cnt)
{
	u_int i;

	for (i = 0; i < cnt; i++) wait_1us(1000);
}

void wait_1us(int cnt)
{
	u_int i;

	for (i = 0; i < cnt; i++) ;
}