Commit 67b7333347c0e688d3a1c14a547d7a5fe96ae5c5
1 parent
f9271773
Ajout du squelette
Showing
15 changed files
with
2679 additions
and
0 deletions
Show diff stats
@@ -0,0 +1,37 @@ | @@ -0,0 +1,37 @@ | ||
1 | +# | ||
2 | +# Makefile pour le projet filtrage réseau | ||
3 | +# | ||
4 | + | ||
5 | +# | ||
6 | +# Constantes pour la compilation des programmes | ||
7 | +# | ||
8 | + | ||
9 | +export CC = gcc | ||
10 | +export LD = gcc | ||
11 | +export CLIB = ar cq | ||
12 | +export CFLAGS = -Wall | ||
13 | +export CDEBUG = -g -DDEBUG | ||
14 | + | ||
15 | +# | ||
16 | +# Constantes liees au projet | ||
17 | +# | ||
18 | + | ||
19 | +DIRS=Network Threads | ||
20 | + | ||
21 | +# | ||
22 | +# La cible generale | ||
23 | +# | ||
24 | + | ||
25 | +all: $(patsubst %, _dir_%, $(DIRS)) | ||
26 | + | ||
27 | +$(patsubst %,_dir_%,$(DIRS)): | ||
28 | + cd $(patsubst _dir_%,%,$@) && make | ||
29 | + | ||
30 | +# | ||
31 | +# La cible de nettoyage | ||
32 | +# | ||
33 | + | ||
34 | +clean: $(patsubst %, _clean_%, $(DIRS)) | ||
35 | + | ||
36 | +$(patsubst %,_clean_%,$(DIRS)): | ||
37 | + cd $(patsubst _clean_%,%,$@) && make clean |
@@ -0,0 +1,22 @@ | @@ -0,0 +1,22 @@ | ||
1 | +# | ||
2 | +# Makefile pour generer la bibliotheque de fonctions de communication | ||
3 | +# | ||
4 | + | ||
5 | +all: libnet.a | ||
6 | + | ||
7 | +# | ||
8 | +# La cible de nettoyage | ||
9 | +# | ||
10 | + | ||
11 | +clean: | ||
12 | + rm -f core *.o libnet.a | ||
13 | + | ||
14 | +# | ||
15 | +# Les cibles pour la bibliotheque | ||
16 | +# | ||
17 | + | ||
18 | +libnet.o: libnet.c libnet.h | ||
19 | + | ||
20 | +libcom.a: libnet.o | ||
21 | + rm -f $@ | ||
22 | + $(CLIB) $@ $+ |
@@ -0,0 +1,34 @@ | @@ -0,0 +1,34 @@ | ||
1 | +MCU = atmega328p | ||
2 | +FCPU = 16000000 | ||
3 | + | ||
4 | +CC = avr-gcc | ||
5 | +LD = avr-gcc | ||
6 | +FLAGS = -mmcu=$(MCU) | ||
7 | +CFLAGS = -Wall $(FLAGS) -DF_CPU=$(FCPU) -Os | ||
8 | +LDFLAGS = $(FLAGS) | ||
9 | + | ||
10 | +DUDE = avrdude | ||
11 | +PROTOCOL = stk500v1 # stk500 / stk500v1 | ||
12 | +SPEED = 115200 # 57600 / 115200 | ||
13 | +SERIAL = /dev/ttyACM0 # ttyUSB0 / ttyACM0 | ||
14 | + | ||
15 | +TARGET = broadcast | ||
16 | +SOURCES = $(wildcard *.c) | ||
17 | +OBJECTS = $(SOURCES:.c=.o) | ||
18 | + | ||
19 | +all: $(TARGET).hex | ||
20 | + | ||
21 | +clean: | ||
22 | + rm -f *.o $(TARGET).hex $(TARGET) | ||
23 | + | ||
24 | +$(TARGET): $(OBJECTS) | ||
25 | + | ||
26 | +$(TARGET).hex: $(TARGET) | ||
27 | + avr-objcopy -j .text -j .data -O ihex $(TARGET) $(TARGET).hex | ||
28 | + | ||
29 | +upload: $(TARGET).hex | ||
30 | + stty -F $(SERIAL) hupcl | ||
31 | + $(DUDE) -F -v -p $(MCU) -c $(PROTOCOL) -b $(SPEED) -P $(SERIAL) -U flash:w:$(TARGET).hex | ||
32 | + | ||
33 | +size: $(TARGET) | ||
34 | + avr-size --format=avr --mcu=$(MCU) $(TARGET) |
@@ -0,0 +1,15 @@ | @@ -0,0 +1,15 @@ | ||
1 | +#include <stdint.h> | ||
2 | + | ||
3 | +#include "ethernet.h" | ||
4 | +#include "w5100.h" | ||
5 | + | ||
6 | +/** Function for Ethernet hardware **/ | ||
7 | + | ||
8 | +void ethernet_init(uint8_t *mac,uint8_t *ip,uint8_t *gateway,uint8_t *mask){ | ||
9 | +iinchip_init(); | ||
10 | +sysinit(0x55,0x55); | ||
11 | +setSHAR(mac); | ||
12 | +setSIPR(ip); | ||
13 | +setGAR(gateway); | ||
14 | +setSUBR(mask); | ||
15 | +} |
@@ -0,0 +1,167 @@ | @@ -0,0 +1,167 @@ | ||
1 | +/* | ||
2 | +* | ||
3 | +@file ethernet.h | ||
4 | +* | ||
5 | +*/ | ||
6 | + | ||
7 | +#ifndef _ETHERNET_H_ | ||
8 | +#define _ETHERNET_H_ | ||
9 | + | ||
10 | + | ||
11 | +/*************************************************** | ||
12 | + * attribute for mcu ( types, ... ) | ||
13 | + ***************************************************/ | ||
14 | +//#include "mcu_define.h" | ||
15 | +#define __MCU_AVR__ 1 | ||
16 | +#define __MCU_TYPE__ __MCU_AVR__ | ||
17 | + | ||
18 | +//---- Refer "Rom File Maker Manual Vx.x.pdf" | ||
19 | +#include <avr/pgmspace.h> | ||
20 | + | ||
21 | +#define _ENDIAN_LITTLE_ 0 /**< This must be defined if system is little-endian alignment */ | ||
22 | +#define _ENDIAN_BIG_ 1 | ||
23 | +#define SYSTEM_ENDIAN _ENDIAN_LITTLE_ | ||
24 | + | ||
25 | +#define MAX_SOCK_NUM 4 /**< Maxmium number of socket */ | ||
26 | +#define CLK_CPU F_CPU /**< 8Mhz(for serial) */ | ||
27 | + | ||
28 | +/* ## __DEF_IINCHIP_xxx__ : define option for iinchip driver *****************/ | ||
29 | +#define __DEF_IINCHIP_DBG__ /* involve debug code in driver (socket.c) */ | ||
30 | +//#define __DEF_IINCHIP_INT__ /**< involve interrupt service routine (socket.c) */ | ||
31 | +//#define __DEF_IINCHIP_PPP__ /* involve pppoe routine (socket.c) */ | ||
32 | + /* If it is defined, the source files(md5.h,md5.c) must be included in your project. | ||
33 | + Otherwize, the source files must be removed in your project. */ | ||
34 | + | ||
35 | +#define __DEF_IINCHIP_DIRECT_MODE__ 1 | ||
36 | +#define __DEF_IINCHIP_INDIRECT_MODE__ 2 | ||
37 | +#define __DEF_IINCHIP_SPI_MODE__ 3 | ||
38 | + | ||
39 | +//#define __DEF_IINCHIP_BUS__ __DEF_IINCHIP_DIRECT_MODE__ | ||
40 | +//#define __DEF_IINCHIP_BUS__ __DEF_IINCHIP_INDIRECT_MODE__ | ||
41 | +#define __DEF_IINCHIP_BUS__ __DEF_IINCHIP_SPI_MODE__ /*Enable SPI_mode*/ | ||
42 | + | ||
43 | + | ||
44 | +/** | ||
45 | +@brief __DEF_IINCHIP_MAP_xxx__ : define memory map for iinchip | ||
46 | +*/ | ||
47 | +#define __DEF_IINCHIP_MAP_BASE__ 0x8000 | ||
48 | +#if (__DEF_IINCHIP_BUS__ == __DEF_IINCHIP_DIRECT_MODE__) | ||
49 | + #define COMMON_BASE __DEF_IINCHIP_MAP_BASE__ | ||
50 | +#else | ||
51 | + #define COMMON_BASE 0x0000 | ||
52 | +#endif | ||
53 | +#define __DEF_IINCHIP_MAP_TXBUF__ (COMMON_BASE + 0x4000) /* Internal Tx buffer address of the iinchip */ | ||
54 | +#define __DEF_IINCHIP_MAP_RXBUF__ (COMMON_BASE + 0x6000) /* Internal Rx buffer address of the iinchip */ | ||
55 | + | ||
56 | + | ||
57 | +#if (__MCU_TYPE__ == __MCU_AVR__) | ||
58 | + #ifdef __DEF_IINCHIP_INT__ | ||
59 | + // iinchip use external interrupt 4 | ||
60 | + #define IINCHIP_ISR_DISABLE() (EIMSK &= ~(0x10)) | ||
61 | + #define IINCHIP_ISR_ENABLE() (EIMSK |= 0x10) | ||
62 | + #define IINCHIP_ISR_GET(X) (X = EIMSK) | ||
63 | + #define IINCHIP_ISR_SET(X) (EIMSK = X) | ||
64 | + #else | ||
65 | + #define IINCHIP_ISR_DISABLE() | ||
66 | + #define IINCHIP_ISR_ENABLE() | ||
67 | + #define IINCHIP_ISR_GET(X) | ||
68 | + #define IINCHIP_ISR_SET(X) | ||
69 | + #endif | ||
70 | +#else | ||
71 | +#error "unknown MCU type" | ||
72 | +#endif | ||
73 | + | ||
74 | +#ifndef NULL | ||
75 | +#define NULL ((void *) 0) | ||
76 | +#endif | ||
77 | + | ||
78 | +//typedef enum { false, true } bool; | ||
79 | + | ||
80 | +#ifndef _SIZE_T | ||
81 | +#define _SIZE_T | ||
82 | +typedef unsigned int size_t; | ||
83 | +#endif | ||
84 | + | ||
85 | +/** | ||
86 | + * The 8-bit signed data type. | ||
87 | + */ | ||
88 | +typedef char int8; | ||
89 | +/** | ||
90 | + * The volatile 8-bit signed data type. | ||
91 | + */ | ||
92 | +typedef volatile char vint8; | ||
93 | +/** | ||
94 | + * The 8-bit unsigned data type. | ||
95 | + */ | ||
96 | +typedef unsigned char uint8; | ||
97 | +/** | ||
98 | + * The volatile 8-bit unsigned data type. | ||
99 | + */ | ||
100 | +typedef volatile unsigned char vuint8; | ||
101 | + | ||
102 | +/** | ||
103 | + * The 16-bit signed data type. | ||
104 | + */ | ||
105 | +typedef int int16; | ||
106 | +/** | ||
107 | + * The volatile 16-bit signed data type. | ||
108 | + */ | ||
109 | +typedef volatile int vint16; | ||
110 | +/** | ||
111 | + * The 16-bit unsigned data type. | ||
112 | + */ | ||
113 | +typedef unsigned int uint16; | ||
114 | +/** | ||
115 | + * The volatile 16-bit unsigned data type. | ||
116 | + */ | ||
117 | +typedef volatile unsigned int vuint16; | ||
118 | +/** | ||
119 | + * The 32-bit signed data type. | ||
120 | + */ | ||
121 | +typedef long int32; | ||
122 | +/** | ||
123 | + * The volatile 32-bit signed data type. | ||
124 | + */ | ||
125 | +typedef volatile long vint32; | ||
126 | +/** | ||
127 | + * The 32-bit unsigned data type. | ||
128 | + */ | ||
129 | +typedef unsigned long uint32; | ||
130 | +/** | ||
131 | + * The volatile 32-bit unsigned data type. | ||
132 | + */ | ||
133 | +typedef volatile unsigned long vuint32; | ||
134 | + | ||
135 | +/* bsd */ | ||
136 | +typedef uint8 u_char; /**< 8-bit value */ | ||
137 | +typedef uint8 SOCKET; | ||
138 | +typedef uint16 u_short; /**< 16-bit value */ | ||
139 | +typedef uint16 u_int; /**< 16-bit value */ | ||
140 | +typedef uint32 u_long; /**< 32-bit value */ | ||
141 | + | ||
142 | +typedef union _un_l2cval { | ||
143 | + u_long lVal; | ||
144 | + u_char cVal[4]; | ||
145 | +}un_l2cval; | ||
146 | + | ||
147 | +typedef union _un_i2cval { | ||
148 | + u_int iVal; | ||
149 | + u_char cVal[2]; | ||
150 | +}un_i2cval; | ||
151 | + | ||
152 | + | ||
153 | +/** global define */ | ||
154 | +#define FW_VERSION 0x01010000 /* System F/W Version : 1.1.0.0 */ | ||
155 | +#define HW_VERSION 0x01000000 | ||
156 | + | ||
157 | + | ||
158 | +#define TX_RX_MAX_BUF_SIZE 2048 | ||
159 | +#define TX_BUF 0x1100 | ||
160 | +#define RX_BUF (TX_BUF+TX_RX_MAX_BUF_SIZE) | ||
161 | + | ||
162 | +#define UART_DEVICE_CNT 1 /**< UART device number */ | ||
163 | +/* #define SUPPORT_UART_ONE */ | ||
164 | + | ||
165 | +void ethernet_init(uint8_t *mac,uint8_t *ip,uint8_t *gateway,uint8_t *mask); | ||
166 | + | ||
167 | +#endif /* _ETHERNET_H_ */ |
@@ -0,0 +1,83 @@ | @@ -0,0 +1,83 @@ | ||
1 | +/************************ | ||
2 | +* i2c minimal library * | ||
3 | +************************/ | ||
4 | + | ||
5 | +#include <stdint.h> | ||
6 | +#include <avr/io.h> | ||
7 | + | ||
8 | +#include "iic.h" | ||
9 | + | ||
10 | +// Initialize i2c | ||
11 | +void TWI_init(void) | ||
12 | +{ | ||
13 | + //set SCL to 400kHz | ||
14 | + TWSR = 0x00; | ||
15 | + TWBR = 0x0C; | ||
16 | + //enable TWI | ||
17 | + TWCR = (1<<TWEN); | ||
18 | +} | ||
19 | + | ||
20 | +// Send start signal | ||
21 | +static void TWI_start(void) | ||
22 | +{ | ||
23 | + TWCR = (1<<TWINT)|(1<<TWSTA)|(1<<TWEN); | ||
24 | + while ((TWCR & (1<<TWINT)) == 0); | ||
25 | +} | ||
26 | + | ||
27 | +// Send stop signal | ||
28 | +static void TWI_stop(void) | ||
29 | +{ | ||
30 | + TWCR = (1<<TWINT)|(1<<TWSTO)|(1<<TWEN); | ||
31 | +} | ||
32 | + | ||
33 | +// Get i2c bus status | ||
34 | +static uint8_t TWIGetStatus(void) | ||
35 | +{ | ||
36 | + uint8_t status; | ||
37 | + //mask status | ||
38 | + status = TWSR & 0xF8; | ||
39 | + return status; | ||
40 | +} | ||
41 | + | ||
42 | +// Write single byte to bus | ||
43 | +static void TWI_writebyte(uint8_t u8data) | ||
44 | +{ | ||
45 | + TWDR = u8data; | ||
46 | + TWCR = (1<<TWINT)|(1<<TWEN); | ||
47 | + while ((TWCR & (1<<TWINT)) == 0); | ||
48 | +} | ||
49 | + | ||
50 | +// Write i2c minimal message (command) | ||
51 | +uint8_t TWI_writecmd(uint8_t address,uint8_t com_add) | ||
52 | +{ | ||
53 | + TWI_start(); | ||
54 | + if (TWIGetStatus() != 0x08) | ||
55 | + return ERROR; | ||
56 | + TWI_writebyte(address<<1); | ||
57 | + if (TWIGetStatus() != 0x18) | ||
58 | + return ERROR; | ||
59 | + TWI_writebyte(com_add); | ||
60 | + if (TWIGetStatus() != 0x28) | ||
61 | + return ERROR; | ||
62 | + TWI_stop(); | ||
63 | + return SUCCESS; | ||
64 | +} | ||
65 | + | ||
66 | +// Write i2c message (with a single data byte) | ||
67 | +uint8_t TWI_writedata(uint8_t address,uint8_t com_add,uint8_t data) | ||
68 | +{ | ||
69 | + TWI_start(); | ||
70 | + if (TWIGetStatus() != 0x08) | ||
71 | + return ERROR; | ||
72 | + TWI_writebyte(address<<1); | ||
73 | + if (TWIGetStatus() != 0x18) | ||
74 | + return ERROR; | ||
75 | + TWI_writebyte(com_add); | ||
76 | + if (TWIGetStatus() != 0x28) | ||
77 | + return ERROR; | ||
78 | + TWI_writebyte(data); | ||
79 | + if (TWIGetStatus() != 0x28) | ||
80 | + return ERROR; | ||
81 | + TWI_stop(); | ||
82 | + return SUCCESS; | ||
83 | +} |
@@ -0,0 +1,12 @@ | @@ -0,0 +1,12 @@ | ||
1 | +/****************************************** | ||
2 | +* i2c minimal library public definitions * | ||
3 | +******************************************/ | ||
4 | + | ||
5 | +#pragma once | ||
6 | + | ||
7 | +#define ERROR 0 | ||
8 | +#define SUCCESS 1 | ||
9 | + | ||
10 | +void TWI_init(void); | ||
11 | +uint8_t TWI_writecmd(uint8_t address,uint8_t com_add); | ||
12 | +uint8_t TWI_writedata(uint8_t address,uint8_t com_add,uint8_t data); |
@@ -0,0 +1,44 @@ | @@ -0,0 +1,44 @@ | ||
1 | +/** Functions for serial port **/ | ||
2 | + | ||
3 | +#include <avr/io.h> | ||
4 | +#include <stdio.h> | ||
5 | + | ||
6 | +#include "serial.h" | ||
7 | + | ||
8 | +static int send_serial_printf(char c,FILE *stream); | ||
9 | +static FILE mystdout=FDEV_SETUP_STREAM(send_serial_printf,NULL,_FDEV_SETUP_WRITE); | ||
10 | + | ||
11 | +void init_serial(int speed){ | ||
12 | +/* Set baud rate */ | ||
13 | +UBRR0 = F_CPU/(((unsigned long int)speed)<<4)-1; | ||
14 | + | ||
15 | +/* Enable transmitter & receiver */ | ||
16 | +UCSR0B = (1<<TXEN0 | 1<<RXEN0); | ||
17 | + | ||
18 | +/* Set 8 bits character and 1 stop bit */ | ||
19 | +UCSR0C = (1<<UCSZ01 | 1<<UCSZ00); | ||
20 | + | ||
21 | +/* Set off UART baud doubler */ | ||
22 | +UCSR0A &= ~(1 << U2X0); | ||
23 | +} | ||
24 | + | ||
25 | +void send_serial(char c){ | ||
26 | +loop_until_bit_is_set(UCSR0A, UDRE0); | ||
27 | +UDR0 = c; | ||
28 | +} | ||
29 | + | ||
30 | +char get_serial(void){ | ||
31 | +loop_until_bit_is_set(UCSR0A, RXC0); | ||
32 | +return UDR0; | ||
33 | +} | ||
34 | + | ||
35 | +void init_printf(void){ | ||
36 | +init_serial(9600); | ||
37 | +stdout=&mystdout; | ||
38 | +} | ||
39 | + | ||
40 | +static int send_serial_printf(char c,FILE *stream){ | ||
41 | +if(c=='\n') send_serial('\r'); | ||
42 | +send_serial(c); | ||
43 | +return 0; | ||
44 | +} |
@@ -0,0 +1,561 @@ | @@ -0,0 +1,561 @@ | ||
1 | +/* | ||
2 | +* | ||
3 | +@file socket.c | ||
4 | +@brief setting chip register for socket | ||
5 | + last update : 2008. Jan | ||
6 | +* | ||
7 | +*/ | ||
8 | + | ||
9 | +#include "ethernet.h" | ||
10 | +#include "w5100.h" | ||
11 | +#include "socket.h" | ||
12 | + | ||
13 | +#ifdef __DEF_IINCHIP_DBG__ | ||
14 | +#include <stdio.h> | ||
15 | +#endif | ||
16 | + | ||
17 | +static uint16 local_port; | ||
18 | + | ||
19 | +/** | ||
20 | +@brief This Socket function initialize the channel in perticular mode, and set the port and wait for W5100 done it. | ||
21 | +@return 1 for success else 0. | ||
22 | +*/ | ||
23 | +uint8 socket( | ||
24 | + SOCKET s, /**< for socket number */ | ||
25 | + uint8 protocol, /**< for socket protocol */ | ||
26 | + uint16 port, /**< the source port for the socket */ | ||
27 | + uint8 flag /**< the option for the socket */ | ||
28 | + ) | ||
29 | +{ | ||
30 | + uint8 ret; | ||
31 | +#ifdef __DEF_IINCHIP_DBG__ | ||
32 | + printf("socket()\r\n"); | ||
33 | +#endif | ||
34 | + if ((protocol == Sn_MR_TCP) || (protocol == Sn_MR_UDP) || (protocol == Sn_MR_IPRAW) || (protocol == Sn_MR_MACRAW) || (protocol == Sn_MR_PPPOE)) | ||
35 | + { | ||
36 | + close(s); | ||
37 | + IINCHIP_WRITE(Sn_MR(s),protocol | flag); | ||
38 | + if (port != 0) { | ||
39 | + IINCHIP_WRITE(Sn_PORT0(s),(uint8)((port & 0xff00) >> 8)); | ||
40 | + IINCHIP_WRITE((Sn_PORT0(s) + 1),(uint8)(port & 0x00ff)); | ||
41 | + } else { | ||
42 | + local_port++; // if don't set the source port, set local_port number. | ||
43 | + IINCHIP_WRITE(Sn_PORT0(s),(uint8)((local_port & 0xff00) >> 8)); | ||
44 | + IINCHIP_WRITE((Sn_PORT0(s) + 1),(uint8)(local_port & 0x00ff)); | ||
45 | + } | ||
46 | + IINCHIP_WRITE(Sn_CR(s),Sn_CR_OPEN); // run sockinit Sn_CR | ||
47 | + | ||
48 | + /* +20071122[chungs]:wait to process the command... */ | ||
49 | + while( IINCHIP_READ(Sn_CR(s)) ) | ||
50 | + ; | ||
51 | + /* ------- */ | ||
52 | + ret = 1; | ||
53 | + } | ||
54 | + else | ||
55 | + { | ||
56 | + ret = 0; | ||
57 | + } | ||
58 | +#ifdef __DEF_IINCHIP_DBG__ | ||
59 | + printf("Sn_SR = %.2x , Protocol = %.2x\r\n", IINCHIP_READ(Sn_SR(s)), IINCHIP_READ(Sn_MR(s))); | ||
60 | +#endif | ||
61 | + return ret; | ||
62 | +} | ||
63 | + | ||
64 | + | ||
65 | +/** | ||
66 | +@brief This function close the socket and parameter is "s" which represent the socket number | ||
67 | +*/ | ||
68 | +void close(SOCKET s) | ||
69 | +{ | ||
70 | +#ifdef __DEF_IINCHIP_DBG__ | ||
71 | + printf("close()\r\n"); | ||
72 | +#endif | ||
73 | + | ||
74 | + IINCHIP_WRITE(Sn_CR(s),Sn_CR_CLOSE); | ||
75 | + | ||
76 | + /* +20071122[chungs]:wait to process the command... */ | ||
77 | + while( IINCHIP_READ(Sn_CR(s)) ) | ||
78 | + ; | ||
79 | + /* ------- */ | ||
80 | + | ||
81 | + /* +2008.01 [hwkim]: clear interrupt */ | ||
82 | + #ifdef __DEF_IINCHIP_INT__ | ||
83 | + /* m2008.01 [bj] : all clear */ | ||
84 | + putISR(s, 0x00); | ||
85 | + #else | ||
86 | + /* m2008.01 [bj] : all clear */ | ||
87 | + IINCHIP_WRITE(Sn_IR(s), 0xFF); | ||
88 | + #endif | ||
89 | +} | ||
90 | + | ||
91 | + | ||
92 | +/** | ||
93 | +@brief This function established the connection for the channel in passive (server) mode. This function waits for the request from the peer. | ||
94 | +@return 1 for success else 0. | ||
95 | +*/ | ||
96 | +uint8 listen( | ||
97 | + SOCKET s /**< the socket number */ | ||
98 | + ) | ||
99 | +{ | ||
100 | + uint8 ret; | ||
101 | +#ifdef __DEF_IINCHIP_DBG__ | ||
102 | + printf("listen()\r\n"); | ||
103 | +#endif | ||
104 | + if (IINCHIP_READ(Sn_SR(s)) == SOCK_INIT) | ||
105 | + { | ||
106 | + IINCHIP_WRITE(Sn_CR(s),Sn_CR_LISTEN); | ||
107 | + /* +20071122[chungs]:wait to process the command... */ | ||
108 | + while( IINCHIP_READ(Sn_CR(s)) ) | ||
109 | + ; | ||
110 | + /* ------- */ | ||
111 | + ret = 1; | ||
112 | + } | ||
113 | + else | ||
114 | + { | ||
115 | + ret = 0; | ||
116 | +#ifdef __DEF_IINCHIP_DBG__ | ||
117 | + printf("Fail[invalid ip,port]\r\n"); | ||
118 | +#endif | ||
119 | + } | ||
120 | + return ret; | ||
121 | +} | ||
122 | + | ||
123 | + | ||
124 | +/** | ||
125 | +@brief This function established the connection for the channel in Active (client) mode. | ||
126 | + This function waits for the until the connection is established. | ||
127 | + | ||
128 | +@return 1 for success else 0. | ||
129 | +*/ | ||
130 | +uint8 connect(SOCKET s, uint8 * addr, uint16 port) | ||
131 | +{ | ||
132 | + uint8 ret; | ||
133 | +#ifdef __DEF_IINCHIP_DBG__ | ||
134 | + printf("connect()\r\n"); | ||
135 | +#endif | ||
136 | + if | ||
137 | + ( | ||
138 | + ((addr[0] == 0xFF) && (addr[1] == 0xFF) && (addr[2] == 0xFF) && (addr[3] == 0xFF)) || | ||
139 | + ((addr[0] == 0x00) && (addr[1] == 0x00) && (addr[2] == 0x00) && (addr[3] == 0x00)) || | ||
140 | + (port == 0x00) | ||
141 | + ) | ||
142 | + { | ||
143 | + ret = 0; | ||
144 | +#ifdef __DEF_IINCHIP_DBG__ | ||
145 | + printf("Fail[invalid ip,port]\r\n"); | ||
146 | +#endif | ||
147 | + } | ||
148 | + else | ||
149 | + { | ||
150 | + ret = 1; | ||
151 | + // set destination IP | ||
152 | + IINCHIP_WRITE(Sn_DIPR0(s),addr[0]); | ||
153 | + IINCHIP_WRITE((Sn_DIPR0(s) + 1),addr[1]); | ||
154 | + IINCHIP_WRITE((Sn_DIPR0(s) + 2),addr[2]); | ||
155 | + IINCHIP_WRITE((Sn_DIPR0(s) + 3),addr[3]); | ||
156 | + IINCHIP_WRITE(Sn_DPORT0(s),(uint8)((port & 0xff00) >> 8)); | ||
157 | + IINCHIP_WRITE((Sn_DPORT0(s) + 1),(uint8)(port & 0x00ff)); | ||
158 | + IINCHIP_WRITE(Sn_CR(s),Sn_CR_CONNECT); | ||
159 | + /* m2008.01 [bj] : wait for completion */ | ||
160 | + while ( IINCHIP_READ(Sn_CR(s)) ) ; | ||
161 | + | ||
162 | + } | ||
163 | + | ||
164 | + return ret; | ||
165 | +} | ||
166 | + | ||
167 | + | ||
168 | + | ||
169 | +/** | ||
170 | +@brief This function used for disconnect the socket and parameter is "s" which represent the socket number | ||
171 | +@return 1 for success else 0. | ||
172 | +*/ | ||
173 | +void disconnect(SOCKET s) | ||
174 | +{ | ||
175 | +#ifdef __DEF_IINCHIP_DBG__ | ||
176 | + printf("disconnect()\r\n"); | ||
177 | +#endif | ||
178 | + IINCHIP_WRITE(Sn_CR(s),Sn_CR_DISCON); | ||
179 | + | ||
180 | + /* +20071122[chungs]:wait to process the command... */ | ||
181 | + while( IINCHIP_READ(Sn_CR(s)) ) | ||
182 | + ; | ||
183 | + /* ------- */ | ||
184 | +} | ||
185 | + | ||
186 | + | ||
187 | +/** | ||
188 | +@brief This function used to send the data in TCP mode | ||
189 | +@return 1 for success else 0. | ||
190 | +*/ | ||
191 | +uint16 send( | ||
192 | + SOCKET s, /**< the socket index */ | ||
193 | + const uint8 * buf, /**< a pointer to data */ | ||
194 | + uint16 len /**< the data size to be send */ | ||
195 | + ) | ||
196 | +{ | ||
197 | + uint8 status=0; | ||
198 | + uint16 ret=0; | ||
199 | + uint16 freesize=0; | ||
200 | +#ifdef __DEF_IINCHIP_DBG__ | ||
201 | + printf("send()\r\n"); | ||
202 | +#endif | ||
203 | + | ||
204 | + if (len > getIINCHIP_TxMAX(s)) ret = getIINCHIP_TxMAX(s); // check size not to exceed MAX size. | ||
205 | + else ret = len; | ||
206 | + | ||
207 | + // if freebuf is available, start. | ||
208 | + do | ||
209 | + { | ||
210 | + freesize = getSn_TX_FSR(s); | ||
211 | + status = IINCHIP_READ(Sn_SR(s)); | ||
212 | + if ((status != SOCK_ESTABLISHED) && (status != SOCK_CLOSE_WAIT)) | ||
213 | + { | ||
214 | + ret = 0; | ||
215 | + break; | ||
216 | + } | ||
217 | +#ifdef __DEF_IINCHIP_DBG__ | ||
218 | + printf("socket %d freesize(%d) empty or error\r\n", s, freesize); | ||
219 | +#endif | ||
220 | + } while (freesize < ret); | ||
221 | + | ||
222 | + // copy data | ||
223 | + send_data_processing(s, (uint8 *)buf, ret); | ||
224 | + IINCHIP_WRITE(Sn_CR(s),Sn_CR_SEND); | ||
225 | + | ||
226 | + /* +20071122[chungs]:wait to process the command... */ | ||
227 | + while( IINCHIP_READ(Sn_CR(s)) ) | ||
228 | + ; | ||
229 | + /* ------- */ | ||
230 | + | ||
231 | +/* +2008.01 bj */ | ||
232 | +#ifdef __DEF_IINCHIP_INT__ | ||
233 | + while ( (getISR(s) & Sn_IR_SEND_OK) != Sn_IR_SEND_OK ) | ||
234 | +#else | ||
235 | + while ( (IINCHIP_READ(Sn_IR(s)) & Sn_IR_SEND_OK) != Sn_IR_SEND_OK ) | ||
236 | +#endif | ||
237 | + { | ||
238 | + /* m2008.01 [bj] : reduce code */ | ||
239 | + if ( IINCHIP_READ(Sn_SR(s)) == SOCK_CLOSED ) | ||
240 | + { | ||
241 | +#ifdef __DEF_IINCHIP_DBG__ | ||
242 | + printf("SOCK_CLOSED.\r\n"); | ||
243 | +#endif | ||
244 | + close(s); | ||
245 | + return 0; | ||
246 | + } | ||
247 | + } | ||
248 | +/* +2008.01 bj */ | ||
249 | +#ifdef __DEF_IINCHIP_INT__ | ||
250 | + putISR(s, getISR(s) & (~Sn_IR_SEND_OK)); | ||
251 | +#else | ||
252 | + IINCHIP_WRITE(Sn_IR(s), Sn_IR_SEND_OK); | ||
253 | +#endif | ||
254 | + return ret; | ||
255 | +} | ||
256 | + | ||
257 | + | ||
258 | +/** | ||
259 | +@brief This function is an application I/F function which is used to receive the data in TCP mode. | ||
260 | + It continues to wait for data as much as the application wants to receive. | ||
261 | + | ||
262 | +@return received data size for success else -1. | ||
263 | +*/ | ||
264 | +uint16 recv( | ||
265 | + SOCKET s, /**< socket index */ | ||
266 | + uint8 * buf, /**< a pointer to copy the data to be received */ | ||
267 | + uint16 len /**< the data size to be read */ | ||
268 | + ) | ||
269 | +{ | ||
270 | + uint16 ret=0; | ||
271 | +#ifdef __DEF_IINCHIP_DBG__ | ||
272 | + printf("recv()\r\n"); | ||
273 | +#endif | ||
274 | + | ||
275 | + | ||
276 | + if ( len > 0 ) | ||
277 | + { | ||
278 | + recv_data_processing(s, buf, len); | ||
279 | + IINCHIP_WRITE(Sn_CR(s),Sn_CR_RECV); | ||
280 | + | ||
281 | + /* +20071122[chungs]:wait to process the command... */ | ||
282 | + while( IINCHIP_READ(Sn_CR(s)) ) | ||
283 | + ; | ||
284 | + /* ------- */ | ||
285 | + ret = len; | ||
286 | + } | ||
287 | + return ret; | ||
288 | +} | ||
289 | + | ||
290 | + | ||
291 | +/** | ||
292 | +@brief This function is an application I/F function which is used to send the data for other then TCP mode. | ||
293 | + Unlike TCP transmission, The peer's destination address and the port is needed. | ||
294 | + | ||
295 | +@return This function return send data size for success else -1. | ||
296 | +*/ | ||
297 | +uint16 sendto( | ||
298 | + SOCKET s, /**< socket index */ | ||
299 | + const uint8 * buf, /**< a pointer to the data */ | ||
300 | + uint16 len, /**< the data size to send */ | ||
301 | + uint8 * addr, /**< the peer's Destination IP address */ | ||
302 | + uint16 port /**< the peer's destination port number */ | ||
303 | + ) | ||
304 | +{ | ||
305 | +// uint8 status=0; | ||
306 | +// uint8 isr=0; | ||
307 | + uint16 ret=0; | ||
308 | + | ||
309 | +#ifdef __DEF_IINCHIP_DBG__ | ||
310 | + printf("sendto()\r\n"); | ||
311 | +#endif | ||
312 | + if (len > getIINCHIP_TxMAX(s)) ret = getIINCHIP_TxMAX(s); // check size not to exceed MAX size. | ||
313 | + else ret = len; | ||
314 | + | ||
315 | + if | ||
316 | + ( | ||
317 | + ((addr[0] == 0x00) && (addr[1] == 0x00) && (addr[2] == 0x00) && (addr[3] == 0x00)) || | ||
318 | + ((port == 0x00)) ||(ret == 0) | ||
319 | + ) | ||
320 | + { | ||
321 | + /* +2008.01 [bj] : added return value */ | ||
322 | + ret = 0; | ||
323 | +#ifdef __DEF_IINCHIP_DBG__ | ||
324 | + printf("%d Fail[%.2x.%.2x.%.2x.%.2x, %.d, %d]\r\n",s, addr[0], addr[1], addr[2], addr[3] , port, len); | ||
325 | + printf("Fail[invalid ip,port]\r\n"); | ||
326 | +#endif | ||
327 | + } | ||
328 | + else | ||
329 | + { | ||
330 | + IINCHIP_WRITE(Sn_DIPR0(s),addr[0]); | ||
331 | + IINCHIP_WRITE((Sn_DIPR0(s) + 1),addr[1]); | ||
332 | + IINCHIP_WRITE((Sn_DIPR0(s) + 2),addr[2]); | ||
333 | + IINCHIP_WRITE((Sn_DIPR0(s) + 3),addr[3]); | ||
334 | + IINCHIP_WRITE(Sn_DPORT0(s),(uint8)((port & 0xff00) >> 8)); | ||
335 | + IINCHIP_WRITE((Sn_DPORT0(s) + 1),(uint8)(port & 0x00ff)); | ||
336 | + | ||
337 | + // copy data | ||
338 | + send_data_processing(s, (uint8 *)buf, ret); | ||
339 | + IINCHIP_WRITE(Sn_CR(s),Sn_CR_SEND); | ||
340 | + | ||
341 | + /* +20071122[chungs]:wait to process the command... */ | ||
342 | + while( IINCHIP_READ(Sn_CR(s)) ) | ||
343 | + ; | ||
344 | + /* ------- */ | ||
345 | + | ||
346 | +/* +2008.01 bj */ | ||
347 | +#ifdef __DEF_IINCHIP_INT__ | ||
348 | + while ( (getISR(s) & Sn_IR_SEND_OK) != Sn_IR_SEND_OK ) | ||
349 | +#else | ||
350 | + while ( (IINCHIP_READ(Sn_IR(s)) & Sn_IR_SEND_OK) != Sn_IR_SEND_OK ) | ||
351 | +#endif | ||
352 | + { | ||
353 | +#ifdef __DEF_IINCHIP_INT__ | ||
354 | + if (getISR(s) & Sn_IR_TIMEOUT) | ||
355 | +#else | ||
356 | + if (IINCHIP_READ(Sn_IR(s)) & Sn_IR_TIMEOUT) | ||
357 | +#endif | ||
358 | + { | ||
359 | +#ifdef __DEF_IINCHIP_DBG__ | ||
360 | + printf("send fail.\r\n"); | ||
361 | +#endif | ||
362 | +/* +2008.01 [bj]: clear interrupt */ | ||
363 | +#ifdef __DEF_IINCHIP_INT__ | ||
364 | + putISR(s, getISR(s) & ~(Sn_IR_SEND_OK | Sn_IR_TIMEOUT)); /* clear SEND_OK & TIMEOUT */ | ||
365 | +#else | ||
366 | + IINCHIP_WRITE(Sn_IR(s), (Sn_IR_SEND_OK | Sn_IR_TIMEOUT)); /* clear SEND_OK & TIMEOUT */ | ||
367 | +#endif | ||
368 | + return 0; | ||
369 | + } | ||
370 | + } | ||
371 | + | ||
372 | +/* +2008.01 bj */ | ||
373 | +#ifdef __DEF_IINCHIP_INT__ | ||
374 | + putISR(s, getISR(s) & (~Sn_IR_SEND_OK)); | ||
375 | +#else | ||
376 | + IINCHIP_WRITE(Sn_IR(s), Sn_IR_SEND_OK); | ||
377 | +#endif | ||
378 | + | ||
379 | + } | ||
380 | + return ret; | ||
381 | +} | ||
382 | + | ||
383 | + | ||
384 | +/** | ||
385 | +@brief This function is an application I/F function which is used to receive the data in other then | ||
386 | + TCP mode. This function is used to receive UDP, IP_RAW and MAC_RAW mode, and handle the header as well. | ||
387 | + | ||
388 | +@return This function return received data size for success else -1. | ||
389 | +*/ | ||
390 | +uint16 recvfrom( | ||
391 | + SOCKET s, /**< the socket number */ | ||
392 | + uint8 * buf, /**< a pointer to copy the data to be received */ | ||
393 | + uint16 len, /**< the data size to read */ | ||
394 | + uint8 * addr, /**< a pointer to store the peer's IP address */ | ||
395 | + uint16 *port /**< a pointer to store the peer's port number. */ | ||
396 | + ) | ||
397 | +{ | ||
398 | + uint8 head[8]; | ||
399 | + uint16 data_len=0; | ||
400 | + uint16 ptr=0; | ||
401 | +#ifdef __DEF_IINCHIP_DBG__ | ||
402 | + printf("recvfrom()\r\n"); | ||
403 | +#endif | ||
404 | + | ||
405 | + if ( len > 0 ) | ||
406 | + { | ||
407 | + ptr = IINCHIP_READ(Sn_RX_RD0(s)); | ||
408 | + ptr = ((ptr & 0x00ff) << 8) + IINCHIP_READ(Sn_RX_RD0(s) + 1); | ||
409 | +#ifdef __DEF_IINCHIP_DBG__ | ||
410 | + printf("ISR_RX: rd_ptr : %.4x\r\n", ptr); | ||
411 | +#endif | ||
412 | + switch (IINCHIP_READ(Sn_MR(s)) & 0x07) | ||
413 | + { | ||
414 | + case Sn_MR_UDP : | ||
415 | + read_data(s, (uint8 *)ptr, head, 0x08); | ||
416 | + ptr += 8; | ||
417 | + // read peer's IP address, port number. | ||
418 | + addr[0] = head[0]; | ||
419 | + addr[1] = head[1]; | ||
420 | + addr[2] = head[2]; | ||
421 | + addr[3] = head[3]; | ||
422 | + *port = head[4]; | ||
423 | + *port = (*port << 8) + head[5]; | ||
424 | + data_len = head[6]; | ||
425 | + data_len = (data_len << 8) + head[7]; | ||
426 | + | ||
427 | +#ifdef __DEF_IINCHIP_DBG__ | ||
428 | + printf("UDP msg arrived\r\n"); | ||
429 | + printf("source Port : %d\r\n", *port); | ||
430 | + printf("source IP : %d.%d.%d.%d\r\n", addr[0], addr[1], addr[2], addr[3]); | ||
431 | +#endif | ||
432 | + | ||
433 | + read_data(s, (uint8 *)ptr, buf, data_len); // data copy. | ||
434 | + ptr += data_len; | ||
435 | + | ||
436 | + IINCHIP_WRITE(Sn_RX_RD0(s),(uint8)((ptr & 0xff00) >> 8)); | ||
437 | + IINCHIP_WRITE((Sn_RX_RD0(s) + 1),(uint8)(ptr & 0x00ff)); | ||
438 | + break; | ||
439 | + | ||
440 | + case Sn_MR_IPRAW : | ||
441 | + read_data(s, (uint8 *)ptr, head, 0x06); | ||
442 | + ptr += 6; | ||
443 | + | ||
444 | + addr[0] = head[0]; | ||
445 | + addr[1] = head[1]; | ||
446 | + addr[2] = head[2]; | ||
447 | + addr[3] = head[3]; | ||
448 | + data_len = head[4]; | ||
449 | + data_len = (data_len << 8) + head[5]; | ||
450 | + | ||
451 | +#ifdef __DEF_IINCHIP_DBG__ | ||
452 | + printf("IP RAW msg arrived\r\n"); | ||
453 | + printf("source IP : %d.%d.%d.%d\r\n", addr[0], addr[1], addr[2], addr[3]); | ||
454 | +#endif | ||
455 | + read_data(s, (uint8 *)ptr, buf, data_len); // data copy. | ||
456 | + ptr += data_len; | ||
457 | + | ||
458 | + IINCHIP_WRITE(Sn_RX_RD0(s),(uint8)((ptr & 0xff00) >> 8)); | ||
459 | + IINCHIP_WRITE((Sn_RX_RD0(s) + 1),(uint8)(ptr & 0x00ff)); | ||
460 | + break; | ||
461 | + case Sn_MR_MACRAW : | ||
462 | + read_data(s,(uint8*)ptr,head,2); | ||
463 | + ptr+=2; | ||
464 | + data_len = head[0]; | ||
465 | + data_len = (data_len<<8) + head[1] - 2; | ||
466 | + | ||
467 | + read_data(s,(uint8*) ptr,buf,data_len); | ||
468 | + ptr += data_len; | ||
469 | + IINCHIP_WRITE(Sn_RX_RD0(s),(uint8)((ptr & 0xff00) >> 8)); | ||
470 | + IINCHIP_WRITE((Sn_RX_RD0(s) + 1),(uint8)(ptr & 0x00ff)); | ||
471 | + | ||
472 | +#ifdef __DEF_IINCHIP_DGB__ | ||
473 | + printf("MAC RAW msg arrived\r\n"); | ||
474 | + printf("dest mac=%.2X.%.2X.%.2X.%.2X.%.2X.%.2X\r\n",buf[0],buf[1],buf[2],buf[3],buf[4],buf[5]); | ||
475 | + printf("src mac=%.2X.%.2X.%.2X.%.2X.%.2X.%.2X\r\n",buf[6],buf[7],buf[8],buf[9],buf[10],buf[11]); | ||
476 | + printf("type =%.2X%.2X\r\n",buf[12],buf[13]); | ||
477 | +#endif | ||
478 | + break; | ||
479 | + | ||
480 | + default : | ||
481 | + break; | ||
482 | + } | ||
483 | + IINCHIP_WRITE(Sn_CR(s),Sn_CR_RECV); | ||
484 | + | ||
485 | + /* +20071122[chungs]:wait to process the command... */ | ||
486 | + while( IINCHIP_READ(Sn_CR(s)) ) | ||
487 | + ; | ||
488 | + /* ------- */ | ||
489 | + } | ||
490 | +#ifdef __DEF_IINCHIP_DBG__ | ||
491 | + printf("recvfrom() end ..\r\n"); | ||
492 | +#endif | ||
493 | + return data_len; | ||
494 | +} | ||
495 | + | ||
496 | + | ||
497 | +uint16 igmpsend(SOCKET s, const uint8 * buf, uint16 len) | ||
498 | +{ | ||
499 | +// uint8 status=0; | ||
500 | +// uint8 isr=0; | ||
501 | + uint16 ret=0; | ||
502 | + | ||
503 | +#ifdef __DEF_IINCHIP_DBG__ | ||
504 | + printf("igmpsend()\r\n"); | ||
505 | +#endif | ||
506 | + if (len > getIINCHIP_TxMAX(s)) ret = getIINCHIP_TxMAX(s); // check size not to exceed MAX size. | ||
507 | + else ret = len; | ||
508 | + | ||
509 | + if (ret == 0) | ||
510 | + { | ||
511 | + ; | ||
512 | +#ifdef __DEF_IINCHIP_DBG__ | ||
513 | + printf("%d Fail[%d]\r\n",len,ret); | ||
514 | +#endif | ||
515 | + } | ||
516 | + else | ||
517 | + { | ||
518 | + // copy data | ||
519 | + send_data_processing(s, (uint8 *)buf, ret); | ||
520 | + IINCHIP_WRITE(Sn_CR(s),Sn_CR_SEND); | ||
521 | +/* +2008.01 bj */ | ||
522 | + while( IINCHIP_READ(Sn_CR(s)) ) | ||
523 | + ; | ||
524 | +/* ------- */ | ||
525 | + | ||
526 | +/* +2008.01 bj */ | ||
527 | +#ifdef __DEF_IINCHIP_INT__ | ||
528 | + while ( (getISR(s) & Sn_IR_SEND_OK) != Sn_IR_SEND_OK ) | ||
529 | +#else | ||
530 | + while ( (IINCHIP_READ(Sn_IR(s)) & Sn_IR_SEND_OK) != Sn_IR_SEND_OK ) | ||
531 | +#endif | ||
532 | + { | ||
533 | + IINCHIP_READ(Sn_SR(s)); | ||
534 | +#ifdef __DEF_IINCHIP_INT__ | ||
535 | + if (getISR(s) & Sn_IR_TIMEOUT) | ||
536 | +#else | ||
537 | + if (IINCHIP_READ(Sn_IR(s)) & Sn_IR_TIMEOUT) | ||
538 | +#endif | ||
539 | + { | ||
540 | +#ifdef __DEF_IINCHIP_DBG__ | ||
541 | + printf("igmpsend fail.\r\n"); | ||
542 | +#endif | ||
543 | + /* in case of igmp, if send fails, then socket closed */ | ||
544 | + /* if you want change, remove this code. */ | ||
545 | + close(s); | ||
546 | + /* ----- */ | ||
547 | + | ||
548 | + return 0; | ||
549 | + } | ||
550 | + } | ||
551 | + | ||
552 | +/* +2008.01 bj */ | ||
553 | +#ifdef __DEF_IINCHIP_INT__ | ||
554 | + putISR(s, getISR(s) & (~Sn_IR_SEND_OK)); | ||
555 | +#else | ||
556 | + IINCHIP_WRITE(Sn_IR(s), Sn_IR_SEND_OK); | ||
557 | +#endif | ||
558 | + } | ||
559 | + return ret; | ||
560 | +} | ||
561 | + |
@@ -0,0 +1,23 @@ | @@ -0,0 +1,23 @@ | ||
1 | +/* | ||
2 | +* | ||
3 | +@file socket.h | ||
4 | +@brief define function of socket API | ||
5 | +* | ||
6 | +*/ | ||
7 | + | ||
8 | +#ifndef _SOCKET_H_ | ||
9 | +#define _SOCKET_H_ | ||
10 | + | ||
11 | +extern uint8 socket(SOCKET s, uint8 protocol, uint16 port, uint8 flag); // Opens a socket(TCP or UDP or IP_RAW mode) | ||
12 | +extern void close(SOCKET s); // Close socket | ||
13 | +extern uint8 connect(SOCKET s, uint8 * addr, uint16 port); // Establish TCP connection (Active connection) | ||
14 | +extern void disconnect(SOCKET s); // disconnect the connection | ||
15 | +extern uint8 listen(SOCKET s); // Establish TCP connection (Passive connection) | ||
16 | +extern uint16 send(SOCKET s, const uint8 * buf, uint16 len); // Send data (TCP) | ||
17 | +extern uint16 recv(SOCKET s, uint8 * buf, uint16 len); // Receive data (TCP) | ||
18 | +extern uint16 sendto(SOCKET s, const uint8 * buf, uint16 len, uint8 * addr, uint16 port); // Send data (UDP/IP RAW) | ||
19 | +extern uint16 recvfrom(SOCKET s, uint8 * buf, uint16 len, uint8 * addr, uint16 *port); // Receive data (UDP/IP RAW) | ||
20 | + | ||
21 | +extern uint16 igmpsend(SOCKET s, const uint8 * buf, uint16 len); | ||
22 | +#endif | ||
23 | +/* _SOCKET_H_ */ |
@@ -0,0 +1,58 @@ | @@ -0,0 +1,58 @@ | ||
1 | +//----------------------------------------------------------------------------- | ||
2 | +//AVR Mega168 SPI HAL | ||
3 | +#define BIT0 0x01 | ||
4 | +#define BIT1 0x02 | ||
5 | +#define BIT2 0x04 | ||
6 | +#define BIT3 0x08 | ||
7 | +#define BIT4 0x10 | ||
8 | +#define BIT5 0x20 | ||
9 | +#define BIT6 0x40 | ||
10 | +#define BIT7 0x80 | ||
11 | + | ||
12 | +#define SPI0_SS_BIT BIT2 | ||
13 | +#define SPI0_SS_DDR DDRB | ||
14 | +#define SPI0_SS_PORT PORTB | ||
15 | + | ||
16 | +#define SPI0_SCLK_BIT BIT5 | ||
17 | +#define SPI0_SCLK_DDR DDRB | ||
18 | +#define SPI0_SCLK_PORT PORTB | ||
19 | + | ||
20 | +#define SPI0_MOSI_BIT BIT3 | ||
21 | +#define SPI0_MOSI_DDR DDRB | ||
22 | +#define SPI0_MOSI_PORT PORTB | ||
23 | + | ||
24 | +#define SPI0_MISO_BIT BIT4 | ||
25 | +#define SPI0_MISO_DDR DDRB | ||
26 | +#define SPI0_MISO_PORT PORTB | ||
27 | + | ||
28 | + | ||
29 | +#define SPI0_WaitForReceive() | ||
30 | +#define SPI0_RxData() (SPDR) | ||
31 | + | ||
32 | +#define SPI0_TxData(Data) (SPDR = Data) | ||
33 | +#define SPI0_WaitForSend() while( (SPSR & 0x80)==0x00 ) | ||
34 | + | ||
35 | +#define SPI0_SendByte(Data) SPI0_TxData(Data);SPI0_WaitForSend() | ||
36 | +#define SPI0_RecvBute() SPI0_RxData() | ||
37 | + | ||
38 | +// PB4(MISO), PB3(MOSI), PB5(SCK), PB2(/SS) // CS=1, waiting for SPI start // SPI mode 0, 4MHz | ||
39 | +#define SPI0_Init() DDRB |= SPI0_SS_BIT|SPI0_SCLK_BIT|SPI0_MOSI_BIT;\ | ||
40 | + PORTB |= SPI0_SS_BIT; PORTB &= ~(SPI0_SCLK_BIT|SPI0_MOSI_BIT);\ | ||
41 | + SPCR = 0x50 | ||
42 | +//----------------------------------------------------------------------------- | ||
43 | + | ||
44 | +//----------------------------------------------------------------------------- | ||
45 | +//IInChip SPI HAL | ||
46 | +#define IINCHIP_SpiInit SPI0_Init | ||
47 | +#define IINCHIP_SpiSendData SPI0_SendByte | ||
48 | +#define IINCHIP_SpiRecvData SPI0_RxData | ||
49 | + | ||
50 | + | ||
51 | +#define IINCHIP_CS_BIT BIT2 | ||
52 | +#define IINCHIP_CS_DDR DDRB | ||
53 | +#define IINCHIP_CS_PORT PORTB | ||
54 | + | ||
55 | +#define IINCHIP_CSInit() (IINCHIP_CS_DDR |= IINCHIP_CS_BIT) | ||
56 | +#define IINCHIP_CSon() (IINCHIP_CS_PORT |= IINCHIP_CS_BIT) | ||
57 | +#define IINCHIP_CSoff() (IINCHIP_CS_PORT &= ~IINCHIP_CS_BIT) | ||
58 | +//----------------------------------------------------------------------------- |
@@ -0,0 +1,18 @@ | @@ -0,0 +1,18 @@ | ||
1 | +#include <avr/io.h> | ||
2 | +#include <util/delay.h> | ||
3 | +#include <stdio.h> | ||
4 | + | ||
5 | +#include "serial.h" | ||
6 | +#include "ethernet.h" | ||
7 | +#include "w5100.h" | ||
8 | +#include "socket.h" | ||
9 | + | ||
10 | +#define MAC_SIZE 6 | ||
11 | +#define IPV4_SIZE 4 | ||
12 | + | ||
13 | +int main(void) | ||
14 | +{ | ||
15 | +init_printf(); | ||
16 | +// Your code here !! | ||
17 | +return 0; | ||
18 | +} |
@@ -0,0 +1,1300 @@ | @@ -0,0 +1,1300 @@ | ||
1 | +/* | ||
2 | + * (c)COPYRIGHT | ||
3 | + * ALL RIGHT RESERVED | ||
4 | + * | ||
5 | + * FileName : w5100.c | ||
6 | + * Revision History : | ||
7 | + * ---------- ------- ------------------------------------------------ | ||
8 | + * Date version Description | ||
9 | + * ---------- ------- ------------------------------------------------ | ||
10 | + * 01/25/2007 1.1 Bug is Fixed in the Indirect Mode | ||
11 | + * : Memory mapping error | ||
12 | + * ---------- ------- ------------------------------------------------ | ||
13 | + * 01/08/2008 1.2 Modification of Socket Command Part | ||
14 | + * : Check if the appropriately performed after writing Sn_CR | ||
15 | + * | ||
16 | + * Modification of SPI Part | ||
17 | + * : SPI code changed by adding 'spi.h'. | ||
18 | + * : Change control type for SPI port from byte to bit. | ||
19 | + * ---------- ------- ------------------------------------------------ | ||
20 | + * 01/15/2008 1.3 Bug is Fixed in the pppinit() fuction. | ||
21 | + * : do not clear interrupt value, so fixed. | ||
22 | + * | ||
23 | + * Modification of ISR | ||
24 | + * : Do not exit ISR, if there is interrupt. | ||
25 | + * ---------- ------- ------------------------------------------------ | ||
26 | + * 03/21/2008 1.4 Modification of SetMR() function | ||
27 | + * : Use IINCHIP_WRITE() function in Direct or SPI mode. | ||
28 | + * ---------- ------- ------------------------------------------------ | ||
29 | + */ | ||
30 | +#include <stdio.h> | ||
31 | +#include <string.h> | ||
32 | + | ||
33 | +#include <avr/interrupt.h> | ||
34 | +// #include <avr/io.h> | ||
35 | + | ||
36 | +#include "ethernet.h" | ||
37 | +#include "socket.h" | ||
38 | +#include "w5100.h" | ||
39 | + | ||
40 | +#ifdef __DEF_IINCHIP_PPP__ | ||
41 | + #include "md5.h" | ||
42 | +#endif | ||
43 | + | ||
44 | + | ||
45 | +#if (__DEF_IINCHIP_BUS__ == __DEF_IINCHIP_SPI_MODE__) | ||
46 | +#include "spi.h" //+2007113[jhpark] | ||
47 | +#endif | ||
48 | + | ||
49 | +static uint8 I_STATUS[MAX_SOCK_NUM]; | ||
50 | +static uint16 SMASK[MAX_SOCK_NUM]; /**< Variable for Tx buffer MASK in each channel */ | ||
51 | +static uint16 RMASK[MAX_SOCK_NUM]; /**< Variable for Rx buffer MASK in each channel */ | ||
52 | +static uint16 SSIZE[MAX_SOCK_NUM]; /**< Max Tx buffer size by each channel */ | ||
53 | +static uint16 RSIZE[MAX_SOCK_NUM]; /**< Max Rx buffer size by each channel */ | ||
54 | +static uint16 SBUFBASEADDRESS[MAX_SOCK_NUM]; /**< Tx buffer base address by each channel */ | ||
55 | +static uint16 RBUFBASEADDRESS[MAX_SOCK_NUM]; /**< Rx buffer base address by each channel */ | ||
56 | + | ||
57 | +uint8 getISR(uint8 s) | ||
58 | +{ | ||
59 | + return I_STATUS[s]; | ||
60 | +} | ||
61 | + | ||
62 | +void putISR(uint8 s, uint8 val) | ||
63 | +{ | ||
64 | + I_STATUS[s] = val; | ||
65 | +} | ||
66 | + | ||
67 | +uint16 getIINCHIP_RxMAX(uint8 s) | ||
68 | +{ | ||
69 | + return RSIZE[s]; | ||
70 | +} | ||
71 | +uint16 getIINCHIP_TxMAX(uint8 s) | ||
72 | +{ | ||
73 | + return SSIZE[s]; | ||
74 | +} | ||
75 | +uint16 getIINCHIP_RxMASK(uint8 s) | ||
76 | +{ | ||
77 | + return RMASK[s]; | ||
78 | +} | ||
79 | +uint16 getIINCHIP_TxMASK(uint8 s) | ||
80 | +{ | ||
81 | + return SMASK[s]; | ||
82 | +} | ||
83 | +uint16 getIINCHIP_RxBASE(uint8 s) | ||
84 | +{ | ||
85 | + return RBUFBASEADDRESS[s]; | ||
86 | +} | ||
87 | +uint16 getIINCHIP_TxBASE(uint8 s) | ||
88 | +{ | ||
89 | + return SBUFBASEADDRESS[s]; | ||
90 | +} | ||
91 | + | ||
92 | + /** | ||
93 | +@brief This function writes the data into W5100 registers. | ||
94 | +*/ | ||
95 | +uint8 IINCHIP_WRITE(uint16 addr,uint8 data) | ||
96 | +{ | ||
97 | +// DIRECT MODE I/F | ||
98 | +#if (__DEF_IINCHIP_BUS__ == __DEF_IINCHIP_DIRECT_MODE__) | ||
99 | + IINCHIP_ISR_DISABLE(); | ||
100 | + *((vuint8*)(addr)) = data; | ||
101 | + IINCHIP_ISR_ENABLE(); | ||
102 | +#elif(__DEF_IINCHIP_BUS__ == __DEF_IINCHIP_INDIRECT_MODE__) /* INDIRECT MODE I/F */ | ||
103 | + IINCHIP_ISR_DISABLE(); | ||
104 | + *((vuint8*)IDM_AR0) = (uint8)((addr & 0xFF00) >> 8); | ||
105 | + *((vuint8*)IDM_AR1) = (uint8)(addr & 0x00FF); | ||
106 | + *((vuint8*)IDM_DR) = data; | ||
107 | + IINCHIP_ISR_ENABLE(); | ||
108 | +#elif (__DEF_IINCHIP_BUS__ == __DEF_IINCHIP_SPI_MODE__) | ||
109 | + IINCHIP_ISR_DISABLE(); | ||
110 | + IINCHIP_SpiInit(); | ||
111 | + | ||
112 | + //SPI MODE I/F | ||
113 | + IINCHIP_CSoff(); // CS=0, SPI start | ||
114 | + | ||
115 | + IINCHIP_SpiSendData(0xF0); | ||
116 | + IINCHIP_SpiSendData((addr & 0xFF00) >> 8); | ||
117 | + IINCHIP_SpiSendData(addr & 0x00FF); | ||
118 | + IINCHIP_SpiSendData(data); | ||
119 | + | ||
120 | + IINCHIP_CSon(); | ||
121 | + | ||
122 | + IINCHIP_ISR_ENABLE(); | ||
123 | +#else | ||
124 | + #error "unknown bus type" | ||
125 | +#endif | ||
126 | + return 1; | ||
127 | +} | ||
128 | + | ||
129 | + | ||
130 | +/** | ||
131 | +@brief This function reads the value from W5100 registers. | ||
132 | +*/ | ||
133 | +uint8 IINCHIP_READ(uint16 addr) | ||
134 | +{ | ||
135 | + uint8 data; | ||
136 | + | ||
137 | +// DIRECT MODE I/F | ||
138 | + | ||
139 | +#if (__DEF_IINCHIP_BUS__ == __DEF_IINCHIP_DIRECT_MODE__) | ||
140 | + IINCHIP_ISR_DISABLE(); | ||
141 | + data = *((vuint8*)(addr)); | ||
142 | + IINCHIP_ISR_ENABLE(); | ||
143 | +#elif(__DEF_IINCHIP_BUS__ == __DEF_IINCHIP_INDIRECT_MODE__) | ||
144 | + IINCHIP_ISR_DISABLE(); | ||
145 | + *((vuint8*)IDM_AR0) = (uint8)((addr & 0xFF00) >> 8); | ||
146 | + *((vuint8*)IDM_AR1) = (uint8)(addr & 0x00FF); | ||
147 | + data = *((vuint8*)IDM_DR); | ||
148 | + IINCHIP_ISR_ENABLE(); | ||
149 | + | ||
150 | +#elif (__DEF_IINCHIP_BUS__ == __DEF_IINCHIP_SPI_MODE__) | ||
151 | + IINCHIP_ISR_DISABLE(); | ||
152 | + IINCHIP_SpiInit(); | ||
153 | + IINCHIP_CSoff(); // CS=0, SPI start | ||
154 | + | ||
155 | + IINCHIP_SpiSendData(0x0F); | ||
156 | + IINCHIP_SpiSendData((addr & 0xFF00) >> 8); | ||
157 | + IINCHIP_SpiSendData(addr & 0x00FF); | ||
158 | + | ||
159 | + | ||
160 | + IINCHIP_SpiSendData(0); | ||
161 | + data = IINCHIP_SpiRecvData(); | ||
162 | + | ||
163 | + IINCHIP_CSon(); // SPI end | ||
164 | + IINCHIP_ISR_ENABLE(); | ||
165 | +#else | ||
166 | + #error "unknown bus type" | ||
167 | +#endif | ||
168 | + return data; | ||
169 | +} | ||
170 | + | ||
171 | + | ||
172 | +/** | ||
173 | +@brief This function writes into W5100 memory(Buffer) | ||
174 | +*/ | ||
175 | +uint16 wiz_write_buf(uint16 addr,uint8* buf,uint16 len) | ||
176 | +{ | ||
177 | +#if (__DEF_IINCHIP_BUS__ == __DEF_IINCHIP_DIRECT_MODE__) | ||
178 | + IINCHIP_ISR_DISABLE(); | ||
179 | + memcpy((uint8 *)addr, buf, len); | ||
180 | + IINCHIP_ISR_ENABLE(); | ||
181 | +#elif (__DEF_IINCHIP_BUS__ == __DEF_IINCHIP_INDIRECT_MODE__) | ||
182 | + uint16 idx = 0; | ||
183 | + IINCHIP_ISR_DISABLE(); | ||
184 | + *((vuint8*)IDM_AR0) = (uint8)((addr & 0xFF00) >> 8); | ||
185 | + *((vuint8*)IDM_AR1) = (uint8)(addr & 0x00FF); | ||
186 | + for (idx = 0; idx < len ; idx++) *((vuint8*)IDM_DR) = buf[idx]; | ||
187 | + IINCHIP_ISR_ENABLE(); | ||
188 | +#elif (__DEF_IINCHIP_BUS__ == __DEF_IINCHIP_SPI_MODE__) | ||
189 | + uint16 idx = 0; | ||
190 | + | ||
191 | + IINCHIP_ISR_DISABLE(); | ||
192 | + IINCHIP_SpiInit(); | ||
193 | + | ||
194 | + //SPI MODE I/F | ||
195 | + for(idx=0;idx<len;idx++) | ||
196 | + { | ||
197 | + IINCHIP_CSoff(); // CS=0, SPI start | ||
198 | + | ||
199 | + IINCHIP_SpiSendData(0xF0); | ||
200 | + IINCHIP_SpiSendData(((addr+idx) & 0xFF00) >> 8); | ||
201 | + IINCHIP_SpiSendData((addr+idx) & 0x00FF); | ||
202 | + IINCHIP_SpiSendData(buf[idx]); | ||
203 | + | ||
204 | + IINCHIP_CSon(); // CS=0, SPI end | ||
205 | + } | ||
206 | + | ||
207 | + IINCHIP_ISR_ENABLE(); | ||
208 | +#else | ||
209 | + #error "unknown bus type" | ||
210 | +#endif | ||
211 | + return len; | ||
212 | +} | ||
213 | + | ||
214 | + | ||
215 | +/** | ||
216 | +@brief This function reads into W5100 memory(Buffer) | ||
217 | +*/ | ||
218 | +uint16 wiz_read_buf(uint16 addr, uint8* buf,uint16 len) | ||
219 | +{ | ||
220 | +#if (__DEF_IINCHIP_BUS__ == __DEF_IINCHIP_DIRECT_MODE__) | ||
221 | + IINCHIP_ISR_DISABLE(); | ||
222 | + memcpy(buf, (uint8 *)addr, len); | ||
223 | + IINCHIP_ISR_ENABLE(); | ||
224 | +#elif(__DEF_IINCHIP_BUS__ == __DEF_IINCHIP_INDIRECT_MODE__) | ||
225 | + uint16 idx = 0; | ||
226 | + IINCHIP_ISR_DISABLE(); | ||
227 | + *((vuint8*)IDM_AR0) = (uint8)((addr & 0xFF00) >> 8); | ||
228 | + *((vuint8*)IDM_AR1) = (uint8)(addr & 0x00FF); | ||
229 | + for (idx = 0; idx < len ; idx++) buf[idx] = *((vuint8*)IDM_DR); | ||
230 | + IINCHIP_ISR_ENABLE(); | ||
231 | +#elif (__DEF_IINCHIP_BUS__ == __DEF_IINCHIP_SPI_MODE__) | ||
232 | + uint16 idx = 0; | ||
233 | + IINCHIP_ISR_DISABLE(); | ||
234 | + | ||
235 | + IINCHIP_SpiInit(); | ||
236 | + | ||
237 | + for (idx=0; idx<len; idx++) | ||
238 | + { | ||
239 | + IINCHIP_CSoff(); // CS=0, SPI start | ||
240 | + | ||
241 | + IINCHIP_SpiSendData(0x0F); | ||
242 | + IINCHIP_SpiSendData(((addr+idx) & 0xFF00) >> 8); | ||
243 | + IINCHIP_SpiSendData((addr+idx) & 0x00FF); | ||
244 | + | ||
245 | + | ||
246 | + IINCHIP_SpiSendData(0); | ||
247 | + buf[idx] = IINCHIP_SpiRecvData(); | ||
248 | + | ||
249 | + IINCHIP_CSon(); // CS=0, SPI end | ||
250 | + } | ||
251 | + | ||
252 | + IINCHIP_ISR_ENABLE(); | ||
253 | +#else | ||
254 | + #error "unknown bus type" | ||
255 | +#endif | ||
256 | + return len; | ||
257 | +} | ||
258 | + | ||
259 | + | ||
260 | +/** | ||
261 | +@brief Socket interrupt routine | ||
262 | +*/ | ||
263 | +#ifdef __DEF_IINCHIP_INT__ | ||
264 | +ISR(INT4_vect) | ||
265 | +{ | ||
266 | + uint8 int_val; | ||
267 | + IINCHIP_ISR_DISABLE(); | ||
268 | + int_val = IINCHIP_READ(IR); | ||
269 | + | ||
270 | + /* +200801[bj] process all of interupt */ | ||
271 | + do { | ||
272 | + /*---*/ | ||
273 | + | ||
274 | + if (int_val & IR_CONFLICT) | ||
275 | + { | ||
276 | + printf("IP conflict : %.2x\r\n", int_val); | ||
277 | + } | ||
278 | + if (int_val & IR_UNREACH) | ||
279 | + { | ||
280 | + printf("INT Port Unreachable : %.2x\r\n", int_val); | ||
281 | + printf("UIPR0 : %d.%d.%d.%d\r\n", IINCHIP_READ(UIPR0), IINCHIP_READ(UIPR0+1), IINCHIP_READ(UIPR0+2), IINCHIP_READ(UIPR0+3)); | ||
282 | + printf("UPORT0 : %.2x %.2x\r\n", IINCHIP_READ(UPORT0), IINCHIP_READ(UPORT0+1)); | ||
283 | + } | ||
284 | + | ||
285 | + /* +200801[bj] interrupt clear */ | ||
286 | + IINCHIP_WRITE(IR, 0xf0); | ||
287 | + /*---*/ | ||
288 | + | ||
289 | + if (int_val & IR_SOCK(0)) | ||
290 | + { | ||
291 | + /* +-200801[bj] save interrupt value*/ | ||
292 | + I_STATUS[0] |= IINCHIP_READ(Sn_IR(0)); // can be come to over two times. | ||
293 | + IINCHIP_WRITE(Sn_IR(0), I_STATUS[0]); | ||
294 | + /*---*/ | ||
295 | + } | ||
296 | + if (int_val & IR_SOCK(1)) | ||
297 | + { | ||
298 | + /* +-200801[bj] save interrupt value*/ | ||
299 | + I_STATUS[1] |= IINCHIP_READ(Sn_IR(1)); | ||
300 | + IINCHIP_WRITE(Sn_IR(1), I_STATUS[1]); | ||
301 | + /*---*/ | ||
302 | + } | ||
303 | + if (int_val & IR_SOCK(2)) | ||
304 | + { | ||
305 | + /* +-200801[bj] save interrupt value*/ | ||
306 | + I_STATUS[2] |= IINCHIP_READ(Sn_IR(2)); | ||
307 | + IINCHIP_WRITE(Sn_IR(2), I_STATUS[2]); | ||
308 | + /*---*/ | ||
309 | + } | ||
310 | + if (int_val & IR_SOCK(3)) | ||
311 | + { | ||
312 | + /* +-200801[bj] save interrupt value*/ | ||
313 | + I_STATUS[3] |= IINCHIP_READ(Sn_IR(3)); | ||
314 | + IINCHIP_WRITE(Sn_IR(3), I_STATUS[3]); | ||
315 | + /*---*/ | ||
316 | + } | ||
317 | + | ||
318 | + /* +-200801[bj] re-read interrupt value*/ | ||
319 | + int_val = IINCHIP_READ(IR); | ||
320 | + | ||
321 | + /* +200801[bj] if exist, contiue to process */ | ||
322 | + } while (int_val != 0x00); | ||
323 | + /*---*/ | ||
324 | + | ||
325 | + IINCHIP_ISR_ENABLE(); | ||
326 | +} | ||
327 | +#endif | ||
328 | + | ||
329 | +/** | ||
330 | +@brief This function is for resetting of the iinchip. Initializes the iinchip to work in whether DIRECT or INDIRECT mode | ||
331 | +*/ | ||
332 | +void iinchip_init(void) | ||
333 | +{ | ||
334 | + setMR( MR_RST ); | ||
335 | +#if (__DEF_IINCHIP_BUS__ == __DEF_IINCHIP_INDIRECT_MODE__) | ||
336 | + setMR( MR_IND | MR_AI ); | ||
337 | +#ifdef __DEF_IINCHIP_DBG__ | ||
338 | + printf("MR value is %d \r\n",IINCHIP_READ(MR)); | ||
339 | +#endif | ||
340 | +#endif | ||
341 | +} | ||
342 | + | ||
343 | + | ||
344 | +/** | ||
345 | +@brief This function set the transmit & receive buffer size as per the channels is used | ||
346 | + | ||
347 | +Note for TMSR and RMSR bits are as follows\n | ||
348 | +bit 1-0 : memory size of channel #0 \n | ||
349 | +bit 3-2 : memory size of channel #1 \n | ||
350 | +bit 5-4 : memory size of channel #2 \n | ||
351 | +bit 7-6 : memory size of channel #3 \n\n | ||
352 | +Maximum memory size for Tx, Rx in the W5100 is 8K Bytes,\n | ||
353 | +In the range of 8KBytes, the memory size could be allocated dynamically by each channel.\n | ||
354 | +Be attentive to sum of memory size shouldn't exceed 8Kbytes\n | ||
355 | +and to data transmission and receiption from non-allocated channel may cause some problems.\n | ||
356 | +If the 8KBytes memory is already assigned to centain channel, \n | ||
357 | +other 3 channels couldn't be used, for there's no available memory.\n | ||
358 | +If two 4KBytes memory are assigned to two each channels, \n | ||
359 | +other 2 channels couldn't be used, for there's no available memory.\n | ||
360 | +*/ | ||
361 | +void sysinit( | ||
362 | + uint8 tx_size, /**< tx_size Tx memory size (00 - 1KByte, 01- 2KBtye, 10 - 4KByte, 11 - 8KByte) */ | ||
363 | + uint8 rx_size /**< rx_size Rx memory size (00 - 1KByte, 01- 2KBtye, 10 - 4KByte, 11 - 8KByte) */ | ||
364 | + ) | ||
365 | +{ | ||
366 | + int16 i; | ||
367 | + int16 ssum,rsum; | ||
368 | + | ||
369 | +#ifdef __DEF_IINCHIP_DBG__ | ||
370 | + printf("sysinit()\r\n"); | ||
371 | +#endif | ||
372 | + | ||
373 | + ssum = 0; | ||
374 | + rsum = 0; | ||
375 | + | ||
376 | + IINCHIP_WRITE(TMSR,tx_size); /* Set Tx memory size for each channel */ | ||
377 | + IINCHIP_WRITE(RMSR,rx_size); /* Set Rx memory size for each channel */ | ||
378 | + | ||
379 | + SBUFBASEADDRESS[0] = (uint16)(__DEF_IINCHIP_MAP_TXBUF__); /* Set base address of Tx memory for channel #0 */ | ||
380 | + RBUFBASEADDRESS[0] = (uint16)(__DEF_IINCHIP_MAP_RXBUF__); /* Set base address of Rx memory for channel #0 */ | ||
381 | + | ||
382 | +#ifdef __DEF_IINCHIP_DBG__ | ||
383 | + printf("Channel : SEND MEM SIZE : RECV MEM SIZE\r\n"); | ||
384 | +#endif | ||
385 | + | ||
386 | + for (i = 0 ; i < MAX_SOCK_NUM; i++) // Set the size, masking and base address of Tx & Rx memory by each channel | ||
387 | + { | ||
388 | + SSIZE[i] = (int16)(0); | ||
389 | + RSIZE[i] = (int16)(0); | ||
390 | + if (ssum < 8192) | ||
391 | + { | ||
392 | + switch((tx_size >> i*2) & 0x03) // Set Tx memory size | ||
393 | + { | ||
394 | + case 0: | ||
395 | + SSIZE[i] = (int16)(1024); | ||
396 | + SMASK[i] = (uint16)(0x03FF); | ||
397 | + break; | ||
398 | + case 1: | ||
399 | + SSIZE[i] = (int16)(2048); | ||
400 | + SMASK[i] = (uint16)(0x07FF); | ||
401 | + break; | ||
402 | + case 2: | ||
403 | + SSIZE[i] = (int16)(4096); | ||
404 | + SMASK[i] = (uint16)(0x0FFF); | ||
405 | + break; | ||
406 | + case 3: | ||
407 | + SSIZE[i] = (int16)(8192); | ||
408 | + SMASK[i] = (uint16)(0x1FFF); | ||
409 | + break; | ||
410 | + } | ||
411 | + } | ||
412 | + if (rsum < 8192) | ||
413 | + { | ||
414 | + switch((rx_size >> i*2) & 0x03) // Set Rx memory size | ||
415 | + { | ||
416 | + case 0: | ||
417 | + RSIZE[i] = (int16)(1024); | ||
418 | + RMASK[i] = (uint16)(0x03FF); | ||
419 | + break; | ||
420 | + case 1: | ||
421 | + RSIZE[i] = (int16)(2048); | ||
422 | + RMASK[i] = (uint16)(0x07FF); | ||
423 | + break; | ||
424 | + case 2: | ||
425 | + RSIZE[i] = (int16)(4096); | ||
426 | + RMASK[i] = (uint16)(0x0FFF); | ||
427 | + break; | ||
428 | + case 3: | ||
429 | + RSIZE[i] = (int16)(8192); | ||
430 | + RMASK[i] = (uint16)(0x1FFF); | ||
431 | + break; | ||
432 | + } | ||
433 | + } | ||
434 | + ssum += SSIZE[i]; | ||
435 | + rsum += RSIZE[i]; | ||
436 | + | ||
437 | + if (i != 0) // Sets base address of Tx and Rx memory for channel #1,#2,#3 | ||
438 | + { | ||
439 | + SBUFBASEADDRESS[i] = SBUFBASEADDRESS[i-1] + SSIZE[i-1]; | ||
440 | + RBUFBASEADDRESS[i] = RBUFBASEADDRESS[i-1] + RSIZE[i-1]; | ||
441 | + } | ||
442 | +#ifdef __DEF_IINCHIP_DBG__ | ||
443 | + printf("%d : %.4x : %.4x : %.4x : %.4x\r\n", i, (uint16)SBUFBASEADDRESS[i], (uint16)RBUFBASEADDRESS[i], SSIZE[i], RSIZE[i]); | ||
444 | +#endif | ||
445 | + } | ||
446 | +} | ||
447 | + | ||
448 | + | ||
449 | +void setMR(uint8 val) | ||
450 | +{ | ||
451 | + | ||
452 | +#if (__DEF_IINCHIP_BUS__ == __DEF_IINCHIP_INDIRECT_MODE__) | ||
453 | + *((volatile uint8*)(MR)) = val; | ||
454 | +#else | ||
455 | + /* DIRECT ACCESS */ | ||
456 | + IINCHIP_WRITE(MR,val); | ||
457 | +#endif | ||
458 | +} | ||
459 | + | ||
460 | + | ||
461 | +/** | ||
462 | +@brief This function sets up gateway IP address. | ||
463 | +*/ | ||
464 | +void setGAR( | ||
465 | + uint8 * addr /**< a pointer to a 4 -byte array responsible to set the Gateway IP address. */ | ||
466 | + ) | ||
467 | +{ | ||
468 | + IINCHIP_WRITE((GAR0 + 0),addr[0]); | ||
469 | + IINCHIP_WRITE((GAR0 + 1),addr[1]); | ||
470 | + IINCHIP_WRITE((GAR0 + 2),addr[2]); | ||
471 | + IINCHIP_WRITE((GAR0 + 3),addr[3]); | ||
472 | +} | ||
473 | +void getGWIP(uint8 * addr) | ||
474 | +{ | ||
475 | + addr[0] = IINCHIP_READ((GAR0 + 0)); | ||
476 | + addr[1] = IINCHIP_READ((GAR0 + 1)); | ||
477 | + addr[2] = IINCHIP_READ((GAR0 + 2)); | ||
478 | + addr[3] = IINCHIP_READ((GAR0 + 3)); | ||
479 | +} | ||
480 | + | ||
481 | + | ||
482 | +/** | ||
483 | +@brief It sets up SubnetMask address | ||
484 | +*/ | ||
485 | +void setSUBR( | ||
486 | + uint8 * addr /**< a pointer to a 4 -byte array responsible to set the SubnetMask address */ | ||
487 | + ) | ||
488 | +{ | ||
489 | + IINCHIP_WRITE((SUBR0 + 0),addr[0]); | ||
490 | + IINCHIP_WRITE((SUBR0 + 1),addr[1]); | ||
491 | + IINCHIP_WRITE((SUBR0 + 2),addr[2]); | ||
492 | + IINCHIP_WRITE((SUBR0 + 3),addr[3]); | ||
493 | +} | ||
494 | + | ||
495 | + | ||
496 | +/** | ||
497 | +@brief This function sets up MAC address. | ||
498 | +*/ | ||
499 | +void setSHAR( | ||
500 | + uint8 * addr /**< a pointer to a 6 -byte array responsible to set the MAC address. */ | ||
501 | + ) | ||
502 | +{ | ||
503 | + IINCHIP_WRITE((SHAR0 + 0),addr[0]); | ||
504 | + IINCHIP_WRITE((SHAR0 + 1),addr[1]); | ||
505 | + IINCHIP_WRITE((SHAR0 + 2),addr[2]); | ||
506 | + IINCHIP_WRITE((SHAR0 + 3),addr[3]); | ||
507 | + IINCHIP_WRITE((SHAR0 + 4),addr[4]); | ||
508 | + IINCHIP_WRITE((SHAR0 + 5),addr[5]); | ||
509 | +} | ||
510 | + | ||
511 | + | ||
512 | +/** | ||
513 | +@brief This function sets up Source IP address. | ||
514 | +*/ | ||
515 | +void setSIPR( | ||
516 | + uint8 * addr /**< a pointer to a 4 -byte array responsible to set the Source IP address. */ | ||
517 | + ) | ||
518 | +{ | ||
519 | + IINCHIP_WRITE((SIPR0 + 0),addr[0]); | ||
520 | + IINCHIP_WRITE((SIPR0 + 1),addr[1]); | ||
521 | + IINCHIP_WRITE((SIPR0 + 2),addr[2]); | ||
522 | + IINCHIP_WRITE((SIPR0 + 3),addr[3]); | ||
523 | +} | ||
524 | + | ||
525 | + | ||
526 | +/** | ||
527 | +@brief This function gets Interrupt register in common register. | ||
528 | + */ | ||
529 | +uint8 getIR( void ) | ||
530 | +{ | ||
531 | + return IINCHIP_READ(IR); | ||
532 | +} | ||
533 | + | ||
534 | + | ||
535 | + | ||
536 | +/** | ||
537 | +@brief This function sets up Retransmission time. | ||
538 | + | ||
539 | +If there is no response from the peer or delay in response then retransmission | ||
540 | +will be there as per RTR (Retry Time-value Register)setting | ||
541 | +*/ | ||
542 | +void setRTR(uint16 timeout) | ||
543 | +{ | ||
544 | + IINCHIP_WRITE(RTR0,(uint8)((timeout & 0xff00) >> 8)); | ||
545 | + IINCHIP_WRITE((RTR0 + 1),(uint8)(timeout & 0x00ff)); | ||
546 | +} | ||
547 | + | ||
548 | + | ||
549 | +/** | ||
550 | +@brief This function set the number of Retransmission. | ||
551 | + | ||
552 | +If there is no response from the peer or delay in response then recorded time | ||
553 | +as per RTR & RCR register seeting then time out will occur. | ||
554 | +*/ | ||
555 | +void setRCR(uint8 retry) | ||
556 | +{ | ||
557 | + IINCHIP_WRITE(RCR,retry); | ||
558 | +} | ||
559 | + | ||
560 | + | ||
561 | +/** | ||
562 | +@brief This function set the interrupt mask Enable/Disable appropriate Interrupt. ('1' : interrupt enable) | ||
563 | + | ||
564 | +If any bit in IMR is set as '0' then there is not interrupt signal though the bit is | ||
565 | +set in IR register. | ||
566 | +*/ | ||
567 | +void setIMR(uint8 mask) | ||
568 | +{ | ||
569 | + IINCHIP_WRITE(IMR,mask); // must be setted 0x10. | ||
570 | +} | ||
571 | + | ||
572 | + | ||
573 | +/** | ||
574 | +@brief These below functions are used to get the Gateway, SubnetMask | ||
575 | + and Source Hardware Address (MAC Address) and Source IP address | ||
576 | +*/ | ||
577 | +void getGAR(uint8 * addr) | ||
578 | +{ | ||
579 | + addr[0] = IINCHIP_READ(GAR0); | ||
580 | + addr[1] = IINCHIP_READ(GAR0+1); | ||
581 | + addr[2] = IINCHIP_READ(GAR0+2); | ||
582 | + addr[3] = IINCHIP_READ(GAR0+3); | ||
583 | +} | ||
584 | +void getSUBR(uint8 * addr) | ||
585 | +{ | ||
586 | + addr[0] = IINCHIP_READ(SUBR0); | ||
587 | + addr[1] = IINCHIP_READ(SUBR0+1); | ||
588 | + addr[2] = IINCHIP_READ(SUBR0+2); | ||
589 | + addr[3] = IINCHIP_READ(SUBR0+3); | ||
590 | +} | ||
591 | +void getSHAR(uint8 * addr) | ||
592 | +{ | ||
593 | + addr[0] = IINCHIP_READ(SHAR0); | ||
594 | + addr[1] = IINCHIP_READ(SHAR0+1); | ||
595 | + addr[2] = IINCHIP_READ(SHAR0+2); | ||
596 | + addr[3] = IINCHIP_READ(SHAR0+3); | ||
597 | + addr[4] = IINCHIP_READ(SHAR0+4); | ||
598 | + addr[5] = IINCHIP_READ(SHAR0+5); | ||
599 | +} | ||
600 | +void getSIPR(uint8 * addr) | ||
601 | +{ | ||
602 | + addr[0] = IINCHIP_READ(SIPR0); | ||
603 | + addr[1] = IINCHIP_READ(SIPR0+1); | ||
604 | + addr[2] = IINCHIP_READ(SIPR0+2); | ||
605 | + addr[3] = IINCHIP_READ(SIPR0+3); | ||
606 | +} | ||
607 | + | ||
608 | + | ||
609 | +/** | ||
610 | +@brief These below functions are used to get the Destination Hardware Address (MAC Address), Destination IP address and Destination Port. | ||
611 | +*/ | ||
612 | +void getSn_DHAR(SOCKET s, uint8 * addr) | ||
613 | +{ | ||
614 | + addr[0] = IINCHIP_READ(Sn_DHAR0(s)); | ||
615 | + addr[1] = IINCHIP_READ(Sn_DHAR0(s)+1); | ||
616 | + addr[2] = IINCHIP_READ(Sn_DHAR0(s)+2); | ||
617 | + addr[3] = IINCHIP_READ(Sn_DHAR0(s)+3); | ||
618 | + addr[4] = IINCHIP_READ(Sn_DHAR0(s)+4); | ||
619 | + addr[5] = IINCHIP_READ(Sn_DHAR0(s)+5); | ||
620 | +} | ||
621 | +void setSn_DHAR(SOCKET s, uint8 * addr) | ||
622 | +{ | ||
623 | + IINCHIP_WRITE((Sn_DHAR0(s) + 0),addr[0]); | ||
624 | + IINCHIP_WRITE((Sn_DHAR0(s) + 1),addr[1]); | ||
625 | + IINCHIP_WRITE((Sn_DHAR0(s) + 2),addr[2]); | ||
626 | + IINCHIP_WRITE((Sn_DHAR0(s) + 3),addr[3]); | ||
627 | + IINCHIP_WRITE((Sn_DHAR0(s) + 4),addr[4]); | ||
628 | + IINCHIP_WRITE((Sn_DHAR0(s) + 5),addr[5]); | ||
629 | +} | ||
630 | +void getSn_DIPR(SOCKET s, uint8 * addr) | ||
631 | +{ | ||
632 | + addr[0] = IINCHIP_READ(Sn_DIPR0(s)); | ||
633 | + addr[1] = IINCHIP_READ(Sn_DIPR0(s)+1); | ||
634 | + addr[2] = IINCHIP_READ(Sn_DIPR0(s)+2); | ||
635 | + addr[3] = IINCHIP_READ(Sn_DIPR0(s)+3); | ||
636 | +} | ||
637 | +void setSn_DIPR(SOCKET s, uint8 * addr) | ||
638 | +{ | ||
639 | + IINCHIP_WRITE((Sn_DIPR0(s) + 0),addr[0]); | ||
640 | + IINCHIP_WRITE((Sn_DIPR0(s) + 1),addr[1]); | ||
641 | + IINCHIP_WRITE((Sn_DIPR0(s) + 2),addr[2]); | ||
642 | + IINCHIP_WRITE((Sn_DIPR0(s) + 3),addr[3]); | ||
643 | +} | ||
644 | +void getSn_DPORT(SOCKET s, uint8 * addr) | ||
645 | +{ | ||
646 | + addr[0] = IINCHIP_READ(Sn_DPORT0(s)); | ||
647 | + addr[1] = IINCHIP_READ(Sn_DPORT0(s)+1); | ||
648 | +} | ||
649 | +void setSn_DPORT(SOCKET s, uint8 * addr) | ||
650 | +{ | ||
651 | + IINCHIP_WRITE((Sn_DPORT0(s) + 0),addr[0]); | ||
652 | + IINCHIP_WRITE((Sn_DPORT0(s) + 1),addr[1]); | ||
653 | +} | ||
654 | + | ||
655 | + | ||
656 | +/** | ||
657 | +@brief This sets the maximum segment size of TCP in Active Mode), while in Passive Mode this is set by peer | ||
658 | +*/ | ||
659 | +void setSn_MSS(SOCKET s, uint16 Sn_MSSR0) | ||
660 | +{ | ||
661 | + IINCHIP_WRITE(Sn_MSSR0(s),(uint8)((Sn_MSSR0 & 0xff00) >> 8)); | ||
662 | + IINCHIP_WRITE((Sn_MSSR0(s) + 1),(uint8)(Sn_MSSR0 & 0x00ff)); | ||
663 | +} | ||
664 | + | ||
665 | +void setSn_TTL(SOCKET s, uint8 ttl) | ||
666 | +{ | ||
667 | + IINCHIP_WRITE(Sn_TTL(s), ttl); | ||
668 | +} | ||
669 | + | ||
670 | + | ||
671 | +/** | ||
672 | +@brief These below function is used to setup the Protocol Field of IP Header when | ||
673 | + executing the IP Layer RAW mode. | ||
674 | +*/ | ||
675 | +void setSn_PROTO(SOCKET s, uint8 proto) | ||
676 | +{ | ||
677 | + IINCHIP_WRITE(Sn_PROTO(s),proto); | ||
678 | +} | ||
679 | + | ||
680 | + | ||
681 | +/** | ||
682 | +@brief get socket interrupt status | ||
683 | + | ||
684 | +These below functions are used to read the Interrupt & Soket Status register | ||
685 | +*/ | ||
686 | +uint8 getSn_IR(SOCKET s) | ||
687 | +{ | ||
688 | + return IINCHIP_READ(Sn_IR(s)); | ||
689 | +} | ||
690 | + | ||
691 | + | ||
692 | +/** | ||
693 | +@brief get socket status | ||
694 | +*/ | ||
695 | +uint8 getSn_SR(SOCKET s) | ||
696 | +{ | ||
697 | + return IINCHIP_READ(Sn_SR(s)); | ||
698 | +} | ||
699 | + | ||
700 | + | ||
701 | +/** | ||
702 | +@brief get socket TX free buf size | ||
703 | + | ||
704 | +This gives free buffer size of transmit buffer. This is the data size that user can transmit. | ||
705 | +User shuold check this value first and control the size of transmitting data | ||
706 | +*/ | ||
707 | +uint16 getSn_TX_FSR(SOCKET s) | ||
708 | +{ | ||
709 | + uint16 val=0,val1=0; | ||
710 | + do | ||
711 | + { | ||
712 | + val1 = IINCHIP_READ(Sn_TX_FSR0(s)); | ||
713 | + val1 = (val1 << 8) + IINCHIP_READ(Sn_TX_FSR0(s) + 1); | ||
714 | + if (val1 != 0) | ||
715 | + { | ||
716 | + val = IINCHIP_READ(Sn_TX_FSR0(s)); | ||
717 | + val = (val << 8) + IINCHIP_READ(Sn_TX_FSR0(s) + 1); | ||
718 | + } | ||
719 | + } while (val != val1); | ||
720 | + return val; | ||
721 | +} | ||
722 | + | ||
723 | + | ||
724 | +/** | ||
725 | +@brief get socket RX recv buf size | ||
726 | + | ||
727 | +This gives size of received data in receive buffer. | ||
728 | +*/ | ||
729 | +uint16 getSn_RX_RSR(SOCKET s) | ||
730 | +{ | ||
731 | + uint16 val=0,val1=0; | ||
732 | + do | ||
733 | + { | ||
734 | + val1 = IINCHIP_READ(Sn_RX_RSR0(s)); | ||
735 | + val1 = (val1 << 8) + IINCHIP_READ(Sn_RX_RSR0(s) + 1); | ||
736 | + if(val1 != 0) | ||
737 | + { | ||
738 | + val = IINCHIP_READ(Sn_RX_RSR0(s)); | ||
739 | + val = (val << 8) + IINCHIP_READ(Sn_RX_RSR0(s) + 1); | ||
740 | + } | ||
741 | + } while (val != val1); | ||
742 | + return val; | ||
743 | +} | ||
744 | + | ||
745 | + | ||
746 | +/** | ||
747 | +@brief This function is being called by send() and sendto() function also. | ||
748 | + | ||
749 | +This function read the Tx write pointer register and after copy the data in buffer update the Tx write pointer | ||
750 | +register. User should read upper byte first and lower byte later to get proper value. | ||
751 | +*/ | ||
752 | +void send_data_processing(SOCKET s, uint8 *data, uint16 len) | ||
753 | +{ | ||
754 | + uint16 ptr; | ||
755 | + ptr = IINCHIP_READ(Sn_TX_WR0(s)); | ||
756 | + ptr = ((ptr & 0x00ff) << 8) + IINCHIP_READ(Sn_TX_WR0(s) + 1); | ||
757 | + write_data(s, data, (uint8 *)(ptr), len); | ||
758 | + ptr += len; | ||
759 | + IINCHIP_WRITE(Sn_TX_WR0(s),(uint8)((ptr & 0xff00) >> 8)); | ||
760 | + IINCHIP_WRITE((Sn_TX_WR0(s) + 1),(uint8)(ptr & 0x00ff)); | ||
761 | +} | ||
762 | + | ||
763 | + | ||
764 | +/** | ||
765 | +@brief This function is being called by recv() also. | ||
766 | + | ||
767 | +This function read the Rx read pointer register | ||
768 | +and after copy the data from receive buffer update the Rx write pointer register. | ||
769 | +User should read upper byte first and lower byte later to get proper value. | ||
770 | +*/ | ||
771 | +void recv_data_processing(SOCKET s, uint8 *data, uint16 len) | ||
772 | +{ | ||
773 | + uint16 ptr; | ||
774 | + ptr = IINCHIP_READ(Sn_RX_RD0(s)); | ||
775 | + ptr = ((ptr & 0x00ff) << 8) + IINCHIP_READ(Sn_RX_RD0(s) + 1); | ||
776 | +#ifdef __DEF_IINCHIP_DBG__ | ||
777 | + printf("ISR_RX: rd_ptr : %.4x\r\n", ptr); | ||
778 | +#endif | ||
779 | + read_data(s, (uint8 *)ptr, data, len); // read data | ||
780 | + ptr += len; | ||
781 | + IINCHIP_WRITE(Sn_RX_RD0(s),(uint8)((ptr & 0xff00) >> 8)); | ||
782 | + IINCHIP_WRITE((Sn_RX_RD0(s) + 1),(uint8)(ptr & 0x00ff)); | ||
783 | +} | ||
784 | + | ||
785 | + | ||
786 | +/** | ||
787 | +@brief for copy the data form application buffer to Transmite buffer of the chip. | ||
788 | + | ||
789 | +This function is being used for copy the data form application buffer to Transmite | ||
790 | +buffer of the chip. It calculate the actual physical address where one has to write | ||
791 | +the data in transmite buffer. Here also take care of the condition while it exceed | ||
792 | +the Tx memory uper-bound of socket. | ||
793 | +*/ | ||
794 | +void write_data(SOCKET s, vuint8 * src, vuint8 * dst, uint16 len) | ||
795 | +{ | ||
796 | + uint16 size; | ||
797 | + uint16 dst_mask; | ||
798 | + uint8 * dst_ptr; | ||
799 | + | ||
800 | + dst_mask = (uint16)dst & getIINCHIP_TxMASK(s); | ||
801 | + dst_ptr = (uint8 *)(getIINCHIP_TxBASE(s) + dst_mask); | ||
802 | + | ||
803 | + if (dst_mask + len > getIINCHIP_TxMAX(s)) | ||
804 | + { | ||
805 | + size = getIINCHIP_TxMAX(s) - dst_mask; | ||
806 | + wiz_write_buf((uint16)dst_ptr, (uint8*)src, size); | ||
807 | + src += size; | ||
808 | + size = len - size; | ||
809 | + dst_ptr = (uint8 *)(getIINCHIP_TxBASE(s)); | ||
810 | + wiz_write_buf((uint16)dst_ptr, (uint8*)src, size); | ||
811 | + } | ||
812 | + else | ||
813 | + { | ||
814 | + wiz_write_buf((uint16)dst_ptr, (uint8*)src, len); | ||
815 | + } | ||
816 | +} | ||
817 | + | ||
818 | + | ||
819 | +/** | ||
820 | +@brief This function is being used for copy the data form Receive buffer of the chip to application buffer. | ||
821 | + | ||
822 | +It calculate the actual physical address where one has to read | ||
823 | +the data from Receive buffer. Here also take care of the condition while it exceed | ||
824 | +the Rx memory uper-bound of socket. | ||
825 | +*/ | ||
826 | +void read_data(SOCKET s, vuint8 * src, vuint8 * dst, uint16 len) | ||
827 | +{ | ||
828 | + uint16 size; | ||
829 | + uint16 src_mask; | ||
830 | + uint8 * src_ptr; | ||
831 | + | ||
832 | + src_mask = (uint16)src & getIINCHIP_RxMASK(s); | ||
833 | + src_ptr = (uint8 *)(getIINCHIP_RxBASE(s) + src_mask); | ||
834 | + | ||
835 | + if( (src_mask + len) > getIINCHIP_RxMAX(s) ) | ||
836 | + { | ||
837 | + size = getIINCHIP_RxMAX(s) - src_mask; | ||
838 | + wiz_read_buf((uint16)src_ptr, (uint8*)dst,size); | ||
839 | + dst += size; | ||
840 | + size = len - size; | ||
841 | + src_ptr = (uint8 *)(getIINCHIP_RxBASE(s)); | ||
842 | + wiz_read_buf((uint16)src_ptr, (uint8*) dst,size); | ||
843 | + } | ||
844 | + else | ||
845 | + { | ||
846 | + wiz_read_buf((uint16)src_ptr, (uint8*) dst,len); | ||
847 | + } | ||
848 | +} | ||
849 | + | ||
850 | + | ||
851 | +#ifdef __DEF_IINCHIP_PPP__ | ||
852 | +#define PPP_OPTION_BUF_LEN 64 | ||
853 | + | ||
854 | +uint8 pppinit_in(uint8 * id, uint8 idlen, uint8 * passwd, uint8 passwdlen); | ||
855 | + | ||
856 | + | ||
857 | +/** | ||
858 | +@brief make PPPoE connection | ||
859 | +@return 1 => success to connect, 2 => Auth fail, 3 => timeout, 4 => Auth type not support | ||
860 | + | ||
861 | +*/ | ||
862 | +uint8 pppinit(uint8 * id, uint8 idlen, uint8 * passwd, uint8 passwdlen) | ||
863 | +{ | ||
864 | + uint8 ret; | ||
865 | + uint8 isr; | ||
866 | + | ||
867 | + // PHASE0. W5100 PPPoE(ADSL) setup | ||
868 | + // enable pppoe mode | ||
869 | + printf("-- PHASE 0. W5100 PPPoE(ADSL) setup process --\r\n"); | ||
870 | + printf("\r\n"); | ||
871 | + IINCHIP_WRITE(MR,IINCHIP_READ(MR) | MR_PPPOE); | ||
872 | + | ||
873 | + // open socket in pppoe mode | ||
874 | + isr = IINCHIP_READ(Sn_IR(0));// first clear isr(0), W5100 at present time | ||
875 | + IINCHIP_WRITE(Sn_IR(0),isr); | ||
876 | + | ||
877 | + IINCHIP_WRITE(PTIMER,200); // 5sec timeout | ||
878 | + IINCHIP_WRITE(PMAGIC,0x01); // magic number | ||
879 | + IINCHIP_WRITE(Sn_MR(0),Sn_MR_PPPOE); | ||
880 | + IINCHIP_WRITE(Sn_CR(0),Sn_CR_OPEN); | ||
881 | + | ||
882 | + /* +20071122[chungs]:wait to process the command... */ | ||
883 | + while( IINCHIP_READ(Sn_CR(0)) ) | ||
884 | + ; | ||
885 | + /* ------- */ | ||
886 | + | ||
887 | + ret = pppinit_in(id, idlen, passwd, passwdlen); | ||
888 | + | ||
889 | + // close ppp connection socket | ||
890 | + /* +200801 (hwkim) */ | ||
891 | + close(0); | ||
892 | + /* ------- */ | ||
893 | + | ||
894 | + return ret; | ||
895 | +} | ||
896 | + | ||
897 | + | ||
898 | +uint8 pppinit_in(uint8 * id, uint8 idlen, uint8 * passwd, uint8 passwdlen) | ||
899 | +{ | ||
900 | + uint8 loop_idx = 0; | ||
901 | + uint8 isr = 0; | ||
902 | + uint8 buf[PPP_OPTION_BUF_LEN]; | ||
903 | + uint16 len; | ||
904 | + uint8 str[PPP_OPTION_BUF_LEN]; | ||
905 | + uint8 str_idx,dst_idx; | ||
906 | + | ||
907 | + // PHASE1. PPPoE Discovery | ||
908 | + // start to connect pppoe connection | ||
909 | + printf("-- PHASE 1. PPPoE Discovery process --"); | ||
910 | + printf(" ok\r\n"); | ||
911 | + printf("\r\n"); | ||
912 | + IINCHIP_WRITE(Sn_CR(0),Sn_CR_PCON); | ||
913 | + /* +20071122[chungs]:wait to process the command... */ | ||
914 | + while( IINCHIP_READ(Sn_CR(0)) ) | ||
915 | + ; | ||
916 | + /* ------- */ | ||
917 | + | ||
918 | + wait_10ms(100); | ||
919 | + | ||
920 | + loop_idx = 0; | ||
921 | + //check whether PPPoE discovery end or not | ||
922 | + while (!(IINCHIP_READ(Sn_IR(0)) & Sn_IR_PNEXT)) | ||
923 | + { | ||
924 | + printf("."); | ||
925 | + if (loop_idx++ == 10) // timeout | ||
926 | + { | ||
927 | + printf("timeout before LCP\r\n"); | ||
928 | + return 3; | ||
929 | + } | ||
930 | + wait_10ms(100); | ||
931 | + } | ||
932 | + | ||
933 | + /* +200801[bj] clear interrupt value*/ | ||
934 | + IINCHIP_WRITE(Sn_IR(0), 0xff); | ||
935 | + /*---*/ | ||
936 | + | ||
937 | + // PHASE2. LCP process | ||
938 | + printf("-- PHASE 2. LCP process --"); | ||
939 | + | ||
940 | + // send LCP Request | ||
941 | + { | ||
942 | + // Magic number option | ||
943 | + // option format (type value + length value + data) | ||
944 | + // write magic number value | ||
945 | + buf[0] = 0x05; // type value | ||
946 | + buf[1] = 0x06; // length value | ||
947 | + buf[2] = 0x01; buf[3] = 0x01; buf[4] = 0x01; buf[5]= 0x01; // data | ||
948 | + // for MRU option, 1492 0x05d4 | ||
949 | + // buf[6] = 0x01; buf[7] = 0x04; buf[8] = 0x05; buf[9] = 0xD4; | ||
950 | + } | ||
951 | + send_data_processing(0, buf, 0x06); | ||
952 | + IINCHIP_WRITE(Sn_CR(0),Sn_CR_PCR); // send request | ||
953 | + /* +20071122[chungs]:wait to process the command... */ | ||
954 | + while( IINCHIP_READ(Sn_CR(0)) ) | ||
955 | + ; | ||
956 | + /* ------- */ | ||
957 | + | ||
958 | + wait_10ms(100); | ||
959 | + | ||
960 | + while (!((isr = IINCHIP_READ(Sn_IR(0))) & Sn_IR_PNEXT)) | ||
961 | + { | ||
962 | + if (isr & Sn_IR_PRECV) // Not support option | ||
963 | + { | ||
964 | + /* +200801[bj] clear interrupt value*/ | ||
965 | + IINCHIP_WRITE(Sn_IR(0), Sn_IR_PRECV); | ||
966 | + /*---*/ | ||
967 | + len = getSn_RX_RSR(0); | ||
968 | + if ( len > 0 ) | ||
969 | + { | ||
970 | + recv_data_processing(0, str, len); | ||
971 | + IINCHIP_WRITE(Sn_CR(0),Sn_CR_RECV); | ||
972 | + /* +20071122[chungs]:wait to process the command... */ | ||
973 | + while( IINCHIP_READ(Sn_CR(0)) ) | ||
974 | + ; | ||
975 | + /* ------- */ | ||
976 | + | ||
977 | + // for debug | ||
978 | + //printf("LCP proc\r\n"); for (i = 0; i < len; i++) printf ("%02x ", str[i]); printf("\r\n"); | ||
979 | + // get option length | ||
980 | + len = str[4]; len = ((len & 0x00ff) << 8) + str[5]; | ||
981 | + len += 2; | ||
982 | + str_idx = 6; dst_idx = 0; // ppp header is 6 byte, so starts at 6. | ||
983 | + do | ||
984 | + { | ||
985 | + if ((str[str_idx] == 0x01) || (str[str_idx] == 0x02) || (str[str_idx] == 0x03) || (str[str_idx] == 0x05)) | ||
986 | + { | ||
987 | + // skip as length of support option. str_idx+1 is option's length. | ||
988 | + str_idx += str[str_idx+1]; | ||
989 | + } | ||
990 | + else | ||
991 | + { | ||
992 | + // not support option , REJECT | ||
993 | + memcpy((uint8 *)(buf+dst_idx), (uint8 *)(str+str_idx), str[str_idx+1]); | ||
994 | + dst_idx += str[str_idx+1]; str_idx += str[str_idx+1]; | ||
995 | + } | ||
996 | + } while (str_idx != len); | ||
997 | + // for debug | ||
998 | + // printf("LCP dst proc\r\n"); for (i = 0; i < dst_idx; i++) printf ("%02x ", dst[i]); printf("\r\n"); | ||
999 | + | ||
1000 | + // send LCP REJECT packet | ||
1001 | + send_data_processing(0, buf, dst_idx); | ||
1002 | + IINCHIP_WRITE(Sn_CR(0),Sn_CR_PCJ); | ||
1003 | + /* +20071122[chungs]:wait to process the command... */ | ||
1004 | + while( IINCHIP_READ(Sn_CR(0)) ) | ||
1005 | + ; | ||
1006 | + /* ------- */ | ||
1007 | + } | ||
1008 | + } | ||
1009 | + printf("."); | ||
1010 | + if (loop_idx++ == 10) // timeout | ||
1011 | + { | ||
1012 | + printf("timeout after LCP\r\n"); | ||
1013 | + return 3; | ||
1014 | + } | ||
1015 | + wait_10ms(100); | ||
1016 | + } | ||
1017 | + printf(" ok\r\n"); | ||
1018 | + printf("\r\n"); | ||
1019 | + | ||
1020 | + /* +200801[bj] clear interrupt value*/ | ||
1021 | + IINCHIP_WRITE(Sn_IR(0), 0xff); | ||
1022 | + /*---*/ | ||
1023 | + | ||
1024 | + printf("-- PHASE 3. PPPoE(ADSL) Authentication mode --\r\n"); | ||
1025 | + printf("Authentication protocol : %.2x %.2x, ", IINCHIP_READ(PATR0), IINCHIP_READ(PATR0+1)); | ||
1026 | + | ||
1027 | + loop_idx = 0; | ||
1028 | + if (IINCHIP_READ(PATR0) == 0xc0 && IINCHIP_READ(PATR0+1) == 0x23) | ||
1029 | + { | ||
1030 | + printf("PAP\r\n"); // in case of adsl normally supports PAP. | ||
1031 | + // send authentication data | ||
1032 | + // copy (idlen + id + passwdlen + passwd) | ||
1033 | + buf[loop_idx] = idlen; loop_idx++; | ||
1034 | + memcpy((uint8 *)(buf+loop_idx), (uint8 *)(id), idlen); loop_idx += idlen; | ||
1035 | + buf[loop_idx] = passwdlen; loop_idx++; | ||
1036 | + memcpy((uint8 *)(buf+loop_idx), (uint8 *)(passwd), passwdlen); loop_idx += passwdlen; | ||
1037 | + send_data_processing(0, buf, loop_idx); | ||
1038 | + IINCHIP_WRITE(Sn_CR(0),Sn_CR_PCR); | ||
1039 | + /* +20071122[chungs]:wait to process the command... */ | ||
1040 | + while( IINCHIP_READ(Sn_CR(0)) ) | ||
1041 | + ; | ||
1042 | + /* ------- */ | ||
1043 | + wait_10ms(100); | ||
1044 | + } | ||
1045 | + else if (IINCHIP_READ(PATR0) == 0xc2 && IINCHIP_READ(PATR0+1) == 0x23) | ||
1046 | + { | ||
1047 | + uint8 chal_len; | ||
1048 | + md5_ctx context; | ||
1049 | + uint8 digest[16]; | ||
1050 | + | ||
1051 | + len = getSn_RX_RSR(0); | ||
1052 | + if ( len > 0 ) | ||
1053 | + { | ||
1054 | + recv_data_processing(0, str, len); | ||
1055 | + IINCHIP_WRITE(Sn_CR(0),Sn_CR_RECV); | ||
1056 | + /* +20071122[chungs]:wait to process the command... */ | ||
1057 | + while( IINCHIP_READ(Sn_CR(0)) ) | ||
1058 | + ; | ||
1059 | + /* ------- */ | ||
1060 | +#ifdef __DEF_IINCHIP_DBG__ | ||
1061 | + printf("recv CHAP\r\n"); | ||
1062 | + { | ||
1063 | + int16 i; | ||
1064 | + | ||
1065 | + for (i = 0; i < 32; i++) | ||
1066 | + printf ("%02x ", str[i]); | ||
1067 | + } | ||
1068 | + printf("\r\n"); | ||
1069 | +#endif | ||
1070 | +// str is C2 23 xx CHAL_ID xx xx CHAP_LEN CHAP_DATA | ||
1071 | +// index 0 1 2 3 4 5 6 7 ... | ||
1072 | + | ||
1073 | + memset(buf,0x00,64); | ||
1074 | + buf[loop_idx] = str[3]; loop_idx++; // chal_id | ||
1075 | + memcpy((uint8 *)(buf+loop_idx), (uint8 *)(passwd), passwdlen); loop_idx += passwdlen; //passwd | ||
1076 | + chal_len = str[6]; // chal_id | ||
1077 | + memcpy((uint8 *)(buf+loop_idx), (uint8 *)(str+7), chal_len); loop_idx += chal_len; //challenge | ||
1078 | + buf[loop_idx] = 0x80; | ||
1079 | +#ifdef __DEF_IINCHIP_DBG__ | ||
1080 | + printf("CHAP proc d1\r\n"); | ||
1081 | + { | ||
1082 | + int16 i; | ||
1083 | + for (i = 0; i < 64; i++) | ||
1084 | + printf ("%02x ", buf[i]); | ||
1085 | + } | ||
1086 | + printf("\r\n"); | ||
1087 | +#endif | ||
1088 | + | ||
1089 | + md5_init(&context); | ||
1090 | + md5_update(&context, buf, loop_idx); | ||
1091 | + md5_final(digest, &context); | ||
1092 | + | ||
1093 | +#ifdef __DEF_IINCHIP_DBG__ | ||
1094 | + printf("CHAP proc d1\r\n"); | ||
1095 | + { | ||
1096 | + int16 i; | ||
1097 | + for (i = 0; i < 16; i++) | ||
1098 | + printf ("%02x", digest[i]); | ||
1099 | + } | ||
1100 | + printf("\r\n"); | ||
1101 | +#endif | ||
1102 | + loop_idx = 0; | ||
1103 | + buf[loop_idx] = 16; loop_idx++; // hash_len | ||
1104 | + memcpy((uint8 *)(buf+loop_idx), (uint8 *)(digest), 16); loop_idx += 16; // hashed value | ||
1105 | + memcpy((uint8 *)(buf+loop_idx), (uint8 *)(id), idlen); loop_idx += idlen; // id | ||
1106 | + send_data_processing(0, buf, loop_idx); | ||
1107 | + IINCHIP_WRITE(Sn_CR(0),Sn_CR_PCR); | ||
1108 | + /* +20071122[chungs]:wait to process the command... */ | ||
1109 | + while( IINCHIP_READ(Sn_CR(0)) ) | ||
1110 | + ; | ||
1111 | + /* ------- */ | ||
1112 | + wait_10ms(100); | ||
1113 | + } | ||
1114 | + } | ||
1115 | + else | ||
1116 | + { | ||
1117 | + printf("Not support\r\n"); | ||
1118 | +#ifdef __DEF_IINCHIP_DBG__ | ||
1119 | + printf("Not support PPP Auth type: %.2x%.2x\r\n",IINCHIP_READ(PATR0), IINCHIP_READ(PATR0+1)); | ||
1120 | +#endif | ||
1121 | + return 4; | ||
1122 | + } | ||
1123 | + printf("\r\n"); | ||
1124 | + | ||
1125 | + printf("-- Waiting for PPPoE server's admission --"); | ||
1126 | + loop_idx = 0; | ||
1127 | + while (!((isr = IINCHIP_READ(Sn_IR(0))) & Sn_IR_PNEXT)) | ||
1128 | + { | ||
1129 | + if (isr & Sn_IR_PFAIL) | ||
1130 | + { | ||
1131 | + /* +200801[bj] clear interrupt value*/ | ||
1132 | + IINCHIP_WRITE(Sn_IR(0), 0xff); | ||
1133 | + /*---*/ | ||
1134 | + printf("failed\r\nReinput id, password..\r\n"); | ||
1135 | + return 2; | ||
1136 | + } | ||
1137 | + printf("."); | ||
1138 | + if (loop_idx++ == 10) // timeout | ||
1139 | + { | ||
1140 | + /* +200801[bj] clear interrupt value*/ | ||
1141 | + IINCHIP_WRITE(Sn_IR(0), 0xff); | ||
1142 | + /*---*/ | ||
1143 | + printf("timeout after PAP\r\n"); | ||
1144 | + return 3; | ||
1145 | + } | ||
1146 | + wait_10ms(100); | ||
1147 | + } | ||
1148 | + /* +200801[bj] clear interrupt value*/ | ||
1149 | + IINCHIP_WRITE(Sn_IR(0), 0xff); | ||
1150 | + /*---*/ | ||
1151 | + printf("ok\r\n"); | ||
1152 | + printf("\r\n"); | ||
1153 | + printf("-- PHASE 4. IPCP process --"); | ||
1154 | + // IP Address | ||
1155 | + buf[0] = 0x03; buf[1] = 0x06; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; | ||
1156 | + send_data_processing(0, buf, 6); | ||
1157 | + IINCHIP_WRITE(Sn_CR(0),Sn_CR_PCR); | ||
1158 | + /* +20071122[chungs]:wait to process the command... */ | ||
1159 | + while( IINCHIP_READ(Sn_CR(0)) ) | ||
1160 | + ; | ||
1161 | + /* ------- */ | ||
1162 | + wait_10ms(100); | ||
1163 | + | ||
1164 | + loop_idx = 0; | ||
1165 | + while (1) | ||
1166 | + { | ||
1167 | + if (IINCHIP_READ(Sn_IR(0)) & Sn_IR_PRECV) | ||
1168 | + { | ||
1169 | + /* +200801[bj] clear interrupt value*/ | ||
1170 | + IINCHIP_WRITE(Sn_IR(0), 0xff); | ||
1171 | + /*---*/ | ||
1172 | + len = getSn_RX_RSR(0); | ||
1173 | + if ( len > 0 ) | ||
1174 | + { | ||
1175 | + recv_data_processing(0, str, len); | ||
1176 | + IINCHIP_WRITE(Sn_CR(0),Sn_CR_RECV); | ||
1177 | + /* +20071122[chungs]:wait to process the command... */ | ||
1178 | + while( IINCHIP_READ(Sn_CR(0)) ) | ||
1179 | + ; | ||
1180 | + /* ------- */ | ||
1181 | + //for debug | ||
1182 | + //printf("IPCP proc\r\n"); for (i = 0; i < len; i++) printf ("%02x ", str[i]); printf("\r\n"); | ||
1183 | + str_idx = 6; dst_idx = 0; | ||
1184 | + if (str[2] == 0x03) // in case of NAK | ||
1185 | + { | ||
1186 | + do | ||
1187 | + { | ||
1188 | + if (str[str_idx] == 0x03) // request only ip information | ||
1189 | + { | ||
1190 | + memcpy((uint8 *)(buf+dst_idx), (uint8 *)(str+str_idx), str[str_idx+1]); | ||
1191 | + dst_idx += str[str_idx+1]; str_idx += str[str_idx+1]; | ||
1192 | + } | ||
1193 | + else | ||
1194 | + { | ||
1195 | + // skip byte | ||
1196 | + str_idx += str[str_idx+1]; | ||
1197 | + } | ||
1198 | + // for debug | ||
1199 | + //printf("s: %d, d: %d, l: %d", str_idx, dst_idx, len); | ||
1200 | + } while (str_idx != len); | ||
1201 | + send_data_processing(0, buf, dst_idx); | ||
1202 | + IINCHIP_WRITE(Sn_CR(0),Sn_CR_PCR); // send ipcp request | ||
1203 | + /* +20071122[chungs]:wait to process the command... */ | ||
1204 | + while( IINCHIP_READ(Sn_CR(0)) ) | ||
1205 | + ; | ||
1206 | + /* ------- */ | ||
1207 | + wait_10ms(100); | ||
1208 | + break; | ||
1209 | + } | ||
1210 | + } | ||
1211 | + } | ||
1212 | + printf("."); | ||
1213 | + if (loop_idx++ == 10) // timeout | ||
1214 | + { | ||
1215 | + printf("timeout after IPCP\r\n"); | ||
1216 | + return 3; | ||
1217 | + } | ||
1218 | + wait_10ms(100); | ||
1219 | + send_data_processing(0, buf, 6); | ||
1220 | + IINCHIP_WRITE(Sn_CR(0),Sn_CR_PCR); //ipcp re-request | ||
1221 | + /* +20071122[chungs]:wait to process the command... */ | ||
1222 | + while( IINCHIP_READ(Sn_CR(0)) ) | ||
1223 | + ; | ||
1224 | + /* ------- */ | ||
1225 | + } | ||
1226 | + | ||
1227 | + loop_idx = 0; | ||
1228 | + while (!(IINCHIP_READ(Sn_IR(0)) & Sn_IR_PNEXT)) | ||
1229 | + { | ||
1230 | + printf("."); | ||
1231 | + if (loop_idx++ == 10) // timeout | ||
1232 | + { | ||
1233 | + printf("timeout after IPCP NAK\r\n"); | ||
1234 | + return 3; | ||
1235 | + } | ||
1236 | + wait_10ms(100); | ||
1237 | + IINCHIP_WRITE(Sn_CR(0),Sn_CR_PCR); // send ipcp request | ||
1238 | + /* +20071122[chungs]:wait to process the command... */ | ||
1239 | + while( IINCHIP_READ(Sn_CR(0)) ) | ||
1240 | + ; | ||
1241 | + /* ------- */ | ||
1242 | + } | ||
1243 | + /* +200801[bj] clear interrupt value*/ | ||
1244 | + IINCHIP_WRITE(Sn_IR(0), 0xff); | ||
1245 | + /*---*/ | ||
1246 | + printf("ok\r\n"); | ||
1247 | + printf("\r\n"); | ||
1248 | + return 1; | ||
1249 | + // after this function, User must save the pppoe server's mac address and pppoe session id in current connection | ||
1250 | +} | ||
1251 | + | ||
1252 | + | ||
1253 | +/** | ||
1254 | +@brief terminate PPPoE connection | ||
1255 | +*/ | ||
1256 | +uint8 pppterm(uint8 * mac, uint8 * sessionid) | ||
1257 | +{ | ||
1258 | + uint16 i; | ||
1259 | + uint8 isr; | ||
1260 | +#ifdef __DEF_IINCHIP_DBG__ | ||
1261 | + printf("pppterm()\r\n"); | ||
1262 | +#endif | ||
1263 | + /* Set PPPoE bit in MR(Common Mode Register) : enable socket0 pppoe */ | ||
1264 | + IINCHIP_WRITE(MR,IINCHIP_READ(MR) | MR_PPPOE); | ||
1265 | + | ||
1266 | + // write pppoe server's mac address and session id | ||
1267 | + // must be setted these value. | ||
1268 | + for (i = 0; i < 6; i++) IINCHIP_WRITE((Sn_DHAR0(0)+i),mac[i]); | ||
1269 | + for (i = 0; i < 2; i++) IINCHIP_WRITE((Sn_DPORT0(0)+i),sessionid[i]); | ||
1270 | + isr = IINCHIP_READ(Sn_IR(0)); | ||
1271 | + IINCHIP_WRITE(Sn_IR(0),isr); | ||
1272 | + | ||
1273 | + //open socket in pppoe mode | ||
1274 | + IINCHIP_WRITE(Sn_MR(0),Sn_MR_PPPOE); | ||
1275 | + IINCHIP_WRITE(Sn_CR(0),Sn_CR_OPEN); | ||
1276 | + /* +20071122[chungs]:wait to process the command... */ | ||
1277 | + while( IINCHIP_READ(Sn_CR(0)) ) | ||
1278 | + ; | ||
1279 | + /* ------- */ | ||
1280 | + wait_1us(1); | ||
1281 | + // close pppoe connection | ||
1282 | + IINCHIP_WRITE(Sn_CR(0),Sn_CR_PDISCON); | ||
1283 | + /* +20071122[chungs]:wait to process the command... */ | ||
1284 | + while( IINCHIP_READ(Sn_CR(0)) ) | ||
1285 | + ; | ||
1286 | + /* ------- */ | ||
1287 | + wait_10ms(100); | ||
1288 | + // close socket | ||
1289 | + /* +200801 (hwkim) */ | ||
1290 | + close(0); | ||
1291 | + /* ------- */ | ||
1292 | + | ||
1293 | + | ||
1294 | +#ifdef __DEF_IINCHIP_DBG__ | ||
1295 | + printf("pppterm() end ..\r\n"); | ||
1296 | +#endif | ||
1297 | + | ||
1298 | + return 1; | ||
1299 | +} | ||
1300 | +#endif |
@@ -0,0 +1,299 @@ | @@ -0,0 +1,299 @@ | ||
1 | +/* | ||
2 | +@file w5100.h | ||
3 | +*/ | ||
4 | + | ||
5 | +#ifndef _W5100_H_ | ||
6 | +#define _W5100_H_ | ||
7 | + | ||
8 | + | ||
9 | +#define MR __DEF_IINCHIP_MAP_BASE__ | ||
10 | +#define IDM_OR ((__DEF_IINCHIP_MAP_BASE__ + 0x00)) | ||
11 | +#define IDM_AR0 ((__DEF_IINCHIP_MAP_BASE__ + 0x01)) | ||
12 | +#define IDM_AR1 ((__DEF_IINCHIP_MAP_BASE__ + 0x02)) | ||
13 | +#define IDM_DR ((__DEF_IINCHIP_MAP_BASE__ + 0x03)) | ||
14 | + | ||
15 | + | ||
16 | +/** | ||
17 | + @brief Gateway IP Register address | ||
18 | + */ | ||
19 | +#define GAR0 (COMMON_BASE + 0x0001) | ||
20 | +/** | ||
21 | + @brief Subnet mask Register address | ||
22 | + */ | ||
23 | +#define SUBR0 (COMMON_BASE + 0x0005) | ||
24 | +/** | ||
25 | + @brief Source MAC Register address | ||
26 | + */ | ||
27 | +#define SHAR0 (COMMON_BASE + 0x0009) | ||
28 | +/** | ||
29 | + @brief Source IP Register address | ||
30 | + */ | ||
31 | +#define SIPR0 (COMMON_BASE + 0x000F) | ||
32 | +/** | ||
33 | + @brief Interrupt Register | ||
34 | + */ | ||
35 | +#define IR (COMMON_BASE + 0x0015) | ||
36 | +/** | ||
37 | + @brief Interrupt mask register | ||
38 | + */ | ||
39 | +#define IMR (COMMON_BASE + 0x0016) | ||
40 | +/** | ||
41 | + @brief Timeout register address( 1 is 100us ) | ||
42 | + */ | ||
43 | +#define RTR0 (COMMON_BASE + 0x0017) | ||
44 | +/** | ||
45 | + @brief Retry count reigster | ||
46 | + */ | ||
47 | +#define RCR (COMMON_BASE + 0x0019) | ||
48 | +/** | ||
49 | + @brief Receive memory size reigster | ||
50 | + */ | ||
51 | +#define RMSR (COMMON_BASE + 0x001A) | ||
52 | +/** | ||
53 | + @brief Transmit memory size reigster | ||
54 | + */ | ||
55 | +#define TMSR (COMMON_BASE + 0x001B) | ||
56 | +/** | ||
57 | + @brief Authentication type register address in PPPoE mode | ||
58 | + */ | ||
59 | +#define PATR0 (COMMON_BASE + 0x001C) | ||
60 | +//#define PPPALGO (COMMON_BASE + 0x001D) | ||
61 | +#define PTIMER (COMMON_BASE + 0x0028) | ||
62 | +#define PMAGIC (COMMON_BASE + 0x0029) | ||
63 | + | ||
64 | +/** | ||
65 | + @brief Unreachable IP register address in UDP mode | ||
66 | + */ | ||
67 | +#define UIPR0 (COMMON_BASE + 0x002A) | ||
68 | +/** | ||
69 | + @brief Unreachable Port register address in UDP mode | ||
70 | + */ | ||
71 | +#define UPORT0 (COMMON_BASE + 0x002E) | ||
72 | + | ||
73 | +/** | ||
74 | + @brief socket register | ||
75 | +*/ | ||
76 | +#define CH_BASE (COMMON_BASE + 0x0400) | ||
77 | +/** | ||
78 | + @brief size of each channel register map | ||
79 | + */ | ||
80 | +#define CH_SIZE 0x0100 | ||
81 | +/** | ||
82 | + @brief socket Mode register | ||
83 | + */ | ||
84 | +#define Sn_MR(ch) (CH_BASE + ch * CH_SIZE + 0x0000) | ||
85 | +/** | ||
86 | + @brief channel Sn_CR register | ||
87 | + */ | ||
88 | +#define Sn_CR(ch) (CH_BASE + ch * CH_SIZE + 0x0001) | ||
89 | +/** | ||
90 | + @brief channel interrupt register | ||
91 | + */ | ||
92 | +#define Sn_IR(ch) (CH_BASE + ch * CH_SIZE + 0x0002) | ||
93 | +/** | ||
94 | + @brief channel status register | ||
95 | + */ | ||
96 | +#define Sn_SR(ch) (CH_BASE + ch * CH_SIZE + 0x0003) | ||
97 | +/** | ||
98 | + @brief source port register | ||
99 | + */ | ||
100 | +#define Sn_PORT0(ch) (CH_BASE + ch * CH_SIZE + 0x0004) | ||
101 | +/** | ||
102 | + @brief Peer MAC register address | ||
103 | + */ | ||
104 | +#define Sn_DHAR0(ch) (CH_BASE + ch * CH_SIZE + 0x0006) | ||
105 | +/** | ||
106 | + @brief Peer IP register address | ||
107 | + */ | ||
108 | +#define Sn_DIPR0(ch) (CH_BASE + ch * CH_SIZE + 0x000C) | ||
109 | +/** | ||
110 | + @brief Peer port register address | ||
111 | + */ | ||
112 | +#define Sn_DPORT0(ch) (CH_BASE + ch * CH_SIZE + 0x0010) | ||
113 | +/** | ||
114 | + @brief Maximum Segment Size(Sn_MSSR0) register address | ||
115 | + */ | ||
116 | +#define Sn_MSSR0(ch) (CH_BASE + ch * CH_SIZE + 0x0012) | ||
117 | +/** | ||
118 | + @brief Protocol of IP Header field register in IP raw mode | ||
119 | + */ | ||
120 | +#define Sn_PROTO(ch) (CH_BASE + ch * CH_SIZE + 0x0014) | ||
121 | + | ||
122 | +/** | ||
123 | + @brief IP Type of Service(TOS) Register | ||
124 | + */ | ||
125 | +#define Sn_TOS(ch) (CH_BASE + ch * CH_SIZE + 0x0015) | ||
126 | +/** | ||
127 | + @brief IP Time to live(TTL) Register | ||
128 | + */ | ||
129 | +#define Sn_TTL(ch) (CH_BASE + ch * CH_SIZE + 0x0016) | ||
130 | + | ||
131 | +/** | ||
132 | + @brief Transmit free memory size register | ||
133 | + */ | ||
134 | +#define Sn_TX_FSR0(ch) (CH_BASE + ch * CH_SIZE + 0x0020) | ||
135 | +/** | ||
136 | + @brief Transmit memory read pointer register address | ||
137 | + */ | ||
138 | +#define Sn_TX_RD0(ch) (CH_BASE + ch * CH_SIZE + 0x0022) | ||
139 | +/** | ||
140 | + @brief Transmit memory write pointer register address | ||
141 | + */ | ||
142 | +#define Sn_TX_WR0(ch) (CH_BASE + ch * CH_SIZE + 0x0024) | ||
143 | +/** | ||
144 | + @brief Received data size register | ||
145 | + */ | ||
146 | +#define Sn_RX_RSR0(ch) (CH_BASE + ch * CH_SIZE + 0x0026) | ||
147 | +/** | ||
148 | + @brief Read point of Receive memory | ||
149 | + */ | ||
150 | +#define Sn_RX_RD0(ch) (CH_BASE + ch * CH_SIZE + 0x0028) | ||
151 | +/** | ||
152 | + @brief Write point of Receive memory | ||
153 | + */ | ||
154 | +#define Sn_RX_WR0(ch) (CH_BASE + ch * CH_SIZE + 0x002A) | ||
155 | + | ||
156 | + | ||
157 | + | ||
158 | +/* MODE register values */ | ||
159 | +#define MR_RST 0x80 /**< reset */ | ||
160 | +#define MR_PB 0x10 /**< ping block */ | ||
161 | +#define MR_PPPOE 0x08 /**< enable pppoe */ | ||
162 | +#define MR_LB 0x04 /**< little or big endian selector in indirect mode */ | ||
163 | +#define MR_AI 0x02 /**< auto-increment in indirect mode */ | ||
164 | +#define MR_IND 0x01 /**< enable indirect mode */ | ||
165 | + | ||
166 | +/* IR register values */ | ||
167 | +#define IR_CONFLICT 0x80 /**< check ip confict */ | ||
168 | +#define IR_UNREACH 0x40 /**< get the destination unreachable message in UDP sending */ | ||
169 | +#define IR_PPPoE 0x20 /**< get the PPPoE close message */ | ||
170 | +#define IR_SOCK(ch) (0x01 << ch) /**< check socket interrupt */ | ||
171 | + | ||
172 | +/* Sn_MR values */ | ||
173 | +#define Sn_MR_CLOSE 0x00 /**< unused socket */ | ||
174 | +#define Sn_MR_TCP 0x01 /**< TCP */ | ||
175 | +#define Sn_MR_UDP 0x02 /**< UDP */ | ||
176 | +#define Sn_MR_IPRAW 0x03 /**< IP LAYER RAW SOCK */ | ||
177 | +#define Sn_MR_MACRAW 0x04 /**< MAC LAYER RAW SOCK */ | ||
178 | +#define Sn_MR_PPPOE 0x05 /**< PPPoE */ | ||
179 | +#define Sn_MR_ND 0x20 /**< No Delayed Ack(TCP) flag */ | ||
180 | +#define Sn_MR_MULTI 0x80 /**< support multicating */ | ||
181 | + | ||
182 | + | ||
183 | +/* Sn_CR values */ | ||
184 | +#define Sn_CR_OPEN 0x01 /**< initialize or open socket */ | ||
185 | +#define Sn_CR_LISTEN 0x02 /**< wait connection request in tcp mode(Server mode) */ | ||
186 | +#define Sn_CR_CONNECT 0x04 /**< send connection request in tcp mode(Client mode) */ | ||
187 | +#define Sn_CR_DISCON 0x08 /**< send closing reqeuset in tcp mode */ | ||
188 | +#define Sn_CR_CLOSE 0x10 /**< close socket */ | ||
189 | +#define Sn_CR_SEND 0x20 /**< updata txbuf pointer, send data */ | ||
190 | +#define Sn_CR_SEND_MAC 0x21 /**< send data with MAC address, so without ARP process */ | ||
191 | +#define Sn_CR_SEND_KEEP 0x22 /**< send keep alive message */ | ||
192 | +#define Sn_CR_RECV 0x40 /**< update rxbuf pointer, recv data */ | ||
193 | + | ||
194 | +#ifdef __DEF_IINCHIP_PPP__ | ||
195 | + #define Sn_CR_PCON 0x23 | ||
196 | + #define Sn_CR_PDISCON 0x24 | ||
197 | + #define Sn_CR_PCR 0x25 | ||
198 | + #define Sn_CR_PCN 0x26 | ||
199 | + #define Sn_CR_PCJ 0x27 | ||
200 | +#endif | ||
201 | + | ||
202 | +/* Sn_IR values */ | ||
203 | +#ifdef __DEF_IINCHIP_PPP__ | ||
204 | + #define Sn_IR_PRECV 0x80 | ||
205 | + #define Sn_IR_PFAIL 0x40 | ||
206 | + #define Sn_IR_PNEXT 0x20 | ||
207 | +#endif | ||
208 | +#define Sn_IR_SEND_OK 0x10 /**< complete sending */ | ||
209 | +#define Sn_IR_TIMEOUT 0x08 /**< assert timeout */ | ||
210 | +#define Sn_IR_RECV 0x04 /**< receiving data */ | ||
211 | +#define Sn_IR_DISCON 0x02 /**< closed socket */ | ||
212 | +#define Sn_IR_CON 0x01 /**< established connection */ | ||
213 | + | ||
214 | +/* Sn_SR values */ | ||
215 | +#define SOCK_CLOSED 0x00 /**< closed */ | ||
216 | +#define SOCK_INIT 0x13 /**< init state */ | ||
217 | +#define SOCK_LISTEN 0x14 /**< listen state */ | ||
218 | +#define SOCK_SYNSENT 0x15 /**< connection state */ | ||
219 | +#define SOCK_SYNRECV 0x16 /**< connection state */ | ||
220 | +#define SOCK_ESTABLISHED 0x17 /**< success to connect */ | ||
221 | +#define SOCK_FIN_WAIT 0x18 /**< closing state */ | ||
222 | +#define SOCK_CLOSING 0x1A /**< closing state */ | ||
223 | +#define SOCK_TIME_WAIT 0x1B /**< closing state */ | ||
224 | +#define SOCK_CLOSE_WAIT 0x1C /**< closing state */ | ||
225 | +#define SOCK_LAST_ACK 0x1D /**< closing state */ | ||
226 | +#define SOCK_UDP 0x22 /**< udp socket */ | ||
227 | +#define SOCK_IPRAW 0x32 /**< ip raw mode socket */ | ||
228 | +#define SOCK_MACRAW 0x42 /**< mac raw mode socket */ | ||
229 | +#define SOCK_PPPOE 0x5F /**< pppoe socket */ | ||
230 | + | ||
231 | +/* IP PROTOCOL */ | ||
232 | +#define IPPROTO_IP 0 /**< Dummy for IP */ | ||
233 | +#define IPPROTO_ICMP 1 /**< Control message protocol */ | ||
234 | +#define IPPROTO_IGMP 2 /**< Internet group management protocol */ | ||
235 | +#define IPPROTO_GGP 3 /**< Gateway^2 (deprecated) */ | ||
236 | +#define IPPROTO_TCP 6 /**< TCP */ | ||
237 | +#define IPPROTO_PUP 12 /**< PUP */ | ||
238 | +#define IPPROTO_UDP 17 /**< UDP */ | ||
239 | +#define IPPROTO_IDP 22 /**< XNS idp */ | ||
240 | +#define IPPROTO_ND 77 /**< UNOFFICIAL net disk protocol */ | ||
241 | +#define IPPROTO_RAW 255 /**< Raw IP packet */ | ||
242 | + | ||
243 | + | ||
244 | +/********************************************************* | ||
245 | +* iinchip access function | ||
246 | +*********************************************************/ | ||
247 | +extern uint8 IINCHIP_READ(uint16 addr); | ||
248 | +extern uint8 IINCHIP_WRITE(uint16 addr,uint8 data); | ||
249 | +extern uint16 wiz_read_buf(uint16 addr, uint8* buf,uint16 len); | ||
250 | +extern uint16 wiz_write_buf(uint16 addr,uint8* buf,uint16 len); | ||
251 | + | ||
252 | +extern void iinchip_init(void); // reset iinchip | ||
253 | +extern void sysinit(uint8 tx_size, uint8 rx_size); // setting tx/rx buf size | ||
254 | +extern uint8 getISR(uint8 s); | ||
255 | +extern void putISR(uint8 s, uint8 val); | ||
256 | +extern uint16 getIINCHIP_RxMAX(uint8 s); | ||
257 | +extern uint16 getIINCHIP_TxMAX(uint8 s); | ||
258 | +extern uint16 getIINCHIP_RxMASK(uint8 s); | ||
259 | +extern uint16 getIINCHIP_TxMASK(uint8 s); | ||
260 | +extern uint16 getIINCHIP_RxBASE(uint8 s); | ||
261 | +extern uint16 getIINCHIP_TxBASE(uint8 s); | ||
262 | +extern void setGAR(uint8 * addr); // set gateway address | ||
263 | +extern void setSUBR(uint8 * addr); // set subnet mask address | ||
264 | +extern void setSHAR(uint8 * addr); // set local MAC address | ||
265 | +extern void setSIPR(uint8 * addr); // set local IP address | ||
266 | +extern void setRTR(uint16 timeout); // set retry duration for data transmission, connection, closing ... | ||
267 | +extern void setRCR(uint8 retry); // set retry count (above the value, assert timeout interrupt) | ||
268 | +extern void setIMR(uint8 mask); // set interrupt mask. | ||
269 | +extern void getGAR(uint8 * addr); | ||
270 | +extern void getSUBR(uint8 * addr); | ||
271 | +extern void getSHAR(uint8 * addr); | ||
272 | +extern void getSIPR(uint8 * addr); | ||
273 | +extern uint8 getIR( void ); | ||
274 | +extern void setSn_MSS(SOCKET s, uint16 Sn_MSSR0); // set maximum segment size | ||
275 | +extern void setSn_PROTO(SOCKET s, uint8 proto); // set IP Protocol value using IP-Raw mode | ||
276 | +extern uint8 getSn_IR(SOCKET s); // get socket interrupt status | ||
277 | +extern uint8 getSn_SR(SOCKET s); // get socket status | ||
278 | +extern uint16 getSn_TX_FSR(SOCKET s); // get socket TX free buf size | ||
279 | +extern uint16 getSn_RX_RSR(SOCKET s); // get socket RX recv buf size | ||
280 | +extern void setSn_DHAR(SOCKET s, uint8 * addr); | ||
281 | +extern void setSn_DIPR(SOCKET s, uint8 * addr); | ||
282 | +extern void setSn_DPORT(SOCKET s, uint8 * addr); | ||
283 | +extern void getSn_DHAR(SOCKET s, uint8 * addr); | ||
284 | +extern void getSn_DIPR(SOCKET s, uint8 * addr); | ||
285 | +extern void getSn_DPORT(SOCKET s, uint8 * addr); | ||
286 | +extern void setSn_TTL(SOCKET s, uint8 ttl); | ||
287 | +extern void setMR(uint8 val); | ||
288 | + | ||
289 | +#ifdef __DEF_IINCHIP_PPP__ | ||
290 | +extern uint8 pppinit(uint8 *id, uint8 idlen, uint8 *passwd, uint8 passwdlen); | ||
291 | +extern uint8 pppterm(uint8 *mac,uint8 *sessionid); | ||
292 | +#endif | ||
293 | + | ||
294 | +extern void send_data_processing(SOCKET s, uint8 *data, uint16 len); | ||
295 | +extern void recv_data_processing(SOCKET s, uint8 *data, uint16 len); | ||
296 | +extern void read_data(SOCKET s, vuint8 * src, vuint8 * dst, uint16 len); | ||
297 | +extern void write_data(SOCKET s, vuint8 * src, vuint8 * dst, uint16 len); | ||
298 | + | ||
299 | +#endif |