; isx_1_6_8.src
; Wing Poon, Chris Waters, Deon Roelofse . V1.6.8 . 1/9/01 . (C) Scenix, Inc.
; SX Ethernet TCP/IP Stack. Protocols implemented: ARP, DHCP, IP/ICMP, UDP, TCP,
; HTTP.
; ******************************************************************************
; NOTES: 1. Will work only on SX48/52 Production Release silicon!
; 2. If using SX-Key, you need SXKEY52.EXE V1.19 or greater. Pls go to
; line 150 for important information!
; 3. If using SX-ISD, you need SASM.EXE V1.45.5 and SXIDE.EXE V1.07.03 or
; greater. Pls go to line 150 for important information!
; 4. The schematics for the board that runs this code is available, pls
; contact sales@scenix.com .
; 5. There is a Java application program available to demonstrate the
; use of the UDP protocol to allow the user to control the iSX, pls
; contact sales@scenix.com . You'll need the Microsoft Java Virtual
; Machine Build 3240, or greater (installed by default with IE5).
; ******************************************************************************
; Program Memory Usage Summary (/w DHCP):
; Page | Usage
; -----------------------------
; 0: 000-0AF, 190-1F1 (53%)
; 1: 200-3FB (100%)
; 2: 400-5FD (100%)
; 3: 600-7FD (100%)
; 4: 800-96D (71%)
; 5: A00-B5B (68%)
; 6: C00-D38 (61%)
; 7: E00-E25 (7%)
; Data Memory Usage Summary (/w DHCP):
; Bank | Usage
; -----------------------------
; 0: - (0%)
; 1: 0-F (100%)
; 2: 0-E (94%)
; 3: 0-F (100%)
; 4: 0-F (100%)
; 5: 0-F (100%)
; 6: 0-A (73%)
; 7: 0-C (81%)
; 8: 0-A (73%)
; 9: - (0%)
; A: - (0%)
; B: - (0%)
; C: - (0%)
; D: - (0%)
; E: - (0%)
; F: - (0%)
; This program implements an embedded web-server. The server will respond to
; HTTP requests and surfs up the specified web resource stored on an external
; serial EEPROM. The IP address of the webserver is http://10.1.1.20, if
; the DHCP option is disabled (default). In addition, the iSX can be pinged
; ("ping 10.1.1.20") using the standard PC/Unix ping utility. Finally, the iSX
; can also be controlled, using UDP, by the user, using a Java program,
; udpsx.class, available from Scenix.
; How to Setup your PC to talk with the iSX Board
; -----------------------------------------------
; 1. Open a DOS Command Prompt Window
; 2. Type "route print"
; 3. If you see a line like the one below, skip step [4] and [5]
; Network Address Netmask Gateway Address Interface Metric
; 10.1.1.0 255.255.255.0 w.x.y.z w.x.y.z 1
; (in the above, "w.x.y.z" is any non-zero IP address)
; 4. Find out the IP address of the PC's Ethernet Interface. Type the following
; command: "ipconfig"
; Look for the line "IP Address. . .", given under a section called "Ethernet
; adapter :". This is the Ethernet IP address of the PC.
; The IP address must not be 0.0.0.0
; If you don't find a non-zero Ethernet IP address, follow the instructions
; Given in the section "How to give your PC a Static IP Address" and restart
; your computer.
; 5. Update the PC's routing table: Issue the following command:
; "route add 10.1.1.0 mask 255.255.255.0 <PC_ETHERNET_IP_ADDR>"
; Be sure to substitute the IP address found in step [4] for the field
; <PC_ETHERNET_IP_ADDR>
; 6. Power-up the iSX board and connect it to the PC using the supplied cross-
; over cable.
; 7. Ping the iSX to see if it the connection is alive: "ping 10.1.1.20"
; If you get a "Request timed out" message, the connection was unsucessful;
; try typing "arp -s 10.1.1.20 00-00-00-00-00-01 <PC_ETHERNET_IP_ADDR>" at the
; DOS prompt and try pinging the iSX again.
; If you get a "Reply from 10.1.1.20: ..." message, the connection is alive.
; 8. Start your web-browser (IE5 works best). Type in the following
; http://10.1.1.20
; 9. If you successfully pinged the iSX board in step [7] but failed to load the
; web page in step [8], do the following:
; In IE, go to Tools->Internet Options. Click on the "Use Blank" button, then
; hit "OK". Exit and restart IE.
; In Netscape, go to Edit->Preferences. Click on the "Blank Page" radio button,
; then hit "OK". Exit and restart Netscape.
; Repeat step [8].
;
; How to give your PC a Static IP Address (optional)
; --------------------------------------------------
; 1. Right-click on the "Network Neighborhood" icon on the Windows Desktop.
; Select Properties.
; 2. Select the "TCP/IP -> <YOUR_ETHERNET_ADAPTER>" entry from the scroll-box.
; Click the Properties button.
; 3. Click on the "IP Address" tab. Select "Specify an IP Address". Enter
; "10.1.1.1" for the "IP Address" (This will be the Ethernet IP address of
; the PC). Enter "255.255.255.0" for the "Subnet Mask". Click on OK and
; restart the computer.
; INCLUDE "SX52.inc"
; SX52.inc
;*********************************************************************************
; SX48BD/52BD Mode addresses
; *On SX48BD/52BD, most registers addressed via mode are read and write, with the
; exception of CMP and WKPND which do an exchange with W.
;*********************************************************************************
; Timer (read) addresses
TCPL_R = $00 ; Read Timer Capture register low byte
TCPH_R = $01 ; Read Timer Capture register high byte
TR2CML_R = $02 ; Read Timer R2 low byte
TR2CMH_R = $03 ; Read Timer R2 high byte
TR1CML_R = $04 ; Read Timer R1 low byte
TR1CMH_R = $05 ; Read Timer R1 high byte
TCNTB_R = $06 ; Read Timer control register B
TCNTA_R = $07 ; Read Timer control register A
; Exchange addresses
CMP = $08 ; Exchange Comparator enable/status register with W
WKPND = $09 ; Exchange MIWU/RB Interrupts pending with W
; Port setup (read) addresses
WKED_R = $0A ; Read MIWU/RB Interrupt edge setup, 0 = falling, 1 = rising
WKEN_R = $0B ; Read MIWU/RB Interrupt edge setup, 0 = enabled, 1 = disabled
ST_R = $0C ; Read Port Schmitt Trigger setup, 0 = enabled, 1 = disabled
LVL_R = $0D ; Read Port Level setup, 0 = CMOS, 1 = TTL
PLP_R = $0E ; Read Port Pull-up setup, 0 = enabled, 1 = disabled
DIR_R = $0F ; Read Port Direction
; Timer (write) addresses
TR2CML_W = $12 ; Write Timer R2 low byte
TR2CMH_W = $13 ; Write Timer R2 high byte
TR1CML_W = $14 ; Write Timer R1 low byte
TR1CMH_W = $15 ; Write Timer R1 high byte
TCNTB_W = $16 ; Write Timer control register B
TCNTA_W = $17 ; Write Timer control register A
; Port setup (write) addresses
WKED_W = $1A ; Write MIWU/RB Interrupt edge setup, 0 = falling, 1 = rising
WKEN_W = $1B ; Write MIWU/RB Interrupt edge setup, 0 = enabled, 1 = disabled
ST_W = $1C ; Write Port Schmitt Trigger setup, 0 = enabled, 1 = disabled
LVL_W = $1D ; Write Port Level setup, 0 = CMOS, 1 = TTL
PLP_W = $1E ; Write Port Pull-up setup, 0 = enabled, 1 = disabled
DIR_W = $1F ; Write Port Direction
;*********************************************************************************
; Setup and enable RTCC interrupt, WREG register, RTCC/WDT prescaler
;*********************************************************************************
RTCC_ON = %10000000 ; Enables RTCC at address $01 (RTW hi)
; WREG at address $01 (RTW lo) by default
RTCC_ID = %01000000 ; Disables RTCC edge interrupt (RTE_IE hi)
; RTCC edge interrupt (RTE_IE lo) enabled by default
RTCC_INC_EXT = %00100000 ; Sets RTCC increment on RTCC pin transition (RTS hi)
; RTCC increment on internal instruction (RTS lo) is defalut
RTCC_FE = %00010000 ; Sets RTCC to increment on falling edge (RTE_ES hi)
; RTCC to increment on rising edge (RTE_ES lo) is default
RTCC_PS_OFF = %00001000 ; Assigns prescaler to Watchdog (PSA hi)
PS_000 = %00000000 ; RTCC = 1:2, WDT = 1:1
PS_001 = %00000001 ; RTCC = 1:4, WDT = 1:2
PS_010 = %00000010 ; RTCC = 1:8, WDT = 1:4
PS_011 = %00000011 ; RTCC = 1:16, WDT = 1:8
PS_100 = %00000100 ; RTCC = 1:32, WDT = 1:16
PS_101 = %00000101 ; RTCC = 1:64, WDT = 1:32
PS_110 = %00000110 ; RTCC = 1:128, WDT = 1:64
PS_111 = %00000111 ; RTCC = 1:256, WDT = 1:128
; **************
; *** DEVICE ***
; **************
; Parallax -- uncomment the following 2 lines if, and only if, using Parallax's SX-Key
DEVICE OSCHS2, DRT60MS
FREQ 48_000_000 ; have to debug at freq != resonant freq
; SASM -- uncomment the following line if, and only if, using Advance Transdata's SX-ISD
; DEVICE SX52BD, OSCHS2, WDRT60
RESET Main
ID 'iSX_167'
; ***************************
; *** CONDITIONAL DEFINES ***
; ***************************
DHCP = 0 ; 1 = DHCP enabled, 0 = DHCP disabled
CREDENCE = 0 ; 1 = Credence board, 0 = Scenix board
; *****************
; *** VARIABLES ***
; *****************
; *** Global ***
GLOBAL_ORG = $0A
flags EQU GLOBAL_ORG+0 ; various flags used by TCP/IP stack
arpFlags EQU GLOBAL_ORG+1 ; ARP status flags
globTemp1 EQU GLOBAL_ORG+2 ; not preserved across any function
globTemp2 EQU GLOBAL_ORG+3 ; not preserved across any function
globTemp3 EQU GLOBAL_ORG+4 ; preserved across some functions
; *** Bank 0 ***
; (Don't use this bank -- it's bad for your mental health)
ORG $00
; *** Bank 1 ***
ORG $10
NIC_BANK = $
nicIOAddr DS 1 ; points to currently addressed register on NIC
nicNextPktPtr DS 1 ; points to next packet in NIC's rx queue
nicCurrPktPtr DS 1 ; points to current packet in NIC's rx queue
nicRemoteEth0 DS 1 ; ethernet addr used for outgoing packet, overwritten by incoming packet
nicRemoteEth1 DS 1 ; "
nicRemoteEth2 DS 1 ; "
nicRemoteEth3 DS 1 ; "
nicRemoteEth4 DS 1 ; "
nicRemoteEth5 DS 1 ; "
nicCopySrcMSB DS 1 ; used by NICBufferCopy()
nicCopySrcLSB DS 1 ; "
nicCopyDestMSB DS 1 ; "
nicCopyDestLSB DS 1 ; "
nicCopyLenMSB DS 1 ; "
nicCopyLenLSB DS 1 ; "
nicCopyTemp DS 1 ; "
; *** Bank 2 ***
ORG $20
IP_BANK = $ ; make sure IP_BANK[7] = NIC_BANK[7]
remoteIP3 DS 1 ; IP addr used for outgoing packet, overwritten by incoming packet
remoteIP2 DS 1 ; "
remoteIP1 DS 1 ; "
remoteIP0 DS 1 ; "
myIP3 DS 1 ; filter value for incoming IP packets, also used in outgoing packet
myIP2 DS 1 ; "
myIP1 DS 1 ; "
myIP0 DS 1 ; "
ipCheckSumMSB DS 1 ; IP <header_checksum>
ipCheckSumLSB DS 1 ; "
ipLengthMSB DS 1 ; IP <length>
ipLengthLSB DS 1 ; "
ipProtocol DS 1 ; IP <protocol>
ipIdentMSB DS 1 ; IP <identifier>, incremented each outgoing packet
ipIdentLSB DS 1 ; "
; *** Bank 3 ***
ORG $30
UDP_BANK = $ ; make sure UDP_BANK[7] = NIC_BANK[7]
udpRxSrcPortMSB DS 1
udpRxSrcPortLSB DS 1
udpRxDestPortMSB DS 1 ; filter value for incoming UDP packets
udpRxDestPortLSB DS 1 ; "
udpRxDataLenMSB DS 1 ; length of <data> field of incoming UDP packet
udpRxDataLenLSB DS 1 ; "
udpTxSrcPortMSB DS 1
udpTxSrcPortLSB DS 1
udpTxDestPortMSB DS 1
udpTxDestPortLSB DS 1
udpTxDataLenMSB DS 1 ; length of <data> field of outgoing UDP packet
udpTxDataLenLSB DS 1 ; "
DHCP_BANK = $
dhcpServerId3 DS 1 ; DHCP <server_identifier> = IP addr of DHCP server
dhcpServerId2 DS 1 ; "
dhcpServerId1 DS 1 ; "
dhcpServerId0 DS 1 ; "
; *** Bank 4 ***
ORG $40
TCP_BANK = $ ; make sure TCP_BANK[7] = NIC_BANK[7]
tcpState DS 1 ; state-machine state
tcpTmpSeq4 DS 1 ; TMP.SEQ. 1=LSB, 4=MSB
tcpTmpSeq3 DS 1 ; temporary information from the received packet
tcpTmpSeq2 DS 1
tcpTmpSeq1 DS 1
tcpTmpAck4 DS 1 ; TMP.ACK
tcpTmpAck3 DS 1 ; temporary information from the received packet
tcpTmpAck2 DS 1
tcpTmpAck1 DS 1
tcpUnAckMSB DS 1 ; number of unacknowledged bytes
tcpUnAckLSB DS 1 ; "
tcpRxFlags DS 1 ; copy of the received flags field
tcpCheckSumMSB DS 1
tcpCheckSumLSB DS 1
tcpLengthMSB DS 1
tcpLengthLSB DS 1
tcpTmpMSB = tcpTmpSeq4
tcpTmpLSB = tcpTmpSeq3
tcpAppTxBytesMSB = tcpUnAckMSB ; number of bytes app wants to transmit
tcpAppTxBytesLSB = tcpUnAckLSB ; "
tcpAppRxBytesMSB = tcpLengthMSB ; number of bytes app will be receiving
tcpAppRxBytesLSB = tcpLengthLSB ; "
; *** Bank 5 ***
ORG $50
TCB_BANK = $ ; make sure TCB_BANK[7] = NIC_BANK[7]
; The ordering of these variables is significant. It is the same as the TCP
; header. This simpifies the send-packet code
tcbLocalPortMSB DS 1 ; source port
tcbLocalPortLSB DS 1 ; "
tcbRemotePortMSB DS 1 ; destination port
tcbRemotePortLSB DS 1 ; "
tcbSndUna4 DS 1 ; SND.UNA: oldest unacknowledged byte
tcbSndUna3 DS 1 ; "
tcbSndUna2 DS 1 ; "
tcbSndUna1 DS 1 ; "
tcbRcvNxt4 DS 1 ; RCV.NXT: next byte to receive
tcbRcvNxt3 DS 1 ; "
tcbRcvNxt2 DS 1 ; "
tcbRcvNxt1 DS 1 ; "
tcbOffset DS 1 ; length of the TCP options
tcbFlags DS 1 ; flags field
tcbSendWinMSB DS 1 ; send window
tcbSendWinLSB DS 1 ; "
TCB_END = $
; *** Bank 6 ***
ORG $60
ARP_BANK = $ ; make sure ARP_BANK[7] = NIC_BANK[7]
host1IP3 DS 1 ; remote host1 IP address
host1IP2 DS 1 ; "
host1IP1 DS 1 ; "
host1IP0 DS 1 ; "
host1Eth0 DS 1 ; remote host1 Ethernet address
host1Eth1 DS 1 ; "
host1Eth2 DS 1 ; "
host1Eth3 DS 1 ; "
host1Eth4 DS 1 ; "
host1Eth5 DS 1 ; "
stPktTxBufStart DS 1 ; start address of stalled packet in NIC tx buffer
; *** Bank 7 ***
ORG $70
TIMER_BANK = $ ; make sure TIMER_BANK[7] = NIC_BANK[7]
baseTimer DS 1 ; lowest/common cog in timer chain
arpTimerMSB DS 1 ; ARP-timer count
arpTimerLSB DS 1 ; "
tcpTimerMSB DS 1 ; TCP-timer count
tcpTimerLSB DS 1 ; "
connTimerMSB DS 1 ; Connection-timer count
connTimerLSB DS 1 ; "
HTTP_BANK = $ ; make sure HTTP_BANK[7] = NIC_BANK[7]
httpParseState DS 1 ; state of the HTTP header parser
httpURIHash DS 1 ; hash of the current URI
EEPROM_BANK = $ ; make sure EEPROM_BANK[7] = NIC_BANK[7]
e2AddrMSB DS 1 ; address in EEPROM to start reading from
e2AddrLSB DS 1 ; "
e2FileLenMSB DS 1 ; length of the file being read
e2FileLenLSB DS 1 ; "
; *** Bank 8 ***
ORG $80
MISC_BANK = $
ledPort DS 1 ; records the state of the led port
bcd3 DS 3 ; buffer for binary-to-ascii conversion
pageCount DS 1 ; num times resource.htm page has been accessed
ADC_BANK = $ ; must be same bank as bcd3
adc DS 1 ; averaged ADC value
adcAcc DS 1
adcCount DS 1
adcMSB DS 1 ; for averaging 256 samples
adcLSB DS 1 ; "
adcSampleCount DS 1 ; count number of averaged samples
; *** Bank 9 ***
ORG $90
; *** Bank A ***
ORG $A0
; *** Bank B ***
ORG $B0
; *** Bank C ***
ORG $C0
; *** Bank D ***
ORG $D0
; *** Bank E ***
ORG $E0
; *** Bank F ***
ORG $F0
; ***************
; *** EQUATES ***
; ***************
INT_PERIOD = 145 ; RTCC interrupt periodicity (345kHz)
; change this if you're not clocking
; the SX at 50MHz
; *** Pin Definitions ***
IF CREDENCE
RA_DIR = %11110011
RA_OUT = %00000000
RA_LVL = %11111111
RA_PLP = %11111111
RB_DIR = %10000000
RB_OUT = %01100000
RB_LVL = %11111111
RB_PLP = %01111111
RC_DIR = %11111111
RC_OUT = %00000000
RC_LVL = %11111111
RC_PLP = %11111111
RD_DIR = %00000010
RD_OUT = %00000011
RD_LVL = %11111111
RD_PLP = %11111100
RE_DIR = %00000000
RE_OUT = %00000000
RE_LVL = %11111111
RE_PLP = %11111111
NIC_DATA_PORT = rc
NIC_CTRL_PORT = rb
IOWB_PIN = NIC_CTRL_PORT.5
IORB_PIN = NIC_CTRL_PORT.6
IOCH_PIN = NIC_CTRL_PORT.7
E2_PORT = rd
E2SCL = 0
E2SDA = 1
E2SCL_PIN = E2_PORT.E2SCL
E2SDA_PIN = E2_PORT.E2SDA
LED_PORT = re
LED = 0
LED_PIN = LED_PORT.LED
ELSE
RA_DIR = %10101010
RA_OUT = %01110101
RA_LVL = %11111111
RA_PLP = %01111111
RB_DIR = %10000000
RB_OUT = %01100000
RB_LVL = %11111111
RB_PLP = %01111111
RC_DIR = %11111111
RC_OUT = %00000000
RC_LVL = %11111111
RC_PLP = %11111111
RD_DIR = %11111111
RD_OUT = %00000000
RD_LVL = %11111111
RD_PLP = %00000000
RE_DIR = %01111111
RE_OUT = %00000000
RE_LVL = %00111111
RE_PLP = %11000000
NIC_DATA_PORT = rc
NIC_CTRL_PORT = rb
IOWB_PIN = NIC_CTRL_PORT.5
IORB_PIN = NIC_CTRL_PORT.6
IOCH_PIN = NIC_CTRL_PORT.7
E2_PORT = ra
E2SCL = 4
E2SDA = 5
E2SCL_PIN = E2_PORT.E2SCL
E2SDA_PIN = E2_PORT.E2SDA
LED_PORT = ra
LED = 6
LED_PIN = LED_PORT.LED
ENDIF
; *** flags ***
RX_IS_ARP = 0 ; incoming packet is an ARP packet
RX_IS_ICMP = 1 ; incoming packet is an ICMP packet
RX_IS_UDP = 2 ; incoming packet is a UDP packet
RX_IS_TCP = 3 ; incoming packet is a TCP packet
RX_IS_IP_BCST = 4 ; incoming packet is an IP Broadcast packet
GOT_DHCP_OFFER = 5 ; received DHCP IP address offer
GOT_IP_ADDR = 6 ; received an IP address assignment (recv'ed DHCP ACK)
IP_CHKSUM_LSB = 7 ; next byte to accumulate IP checksum is LSB
TCP_CHKSUM_LSB = 5 ; next byte to accumulate TCP checksum is LSB
; *** arpFlags ***
ARP_REQ_SENT = 0 ; indicates that an ARP request has been sent
ARP_RSP_RCVD = 1 ; indicates that an ARP response has been received
ARP_STL_TX = 2 ; indicates that the stalled packet is to be transmitted
ARP_BYPASS = 3 ; indicates that the outgoing packet should not be checked
; *** NIC Constants ***
RXBUF_START = $40 ; 4608 byte receive buffer (3 max-size packets)
RXBUF_END = $53 ; "
TXBUF1_START = $53 ; 1536 byte transmit buffer for ICMP/UDP
TXBUF2_START = $59 ; 1536 byte transmit buffer for TCP
TXBUF3_START = $5F ; 256 byte transmit buffer for ARP
; *** Ethernet Constants ***
SX_ETH_ADDR0 = 0 ; SX's Ethernet Phy MAC Address
SX_ETH_ADDR1 = 0 ; "
SX_ETH_ADDR2 = 0 ; "
SX_ETH_ADDR3 = 0 ; "
SX_ETH_ADDR4 = 0 ; "
SX_ETH_ADDR5 = 1 ; "
; *** ARP Constants ***
ARP_TIMEOUT = 5 ; ARP response timeout period. Must be smaller than other timeouts!
; *** IP Constants ***
SX_IP_ADDR3 = 10 ; SX's static IP address (if DHCP disabled)
SX_IP_ADDR2 = 1 ; "
SX_IP_ADDR1 = 1 ; "
SX_IP_ADDR0 = 20 ; "
IP_TTL = 32
; *** UDP Constants ***
UDP_RX_DEST_MSB = $04 ; user UDP RX Port: 1025
UDP_RX_DEST_LSB = $01 ; "
; *** TCP Constants ***
; TCP state-machine states (numbering order is signifcant)
TCP_ST_CLOSED = 0
TCP_ST_LISTEN = 1
TCP_ST_SYNSENT = 2
TCP_ST_SYNRCVED = 3
TCP_ST_ESTABED = 4
TCP_ST_FINWAIT1 = 5
TCP_ST_FINWAIT2 = 6
TCP_ST_CLOSEWAIT = 7
TCP_ST_CLOSING = 8
TCP_ST_LASTACK = 9
TCP_ST_TIMEWAIT = 10
; Bit positions in the TCP <flag> byte.
TCP_FLAG_ACK = 4
TCP_FLAG_PSH = 3
TCP_FLAG_RST = 2
TCP_FLAG_SYN = 1
TCP_FLAG_FIN = 0
; TCP Options
TCP_OPTION_END = 0
TCP_OPTION_NOP = 1
TCP_OPTION_MSS = 2 ; max segment size
TCP_HDR_LENGTH = 5 ; normal TCP header length.
TCP_OFFSET_MASK = $F0
TCP_WINDOW_SIZE = 1400 ; max # of data bytes we will accept
TCP_SEG_SIZE = 1400 ; max # of data bytes TCP will transmit per segment
TCP_RESTART_EXP = 8 ; TCP re-transmission timeout period
TCP_CONN_EXP = 80 ; TCP connection timeout period
; *** HTTP Constants ***
; States for parsing HTTP headers
HTTP_PORT_MSB = 0 ; port number for HTTP server.
HTTP_PORT_LSB = 80 ; "
HTTP_SEG_SIZE = 1400
URI1 = $81 ; hash of "resource.htm"
URI2 = $54 ; hash of "temperature.htm"
; *** EEPROM Constants ***
E2_CMD_RD = $A1 ; most-significant 7-bits is the I2C slave addr
E2_CMD_WR = $A0 ; most-significant 7-bits is the I2C slave addr
E2_SDA_MASK = (1 << E2SDA) ; a '1' in the SDA bit, '0' everywhere else
IF CREDENCE
E2_DDR_SDA_IN = (RD_DIR | E2_SDA_MASK) ; direction of SDA port when SDA is input
E2_DDR_SDA_OUT = (RD_DIR & (~E2_SDA_MASK)) ; direction of SDA port when SDA is output
ELSE
E2_DDR_SDA_IN = (RA_DIR | E2_SDA_MASK) ; direction of SDA port when SDA is input
E2_DDR_SDA_OUT = (RA_DIR & (~E2_SDA_MASK)) ; direction of SDA port when SDA is output
ENDIF
; *** ADC Constants ***
ADC_PORT = re
ADC_OUT = 7
ADC_IN = 6
ADC_OUT_PIN = ADC_PORT.ADC_OUT
ADC_IN_PIN = ADC_PORT.ADC_IN
; **************
; *** MACROS ***
; **************
_bank MACRO 1 ; sets FSR[7:4]
bank \1
IF \1 & %10000000 ; SX48BD and SX52BD (production release) BANK instruction
setb fsr.7 ; modifies FSR bits 4,5 and 6. FSR.7 needs to be set by software.
ELSE
clrb fsr.7
ENDIF
ENDM
_banky MACRO 1 ; set FSR[7] ~only~
IF \1 & %10000000 ; SX48BD and SX52BD (production release) bank instruction
setb fsr.7 ; modifies FSR bits 4,5 and 6. FSR.7 needs to be set by software.
ELSE
clrb fsr.7
ENDIF
ENDM
_mode MACRO 1
mov w, #\1 ; loads the M register correctly for the SX48BD and SX52BD
mov m, w
ENDM
_pc_check MACRO 0
IF ($ & $100)
ERROR 'ERROR!! ADD PC,W instruction at invalid addr'
ENDIF
ENDM
; ***********
; *** ISR ***
; ***********
ORG 0 ; Page0
ISR
Timer ; implement various SW timers
; lowest-common-denominator timer
_bank TIMER_BANK
incsz baseTimer
jmp :timerEnd
:tcpTimer ; TCP-timer (used for TCP re-transmission timeouts)
incsz tcpTimerLSB
jmp :connTimer
inc tcpTimerMSB
:connTimer ; Connection-timer (used for TCP connection timeouts)
incsz connTimerLSB
jmp :arpTimer
inc connTimerMSB
:arpTimer ; ARP-timer (used for ARP response timeouts)
incsz arpTimerLSB
jmp :timerEnd
inc arpTimerMSB
:timerEnd
ADCTempSensor ; SW A-to-D for measuring current board temperature to be then
; displayed on a dynamic web page
; ADC(out) = !ADC(in) (balancing the yin and the yang)
mov w, ADC_PORT
sb wreg.ADC_IN
setb ADC_OUT_PIN
snb wreg.ADC_IN
clrb ADC_OUT_PIN
; decision time
_bank ADC_BANK
sb wreg.ADC_OUT
incsz adcAcc
inc adcAcc
dec adcAcc
inc adcCount
jnz :adcTempSensorEnd
; accumulate for averaging (256 samples)
mov w, adcAcc
clr adcAcc
add adcLSB, w
snc
inc adcMSB
; check if averaging is done
incsz adcSampleCount
jmp :adcTempSensorEnd
; averaging done -- save results
mov adc, adcMSB ; divide by 256 (clever huh?)
clr adcMSB
clr adcLSB
:adcTempSensorEnd
LedBlinker ; blinks auxilliary LED, but don't intefere if E2 access in
; in progress because LED and E2 may share same port
_bank HTTP_BANK
test httpParseState
jnz :ledBlinkerEnd
bank TIMER_BANK
mov w, tcpTimerMSB
and w, #%00001111
jnz :ledHere
_bank MISC_BANK
movb LED_PORT.LED, /ledPort.LED
jmp :ledBlinkerEnd
:ledHere mov w, tcpTimerMSB
and w, #%00001111
xor w, #1
jnz :ledBlinkerEnd
_bank MISC_BANK
movb LED_PORT.LED, ledPort.LED
:ledBlinkerEnd
ISRExit mov w, #-INT_PERIOD
retiw
; ********************
; *** MAIN PROGRAM ***
; ********************
Init jmp _Init
ARPInit jmp _ARPInit
TCPIPInit jmp _TCPIPInit
E2Init jmp _E2Init
StartupDelay jmp _StartupDelay
Main
call @Init
; DHCP Dynamic IP Address solicitation
IF DHCP
; initialize UDP receive port for DHCP
_bank UDP_BANK
mov udpRxDestPortMSB, #0 ; DHCP(BOOTP) Client
mov udpRxDestPortLSB, #68 ;
; send DHCPDISCOVER message to find DHCP server(s)
call @DHCPDISCOVERSend
; wait for DHCPOFFER
:dhcpWaitOffer call @NICWaitRxFrame
call @CheckIPDatagram
jnb flags.RX_IS_UDP, :dhcpWaitOffer
call @UDPProcPktIn
sb flags.GOT_DHCP_OFFER
jmp :dhcpWaitOffer
; send DHCPREQUEST message
call @DHCPREQUESTSend
; wait for DHCPACK
:dhcpGotOffer call @NICWaitRxFrame
call @CheckIPDatagram
jnb flags.RX_IS_UDP, :dhcpGotOffer
call @UDPProcPktIn
sb flags.GOT_IP_ADDR
jmp :dhcpGotOffer
:dhcpGotAck ; hallelujah!
ENDIF
call @UDPAppInit
_bank MISC_BANK
clr pageCount ; clear page counter (dynamic data)
mov ledPort, LED_PORT
; main program loop
:mainLoop call @NICCheckRxFrame
jz :noRxFrame
call @NICWaitRxFrame ; no waiting cus we've already checked
call @ARPCheckIfIs ; check and process if ARP
jb flags.RX_IS_ARP, :mainLoop
call @CheckIPDatagram ; not ARP, check if IP
jb flags.RX_IS_ICMP, :icmp
jb flags.RX_IS_UDP, :udp
jb flags.RX_IS_TCP, :tcp
call @NICDumpRxFrame ; not something we recognize, so dump it
jmp :mainLoop
:icmp call @ICMPProcPktIn ; process incoming ICMP packet
jmp :mainLoop
:udp call @UDPProcPktIn ; process incoming UDP packet
jmp :mainLoop
:tcp call @TCPProcPktIn ; process incoming TCP packet
jmp :mainLoop
:noRxFrame call @ARPSendStPacket ; send ARP stalled packets if any
bank TCP_BANK
cje TCPState, #TCP_ST_CLOSED, :tcpClosed
cje TCPState, #TCP_ST_LISTEN, :tcpListen
bank TIMER_BANK
cjae connTimerMSB, #TCP_CONN_EXP, :resetTCP
sb arpFlags.ARP_REQ_SENT ; do not allow new tx if waiting for ARP response
call @TCPTransmit ; check if app has anything to transmit
jmp :mainLoop
:tcpClosed call @TCPAppInit
jmp :mainLoop
:tcpListen bank TIMER_BANK
clr connTimerMSB
jmp :mainLoop
:resetTCP ; reset hung TCP connection
bank TCP_BANK
clr tcpUnAckMSB
clr tcpUnAckLSB
mov tcpState, #TCP_ST_CLOSED
bank HTTP_BANK
clr httpParseState
jmp :mainLoop
; *******************
; *** SUBROUTINES ***
; *******************
ORG $190 ; Page0
; ******************************************************************************
_Init
; Main program initialization code
; INPUT: none
; OUTPUT: none
; ******************************************************************************
_mode LVL_W
mov !ra, #RA_LVL
mov !rb, #RB_LVL
mov !rc, #RC_LVL
mov !rd, #RD_LVL
mov !re, #RE_LVL
_mode PLP_W
mov !ra, #RA_PLP
mov !rb, #RB_PLP
mov !rc, #RC_PLP
mov !rd, #RD_PLP
mov !re, #RE_PLP
_mode DIR_W
mov !ra, #RA_DIR
mov !rb, #RB_DIR
mov !rc, #RC_DIR
mov !rd, #RD_DIR
mov !re, #RE_DIR
mov ra, #RA_OUT
mov rb, #RB_OUT
mov rc, #RC_OUT
mov rd, #RD_OUT
mov re, #RE_OUT
clr flags
call @NICInit
call @ARPInit
call @TCPIPInit
call @E2Init
mov w, #(RTCC_PS_OFF) ; setup option register
mov !option, w
retp
; ******************************************************************************
_ARPInit
; ARP initialization code
; INPUT: none
; OUTPUT: none
; ******************************************************************************
clr arpFlags
_bank ARP_BANK
clr host1IP0 ; clear the cache
clr host1IP1 ; "
clr host1IP2 ; "
clr host1IP3 ; "
retp
; ******************************************************************************
_TCPIPInit
; TCP/IP stack initialization code
; INPUT: none
; OUTPUT: none
; ******************************************************************************
_bank IP_BANK
IF DHCP
clr myIP3
clr myIP2
clr myIP1
clr myIP0
ELSE
; initialize SX's IP addr
setb flags.GOT_IP_ADDR
mov myIP3, #SX_IP_ADDR3
mov myIP2, #SX_IP_ADDR2
mov myIP1, #SX_IP_ADDR1
mov myIP0, #SX_IP_ADDR0
ENDIF
; initialize IP Identifier sequence number
clr ipIdentMSB
clr ipIdentLSB
; initialise the TCP variables
bank TCP_BANK
clr tcpUnAckMSB
clr tcpUnAckLSB
mov tcpState, #TCP_ST_CLOSED
retp
; ******************************************************************************
_E2Init
; EEPROM initialization code
; INPUT: none
; OUTPUT: none
; ******************************************************************************
; get the I2C device into a known state
call @E2SDAInput
:e2InitLoop clrb E2SCL_PIN
call @E2Delay1300ns
setb E2SCL_PIN
call @E2Delay900ns
jnb E2SDA_PIN, :e2InitLoop
retp
; ******************************************************************************
_StartupDelay
; Delay for ?ms @ 50MHz
; INPUT: none
; OUTPUT: none
; ******************************************************************************
mov globTemp2, #10
:loop3 clr globTemp1
:loop2 clr w
:loop1 decsz wreg
jmp :loop1
decsz globTemp1
jmp :loop2
decsz globTemp2
jmp :loop3
retp
ORG $200 ; Page1
NICSendTxFrame jmp _NICSendTxFrame
NICBufCopy jmp _NICBufCopy
NICBufWrite jmp _NICBufWrite
NICBufRead jmp _NICBufRead
NICBufIPAddrWr jmp _NICBufIPAddrWr
NICWriteSrcIP jmp _NICWriteSrcIP
NICWriteDestIP jmp _NICWriteDestIP
NICWriteSrcEth jmp _NICWriteSrcEth
NICWriteDestEth jmp _NICWriteDestEth
NICDMAInit jmp _NICDMAInit
; ******************************************************************************
NICInit
; Initializes and configures Realtek RTL8019AS NIC
; INPUT: none
; OUTPUT: none
; ******************************************************************************
_bank NIC_BANK
call @StartupDelay ; give it a little time to come out of POR
mov nicIOAddr, #$1F ; write to reset port
call NICWrite
call @StartupDelay ; give it a little time to reset
; --- Page3 Registers ---
clr nicIOAddr ; CR
mov w, #%11000001 ; Page3, Stop
call NICWrite
mov nicIOAddr, #$01 ; 9346CR
mov w, #%11000000 ; config register write enable
call NICWrite
mov nicIOAddr, #$05 ; CONFIG2
mov w, #%00000000 ; link test enable
call NICWrite
; --- Page1 Registers ---
clr nicIOAddr ; CR
mov w, #%01000001 ; Page1, Stop
call NICWrite
inc nicIOAddr ; ($01) PAR0
mov w, #SX_ETH_ADDR0
call NICWrite
inc nicIOAddr ; ($02) PAR1
mov w, #SX_ETH_ADDR1
call NICWrite
inc nicIOAddr ; ($03) PAR2
mov w, #SX_ETH_ADDR2
call NICWrite
inc nicIOAddr ; ($04) PAR3
mov w, #SX_ETH_ADDR3
call NICWrite
inc nicIOAddr ; ($05) PAR4
mov w, #SX_ETH_ADDR4
call NICWrite
inc nicIOAddr ; ($06) PAR5
mov w, #SX_ETH_ADDR5
call NICWrite
inc nicIOAddr ; ($07) CURR
mov w, #RXBUF_START
call NICWrite
; --- Page0 Registers ---
clr nicIOAddr ; CR
mov w, #%00000001 ; Page0, Stop
call NICWrite
inc nicIOAddr ; ($01) PSTART
mov w, #RXBUF_START
call NICWrite
inc nicIOAddr ; ($02) PSTOP
mov w, #RXBUF_END
call NICWrite
inc nicIOAddr ; ($03) BNRY
mov w, #RXBUF_START
call NICWrite
mov nicIOAddr, #$07 ; ISR
mov w, #$FF
call NICWrite
mov nicIOAddr, #$0C ; RCR
mov w, #%11000100
call NICWrite
inc nicIOAddr ; ($0D) TCR
mov w, #%11100000
call NICWrite
inc nicIOAddr ; ($0E) DCR
mov w, #%10111000
call NICWrite
clr nicIOAddr ; CR
mov w, #%00000010 ; Page0, Start
jmp NICWrite
; ******************************************************************************
NICWrite
; Does an I/O Write of a byte on the ISA host bus to the NIC
; INPUT: w = byte to be written
; nicIOAddr = I/O address (most-significant 3 bits must be zero)
; OUTPUT: none
; ******************************************************************************
bank NIC_BANK
; put data out on data bus
mov NIC_DATA_PORT, w
_mode DIR_W
mov w, #0 ; output
mov !NIC_DATA_PORT, w
; put addr out on addr bus
mov w, NIC_CTRL_PORT
and w, #%11100000
or w, nicIOAddr
mov NIC_CTRL_PORT, w
; strobe IOWB pin
jmp $+1
clrb IOWB_PIN
jmp $+1
jnb IOCH_PIN, $
setb IOWB_PIN
retp
; ******************************************************************************
NICWriteAgain
; Write to the same nicIOAddr as the previous call to NICWrite()
; INPUT: w = byte to be written
; OUTPUT: none
; ******************************************************************************
; put data out on data bus
mov NIC_DATA_PORT, w
; strobe IOWB pin
jmp $+1
clrb IOWB_PIN
jmp $+1
jnb IOCH_PIN, $
setb IOWB_PIN
retp
; ******************************************************************************
NICRead
; Does an I/O Read of a byte on the ISA host bus from the NIC
; INPUT: nicIOAddr = I/O address (most-significant 3 bits must be zero)
; OUTPUT: w = byte read
; ******************************************************************************
bank NIC_BANK
; configure data bus for input
_mode DIR_W
mov w, #$FF ; input
mov !NIC_DATA_PORT, w
; put addr out on addr bus
mov w, NIC_CTRL_PORT
and w, #%11100000
or w, nicIOAddr
mov NIC_CTRL_PORT, w
; strobe IORB pin and latch data
jmp $+1
clrb IORB_PIN
jmp $+1
jnb IOCH_PIN, $
mov w, NIC_DATA_PORT
setb IORB_PIN
retp
; ******************************************************************************
NICReadAgain
; Read the NIC using the same nicIOAddr as the previous call to NICRead()
; INPUT: none
; OUTPUT: w = byte read
; ******************************************************************************
; strobe IORB pin and latch data
jmp $+1
clrb IORB_PIN
jmp $+1
jnb IOCH_PIN, $
mov w, NIC_DATA_PORT
setb IORB_PIN
retp
; ******************************************************************************
NICPseudoRead
; 'Read' the NIC, but ignore data. Must have called NICRead() or NICReadAgain()
; priorly
; INPUT: none
; OUTPUT: none
; ******************************************************************************
; strobe IORB pin
jmp $+1
clrb IORB_PIN
jmp $+1
jnb IOCH_PIN, $
setb IORB_PIN
retp
; ******************************************************************************
NICPseudoRead6
; 'Read' the NIC (6) times, but ignore data. Must have called NICRead() or
; NICReadAgain() priorly
; INPUT: none
; OUTPUT: none
; ******************************************************************************
mov w, #6
:loop call NICPseudoRead
decsz wreg
jmp :loop
retp
; ******************************************************************************
NICCheckRxFrame
; Checks to see if an ethernet frame has been received
; INPUT: none
; OUTPUT: z is cleared if there's a frame waiting, otherwise z is set
; ******************************************************************************
_bank NIC_BANK
clr nicIOAddr ; CR
mov w, #%00100010 ; Page0, abort DMA
call NICWrite
mov nicIOAddr, #$07 ; ISR
call NICRead
;jb wreg.4, :overflowed ; OVW (bit set when rx buffer overflowed) DEBUG
jb wreg.4, @Main ; OVW (bit set when rx buffer overflowed)-> reset
clr nicIOAddr ; CR
mov w, #%01000010 ; Page1
call NICWrite
mov nicIOAddr, #$07 ; CURR
call NICRead
mov globTemp1, w
clr nicIOAddr ; CR
mov w, #%00000010 ; Page0
call NICWrite
mov nicIOAddr, #$03 ; BNRY
call NICRead
xor w, globTemp1 ; CURR = BNRY => no packets
retp
;:overflowed mov w, #(RTCC_ID) ; DEBUG
; mov !option, w ; DEBUG
; clrb LED_PIN ; DEBUG
; jmp $ ; DEBUG
; ******************************************************************************
NICWaitRxFrame
; Wait for an ethernet frame to be received.
; INPUT: none
; OUTPUT: nicCurrPktPtr = points to beginning of packet just received
; nicNextPktPtr = points to beginning of next packet
; nicRemoteEth0-5 = source (remote) ethernet address
; ******************************************************************************
_bank NIC_BANK
:loop clr nicIOAddr ; CR
mov w, #%01100010 ; Page1, abort DMA
call NICWrite
mov nicIOAddr, #$07 ; CURR
call NICRead
mov globTemp1, w
clr nicIOAddr ; CR
mov w, #%00000010 ; Page0
call NICWrite
mov nicIOAddr, #$03 ; BNRY
call NICRead
xor w, globTemp1
jz :loop ; CURR = BNRY => no packets
clr nicIOAddr ; CR
mov w, #%00011010 ; Page0, packet send
call NICWrite
; store current-packet pointer
mov nicIOAddr, #$03 ; BNRY
call NICRead
mov nicCurrPktPtr, w
mov nicIOAddr, #$10 ; RDMA
; ignore receive status
call NICRead
; store next-packet pointer
call NICReadAgain
mov nicNextPktPtr, w
; ignore ethernet frame size
call NICPseudoRead
call NICPseudoRead
; ignore the <destination> ethernet addr
call NICPseudoRead6
; record the sender's <source> ethernet addr
call NICReadAgain
mov nicRemoteEth0, w
call NICReadAgain
mov nicRemoteEth1, w
call NICReadAgain
mov nicRemoteEth2, w
call NICReadAgain
mov nicRemoteEth3, w
call NICReadAgain
mov nicRemoteEth4, w
call NICReadAgain
mov nicRemoteEth5, w
clr nicIOAddr ; CR
mov w, #%00100010 ; Page0, abort DMA
jmp NICWrite
; ******************************************************************************
NICDumpRxFrame
; Discard the current received frame by advancing the receive circular buffer
; tail pointer
; INPUT: nicNextPktPtr = next packet page
; OUTPUT: none
; ******************************************************************************
bank NIC_BANK
clr nicIOAddr ; CR
mov w, #%00100010 ; Page0, abort DMA
call NICWrite
mov nicIOAddr, #$03 ; BNRY
mov w, nicNextPktPtr ; advance tail pointer
jmp NICWrite
; ******************************************************************************
NICInitTxFrame
; i. initialize NIC for remote-DMA writes
; ii. fills in ethernet <destination> and <source>
; INPUT: w = starting page number of tx buffer
; nicRemoteEth0-5 = destination ethernet address
; OUTPUT: none
; ******************************************************************************
mov globTemp1, w
bank NIC_BANK
; wait for prior transmission to complete
clr nicIOAddr ; CR
:wait call NICRead
jb wreg.2, :wait
mov w, #%00100010 ; Page0, abort DMA
call NICWrite
mov nicIOAddr, #$04 ; TPSR
mov w, globTemp1
call NICWrite
mov nicIOAddr, #$08 ; RSAR0
mov w, #$00
call NICWrite
inc nicIOAddr ; ($09) RSAR1
mov w, globTemp1
call NICWrite
mov nicIOAddr, #$0A ; RBCR0
mov w, #$EA ; max ethernet packet size
call NICWrite
inc nicIOAddr ; ($0B) RBCR1
mov w, #$05
call NICWrite
clr nicIOAddr ; CR
mov w, #%00010010 ; Page0, remote write
call NICWrite
mov nicIOAddr, #$10 ; RDMA
; <destination>
call NICWriteDestEth
; <source>
jmp NICWriteSrcEth
; ******************************************************************************
_NICSendTxFrame
; Once the transmit buffer on the NIC is filled, call this to tell the NIC to
; start sending
; INPUT: {ipLengthMSB,ipLengthLSB} = length of IP frame to be transmitted
; OUTPUT: none
; ******************************************************************************
; sometimes we need to bypass ARP (e.g. broadcast IP addr)
jb arpFlags.ARP_BYPASS, :here
; otherwise we need to check if we know the MAC mapping for the IP addr
call @ARPCheckCache ; Start ARP
snb arpFlags.ARP_REQ_SENT ; Continue if an ARP request was not sent
; or if a stalled packet is to be sent
retp ; exit, ARP request was sent. packet to be stalled
:here bank NIC_BANK
clr nicIOAddr ; CR
mov w, #%00100010 ; Page0, abort DMA
call NICWrite
bank IP_BANK
mov w, #(64-6-6-2)
mov w, ipLengthLSB-w
jc :notRunt
mov w, #1
mov w, ipLengthMSB-w
jc :notRunt
bank NIC_BANK
mov nicIOAddr, #$05 ; TBCR0
mov w, #64 ; min ethernet frame size
call NICWrite
inc nicIOAddr ; ($06) TBCR1
mov w, #0
call NICWrite
jmp :transmit
:notRunt bank NIC_BANK
mov nicIOAddr, #$05 ; TBCR0
bank IP_BANK
mov w, #(6+6+2)
add w, ipLengthLSB
call NICWrite ; should not affect carry flag
inc nicIOAddr ; ($06) TBCR1
bank IP_BANK
mov w, ipLengthMSB
snc
inc wreg
call NICWrite
:transmit clr nicIOAddr ; CR
mov w, #%00000110 ; Page0, transmit
jmp NICWrite
; ******************************************************************************
_NICBufCopy
; Copy one part of the NIC's SRAM buffer to another part
; INPUT: {nicCopySrcMSB,nicCopySrcLSB} = source address in NIC's SRAM
; {nicCopyDestMSB,nicCopyDestLSB} = destination address in NIC's SRAM
; {nicCopyLenMSB,nicCopyLenLSB} = length of buffer to copy
; OUTPUT: none
; ******************************************************************************
bank NIC_BANK
clr nicIOAddr ; CR
mov w, #%00100010 ; Page0, abort DMA
call NICWrite
mov nicIOAddr, #$0B ; RBCR1
mov w, #0 ; MSB is always zero
call NICWrite
; initialize RDMA to get source byte
:loop clr nicIOAddr ; CR
mov w, #%00100010 ; Page0, abort DMA
call NICWrite
mov nicIOAddr, #$08 ; RSAR0
mov w, nicCopySrcLSB
call NICWrite
inc nicIOAddr ; ($09) RSAR1
mov w, nicCopySrcMSB
call NICWrite
mov nicIOAddr, #$0A ; RBCR0
mov w, #1 ; one-byte DMA
call NICWrite
clr nicIOAddr ; CR
mov w, #%00001010 ; Page0, remote read
call NICWrite
mov nicIOAddr, #$10 ; RDMA
call NICRead
mov nicCopyTemp, w ; store source byte temporarily
; initialize RDMA to write byte to destination
mov nicIOAddr, #$08 ; RSAR0
mov w, nicCopyDestLSB
call NICWrite
inc nicIOAddr ; ($09) RSAR1
mov w, nicCopyDestMSB
call NICWrite
inc nicIOAddr ; ($0A) RBCR0
mov w, #1 ; one-byte DMA
call NICWrite
clr nicIOAddr ; CR
mov w, #%00010010 ; Page0, remote write
call NICWrite
mov nicIOAddr, #$10 ; RDMA
mov w, nicCopyTemp
call NICWrite
; increment source and destination pointers
inc nicCopySrcLSB
snz
inc nicCopySrcMSB
inc nicCopyDestLSB
snz
inc nicCopyDestMSB
; check if source page pointer hit receive buffer ceiling
mov w, nicCopySrcMSB
xor w, #RXBUF_END
jnz :here
mov nicCopySrcMSB, #RXBUF_START
; loop as many times as there are bytes to copy
:here decsz nicCopyLenLSB
jmp :loop
test nicCopyLenMSB
snz
retp
dec nicCopyLenMSB
jmp :loop
; ******************************************************************************
_NICBufWrite
; Writes a byte to the SRAM buffer in the NIC
; INPUT: {nicCopySrcMSB,nicCopySrcLSB} = address in buffer memory to write to
; w = byte to write
; OUTPUT: none
; ******************************************************************************
bank NIC_BANK
mov nicCopyTemp, w
clr nicIOAddr ; CR
mov w, #%00100010 ; Page0, abort DMA
mov nicIOAddr, #$08 ; RSAR0
mov w, nicCopySrcLSB
call NICWrite
inc nicIOAddr ; ($09) RSAR1
mov w, nicCopySrcMSB
call NICWrite
inc nicIOAddr ; ($0A) RBCR0
mov w, #1 ; one-byte DMA
call NICWrite
inc nicIOAddr ; ($0B) RBCR1
mov w, #0 ; MSB is always zero
call NICWrite
clr nicIOAddr ; CR
mov w, #%00010010 ; Page0, remote write
call NICWrite
mov nicIOAddr, #$10 ; RDMA
mov w, nicCopyTemp
jmp NICWrite
; ******************************************************************************
_NICBufRead
; Reads a byte from the SRAM buffer in the NIC
; INPUT: {nicCopySrcMSB,nicCopySrcLSB} = address in buffer memory to read from
; OUTPUT: w = byte read
; ******************************************************************************
bank NIC_BANK
clr nicIOAddr ; CR
mov w, #%00100010 ; Page0, abort DMA
mov nicIOAddr, #$08 ; RSAR0
mov w, nicCopySrcLSB
call NICWrite
inc nicIOAddr ; ($09) RSAR1
mov w, nicCopySrcMSB
call NICWrite
inc nicIOAddr ; ($0A) RBCR0
mov w, #1 ; one-byte DMA
call NICWrite
inc nicIOAddr ; ($0B) RBCR1
mov w, #0 ; MSB is always zero
call NICWrite
clr nicIOAddr ; CR
mov w, #%00001010 ; Page0, remote read
call NICWrite
mov nicIOAddr, #$10 ; RDMA
jmp NICRead
; ******************************************************************************
_NICBufIPAddrWr
; Writes the source and destination IP addresses to the SRAM buffer in the NIC
; INPUT: {nicCopySrcMSB,nicCopySrcLSB} = address in buffer memory to write to
; myIP3-0 = <source_IP>
; remoteIP3-0 = <destination_IP>
; OUTPUT: none
; ******************************************************************************
bank NIC_BANK
clr nicIOAddr ; CR
mov w, #%00100010 ; Page0, abort DMA
mov nicIOAddr, #$08 ; RSAR0
mov w, nicCopySrcLSB
call NICWrite
inc nicIOAddr ; ($09) RSAR1
mov w, nicCopySrcMSB
call NICWrite
inc nicIOAddr ; ($0A) RBCR0
mov w, #(4+4) ; 8-byte DMA
call NICWrite
inc nicIOAddr ; ($0B) RBCR1
mov w, #0 ; MSB is always zero
call NICWrite
clr nicIOAddr ; CR
mov w, #%00010010 ; Page0, remote write
call NICWrite
mov nicIOAddr, #$10 ; RDMA
; <source_IP>
call NICWriteSrcIP
; <destination_IP>
jmp NICWriteDestIP
; ******************************************************************************
_NICWriteSrcIP
; Write Source IP address to NIC's buffer using remote DMA. NIC must be pre-
; initialized for this.
; INPUT: none
; OUTPUT: none
; ******************************************************************************
jnb flags.GOT_IP_ADDR, :noIP
bank IP_BANK
mov w, myIP3
call NICWrite
bank IP_BANK
mov w, myIP2
call NICWriteAgain
mov w, myIP1
call NICWriteAgain
mov w, myIP0
jmp NICWriteAgain
:noIP mov w, #0 ; 0.0.0.0
call NICWrite
mov w, #0
call NICWriteAgain
call NICWriteAgain
jmp NICWriteAgain
; ******************************************************************************
_NICWriteDestIP
; Write Destination IP address to NIC's buffer using remote DMA. NIC must be
; pre-initialized for this.
; INPUT: none
; OUTPUT: none
; ******************************************************************************
bank IP_BANK
mov w, remoteIP3
call NICWrite
bank IP_BANK
mov w, remoteIP2
call NICWriteAgain
bank IP_BANK
mov w, remoteIP1
call NICWriteAgain
bank IP_BANK
mov w, remoteIP0
jmp NICWriteAgain
; ******************************************************************************
_NICWriteSrcEth
; Write Source Ethernet address to NIC's buffer using remote DMA. NIC must be
; pre-initialized for this.
; INPUT: none
; OUTPUT: none
; ******************************************************************************
mov w, #SX_ETH_ADDR0
call NICWrite
mov w, #SX_ETH_ADDR1
call NICWriteAgain
mov w, #SX_ETH_ADDR2
call NICWriteAgain
mov w, #SX_ETH_ADDR3
call NICWriteAgain
mov w, #SX_ETH_ADDR4
call NICWriteAgain
mov w, #SX_ETH_ADDR5
jmp NICWriteAgain
; ******************************************************************************
_NICWriteDestEth
; Write Destination Ethernet address to NIC's buffer using remote DMA. NIC must
; be pre-initialized for this.
; INPUT: none
; OUTPUT: none
; ******************************************************************************
mov w, nicRemoteEth0
call NICWrite
mov w, nicRemoteEth1
call NICWriteAgain
mov w, nicRemoteEth2
call NICWriteAgain
mov w, nicRemoteEth3
call NICWriteAgain
mov w, nicRemoteEth4
call NICWriteAgain
mov w, nicRemoteEth5
jmp NICWriteAgain
; ******************************************************************************
_NICDMAInit
; Setup the NIC's RSAR and RBCR register in preparation for remote DMA.
; INPUT: nicCurrPktPtr = beginning of packet
; OUTPUT: none
; ******************************************************************************
bank NIC_BANK
clr nicIOAddr ; CR
mov w, #%00100010 ; Page0, abort DMA
call NICWrite
; initialize DMA to <type> field in ethernet frame
mov nicIOAddr, #$08 ; RSAR0
mov w, #(4+6+6) ; point to <type> field
call NICWrite
inc nicIOAddr ; ($09) RSAR1
mov w, nicCurrPktPtr
call NICWrite
inc nicIOAddr ; ($0A) RBCR0
mov w, #$FF
call NICWrite
inc nicIOAddr ; ($0B) RBCR1
mov w, #$0F
jmp NICWrite
ORG $400 ; Page2
ARPSendResponse jmp _ARPSendResponse
ARPSendStPacket jmp _ARPSendStPacket
CheckIPDatagram jmp _CheckIPDatagram
CheckIPDestAddr jmp _CheckIPDestAddr
ICMPProcPktIn jmp _ICMPProcPktIn
; ******************************************************************************
NICRead_2
; Shortform for calling NICRead(), which is in Page1 (This is in Page2)
; ******************************************************************************
jmp @NICRead
; ******************************************************************************
NICReadAgain_2
; Shortform for calling NICReadAgain(), which is in Page1 (This is in Page2)
; ******************************************************************************
jmp @NICReadAgain
; ******************************************************************************
NICPseudoRead_2
; Shortform for calling NICPseudoRead(), which is in Page1 (This is in Page2)
; ******************************************************************************
jmp @NICPseudoRead
; ******************************************************************************
NICPseudoRead6_2
; Shortform for calling NICPseudoRead(), which is in Page1 (This is in Page2)
; ******************************************************************************
jmp @NICPseudoRead6
; ******************************************************************************
NICWrite_2
; Shortform for calling NICWrite(), which is in Page1 (This is in Page2)
; ******************************************************************************
jmp @NICWrite
; ******************************************************************************
NICWriteAgain_2
; Shortform for calling NICWriteAgain(), which is in Page1 (This is in Page2)
; ******************************************************************************
jmp @NICWriteAgain
; ******************************************************************************
NICDumpRxFrame_2
; Shortform for calling NICDumpRxFrame(), which is in Page1 (This is in Page2)
; ******************************************************************************
jmp @NICDumpRxFrame
; ******************************************************************************
ARPCheckCache
; Checks if remote(destination) host IP address is in cache. If so, update
; packet Ethernet address in NIC with cache entry, else send ARP request.
; INPUT: remoteIP0-3, host1IP0-3
; OUTPUT: none
; ******************************************************************************
jnb arpFlags.ARP_STL_TX, :cacheGo ; do not check cache if stalled packet to be txed
call ARPUpdateEthAddr ; now update stalled packet's ethernet address
clr arpFlags ; reset ARP
retp
:cacheGo ; check if remote host IP is in cache
bank IP_BANK
mov w, remoteIP0
bank ARP_BANK
xor w, host1IP0
jnz :cacheNoMatch ; no match
mov w, host1IP1
bank IP_BANK
xor w, remoteIP1
jnz :cacheNoMatch ; no match
mov w, remoteIP2
bank ARP_BANK
xor w, host1IP2
jnz :cacheNoMatch ; no match
mov w, host1IP3
bank IP_BANK
xor w, remoteIP3
jz :cacheMatch ; match! remoteIP0-3 = host1IP0-3
:cacheNoMatch setb arpFlags.ARP_REQ_SENT ; indicate an ARP request is sent
jmp ARPSendRequest ; do an ARP request now to get the remote Eth address
:cacheMatch clr arpFlags ; reset ARP
jmp ARPUpdateEthAddr ; check, update remote Eth address of pending packet in NIC
; ******************************************************************************
ARPUpdateEthAddr
; Updates Eth Address of pending packet to be txed in NIC's buffer with that in
; ARP cache
; INPUT: host1Eth0-5, stPktTxBufStart
; OUTPUT: none
; ******************************************************************************
bank NIC_BANK
clr nicIOAddr ; CR
mov w, #%00100010 ; Page0, abort DMA
call NICWrite_2
mov nicIOAddr, #$08 ; RSAR0
mov w, #0
call NICWrite_2
inc nicIOAddr ; ($09) RSAR1
bank ARP_BANK
mov w, stPktTxBufStart ; stPktTxBufStart contains page number of stalled pkt
call NICWrite_2
inc nicIOAddr ; ($0A) RBCR0
mov w, #(6+6) ; 12-byte DMA
call NICWrite_2
inc nicIOAddr ; ($0B) RBCR1
mov w, #0 ; MSB is always zero
call NICWrite_2
clr nicIOAddr ; CR
mov w, #%00010010 ; Page0, remote write
call NICWrite_2
mov nicIOAddr, #$10 ; RDMA
; <destination_Eth>
bank ARP_BANK
mov w, host1Eth0
call NICWrite_2
bank ARP_BANK
mov w, host1Eth1
call NICWriteAgain_2
mov w, host1Eth2
call NICWriteAgain_2
mov w, host1Eth3
call NICWriteAgain_2
mov w, host1Eth4
call NICWriteAgain_2
mov w, host1Eth5
jmp NICWriteAgain_2
; ******************************************************************************
ARPCheckIfIs
; Checks received packet to see if it is ARP.
; Sends an ARP response if its a request.
; Updates cache if it's an ARP response.
; INPUT: nicCurrPktPtr = points to beginning of received packet
; OUTPUT: remoteIP0-3 (:rcvdARPRequest), host1Eth0-5 (:rcvdARPResponse)
; ******************************************************************************
clrb flags.RX_IS_ARP
call @NICDMAInit
clr nicIOAddr ; CR
mov w, #%00001010 ; Page0, remote read
call NICWrite_2
mov nicIOAddr, #$10 ; RDMA
; check if ethernet <type> field contains ARP identifier (0x0806)
call NICRead_2
xor w, #$08
jnz :outtaHere
call NICReadAgain_2
xor w, #$06
jnz :outtaHere
setb flags.RX_IS_ARP ; yes, it's ARP, indicate that for main loop
; ignore <hardware_type>,<protocol_type>,<HLEN>,<PLEN>
call NICPseudoRead6_2
; Checks if the ARP packet received is a request or a response
call NICReadAgain_2
xor w, #$00
jnz :outtaHere ; not ARP at all
call NICReadAgain_2
mov globTemp1, w ; store ARP opcode
xor w, #$01 ; check if ARP Request (0x0001)
jz :rcvdARPRequest ; yes, process ARP request
mov w, globTemp1
xor w, #$02 ; check if ARP Response (0x0002)
jz :rcvdARPResponse ; yes, process ARP response
jmp :outtaHere ; no, not ARP at all
:rcvdARPRequest
; ignore <sender_HA>
call NICPseudoRead6_2
; if a TCP connection has been established, check to see if remote
; IP is the one we've established connection with, otherwise, make
; sure {remoteIP3-0} isn't clobbered
bank TCP_BANK
cjne tcpState, #TCP_ST_ESTABED, :senderIP
; check <source_IP>
mov fsr, #remoteIP3
call ARPCompare4
jnz :outtaHere
jmp :targetHA
; record the sender's IP addr (<sender_IP>)
:senderIP bank IP_BANK
call NICReadAgain_2
mov remoteIP3, w
call NICReadAgain_2
mov remoteIP2, w
call NICReadAgain_2
mov remoteIP1, w
call NICReadAgain_2
mov remoteIP0, w
; ignore <target_HA>
:targetHA call NICPseudoRead6_2
; check if <target_IP> is me
mov fsr, #myIP3
call ARPCompare4
jnz :outtaHere
; so it's for me!
call ARPSendResponse
jmp NICDumpRxFrame_2 ; we're done with this packet, dump it
:rcvdARPResponse
; <sender_HA>
; record sender's Eth address in ARP cache
mov fsr, #host1Eth0
mov globTemp1, #6
:ethLoop call NICReadAgain_2
mov indf, w
inc fsr
decsz globTemp1
jmp :ethLoop
; <sender_IP>
; check if sender's IP corrresponds to IP address in ARP cache
mov fsr, #host1IP3
call ARPCompare4
jz :ipAddrResolved
; whoops, sender doesn't correspond to who we're trying to resolve!
; if we're waiting for an ARP response (no problem here)
jb arpFlags.ARP_REQ_SENT, :outtaHere
; otherwise, we need to invalidate the now corrupted ARP cache
clr host1IP3
clr host1IP1
clr host1IP2
clr host1IP0
jmp :outtaHere
:ipAddrResolved setb arpFlags.ARP_RSP_RCVD ; indicate we got a successfull ARP response
:outtaHere snb flags.RX_IS_ARP ; check if packet was ARP
call NICDumpRxFrame_2 ; if it was ARP, we dump it; otherwise, don't touch it
retp
; ******************************************************************************
ARPCompare4
; Compares data from NICReadAgain() against a 4-byte word store consequtively
; in the SX's data memory
; INPUT: fsr = points to beginning of 4-byte word to compare against
; OUTPUT: z: 1 = match, 0 = not match
; ******************************************************************************
mov globTemp1, #4
:loop call NICReadAgain_2
xor w, indf
sz
retp ; mis-match
inc fsr
decsz globTemp1
jmp :loop
stz
retp
; ******************************************************************************
ARPSendCommon1
; Helper function for ARPSendRequest and ARPSendResponse
; INPUT: none
; OUTPUT: none
; ******************************************************************************
; <type> = 0x0806
mov w, #$08
call NICWriteAgain_2
mov w, #$06
call NICWriteAgain_2
; <hardware_type> = 0x0001
mov w, #$00
call NICWriteAgain_2
mov w, #$01
call NICWriteAgain_2
; <protocol_type> = 0x0800
mov w, #$08
call NICWriteAgain_2
mov w, #$00
call NICWriteAgain_2
; <HLEN> = 0x06
mov w, #$06
call NICWriteAgain_2
; <PLEN> = 0x04
mov w, #$04
jmp NICWriteAgain_2
; ******************************************************************************
ARPSendCommon2
; Helper function for ARPSendRequest and ARPSendResponse
; INPUT: none
; OUTPUT: none
; ******************************************************************************
; <sender_HA>
call @NICWriteSrcEth
; <sender_IP>
call @NICWriteSrcIP
; <target_HA>
call @NICWriteDestEth
; <target_IP>
call @NICWriteDestIP
; whew! the ethernet frame is now complete, get ready to send ...
bank NIC_BANK ; NICWriteDestIP changes bank
clr nicIOAddr ; CR
mov w, #%00100010 ; Page0, abort DMA
call NICWrite_2
mov nicIOAddr, #$05 ; TBCR0
mov w, #$40 ; min ethernet packet size
call NICWrite_2
inc nicIOAddr ; ($06) TBCR1
mov w, #$00
call NICWrite_2
clr nicIOAddr ; CR
mov w, #%00000110 ; transmit
jmp NICWrite_2
; ******************************************************************************
ARPSendRequest
; Stores remote IP address for which pending packet is intended in ARP cache and
; sends an ARP Request
; INPUT: none
; OUTPUT: none
; ******************************************************************************
bank IP_BANK
mov w, remoteIP3 ; store IP address of target in ARP cache
bank ARP_BANK
mov host1IP3, w
bank IP_BANK
mov w, remoteIP2
bank ARP_BANK
mov host1IP2, w
bank IP_BANK
mov w, remoteIP1
bank ARP_BANK
mov host1IP1, w
bank IP_BANK
mov w, remoteIP0
bank ARP_BANK
mov host1IP0, w
bank NIC_BANK
mov w, #$FF
mov nicRemoteEth0, w ; setup broadcast Ethernet address
mov nicRemoteEth1, w
mov nicRemoteEth2, w
mov nicRemoteEth3, w
mov nicRemoteEth4, w
mov nicRemoteEth5, w
mov w, #TXBUF3_START ; point to ARP transmit buffer
call @NICInitTxFrame
call ARPSendCommon1
; <operation> = 0x0001 , ARP request opcode
mov w, #$00
call NICWriteAgain_2
mov w, #$01
call NICWriteAgain_2
call ARPSendCommon2
bank TIMER_BANK ; initialise the APR timeout timer
clr arpTimerMSB
clr arpTimerLSB
retp
; ******************************************************************************
_ARPSendResponse
; Send an ARP Response in reply to a ARP request.
; INPUT: none
; OUTPUT: none
; ******************************************************************************
mov w, #TXBUF3_START ; point to ARP transmit buffer
call @NICInitTxFrame
call ARPSendCommon1
; <operation> = 0x0002
mov w, #$00
call NICWriteAgain_2
mov w, #$02
call NICWriteAgain_2
jmp ARPSendCommon2
; ******************************************************************************
_ARPSendStPacket
; Sends the ARP stalled packet if any and also check if a timeout on waiting for
; an ARP response occured. If timeout, clear ARP cache
; INPUT: none
; OUTPUT: none
; ******************************************************************************
sb arpFlags.ARP_REQ_SENT ; check if we are waiting for an ARP response
retp ; no, nothing to do here
jnb arpFlags.ARP_RSP_RCVD, :checkARPTimeout ; if no ARP response rcvd, check if timeout
; yes we have rcvd a response so now we can send the stalled packet
clr arpFlags ; reset ARP
setb arpFlags.ARP_STL_TX ; indicate that stalled packet is to be transmitted
; re-initialize the NIC's TPSR
bank NIC_BANK
clr nicIOAddr ; CR
:wait call NICRead_2
jb wreg.2, :wait ; wait for prior transmission to complete
mov w, #%00100010 ; Page0, abort DMA
call NICWrite_2
mov nicIOAddr, #$04 ; TPSR
bank ARP_BANK
mov w, stPktTxBufStart ; load stalled packet's address pointer
call NICWrite_2
; read the NIC's transmit buffer to find out the IP <length>
; so that we can re-initialize the NIC's TBCR
bank ARP_BANK
mov w, stPktTxBufStart
bank NIC_BANK
mov nicCopySrcMSB, w
mov nicCopySrcLSB, #(6+6+2+2) ; IP <length> (MSB)
call @NICBufRead
bank IP_BANK
mov ipLengthMSB, w
bank NIC_BANK
inc nicCopySrcLSB ; IP <length> (LSB)
call @NICBufRead
bank IP_BANK
mov ipLengthLSB, w
jmp @NICSendTxFrame ; transmit the stalled ethernet frame
:checkARPTimeout
bank TIMER_BANK
csae arpTimerMSB, #ARP_TIMEOUT ; has the timer expired?
retp ; no, just return
clr arpFlags ; yes, reset ARP flags
; Very important now! Clear the ARP cache, since it acted as a temporary storage of the
; requested IP address. If we do not clear the cache now, the next re-transmit routine will
; find a match in the ARP cache since the original IP is still there!
bank ARP_BANK
clr host1IP3
clr host1IP2
clr host1IP1
clr host1IP0
retp
; ******************************************************************************
_CheckIPDatagram
; Checks to see if received ethernet frame contains an IP datagram. If not, the
; frame will be discarded since this stack doesn't deal with any other kinds of
; data-link layer protocol.
; INPUT: nicCurrPktPtr = points to beginning of received packet
; OUTPUT: none
; ******************************************************************************
mov w, #~((1<<RX_IS_ICMP)|(1<<RX_IS_UDP)|(1<<RX_IS_TCP)|(1<<RX_IS_IP_BCST))
and flags, w
call @NICDMAInit
clr nicIOAddr ; CR
mov w, #%00001010 ; Page0, remote read
call NICWrite_2
mov nicIOAddr, #$10 ; RDMA
; check if ethernet <type> field contains IP identifier (0x0800)
call NICRead_2
xor w, #$08
jnz :outtaHere
call NICReadAgain_2
xor w, #$00
jnz :outtaHere
; check <version> and <HLEN>
call NICReadAgain_2
xor w, #$45 ; version = 4, header length = 5
jnz :outtaHere
; ignore <service_type>
call NICPseudoRead_2
; record <total_length>
call NICReadAgain_2
bank IP_BANK
mov ipLengthMSB, w
call NICReadAgain_2
mov ipLengthLSB, w
; adjust {ipLengthMSB,ipLengthLSB} to reflect number of data bytes
sub ipLengthLSB, #20
sc
dec ipLengthMSB
; ignore <identification>
REPT 2
call NICPseudoRead_2
ENDR
; check against IP packet fragmentation
call NICReadAgain_2
jb wreg.5, :outtaHere ; <flags>
call NICReadAgain_2
xor w, #0 ; <fragment_offset>
jnz :outtaHere
; ignore <time_to_live>
call NICPseudoRead_2
; record <protocol>
call NICReadAgain_2
mov ipProtocol, w
; ignore <header_checksum>
REPT 2
call NICPseudoRead_2
ENDR
; if a TCP connection has been established, check to see if remote
; IP is the one we've established connection with, otherwise, make
; sure {remoteIP3-0} isn't clobbered
bank TCP_BANK
cjne tcpState, #TCP_ST_ESTABED, :srcIP
; check <source_IP>
bank IP_BANK
call NICReadAgain_2
xor w, remoteIP3
jnz :outtaHere
call NICReadAgain_2
xor w, remoteIP2
jnz :outtaHere
call NICReadAgain_2
xor w, remoteIP1
jnz :outtaHere
call NICReadAgain_2
xor w, remoteIP0
jnz :outtaHere
jmp :destIP
; record <source_IP>
:srcIP bank IP_BANK
call NICReadAgain_2
mov remoteIP3, w
call NICReadAgain_2
mov remoteIP2, w
call NICReadAgain_2
mov remoteIP1, w
call NICReadAgain_2
mov remoteIP0, w
; check <destination_IP>
:destIP clr globTemp2
mov w, myIP3
call CheckIPDestAddr
jnz :outtaHere
mov w, myIP2
call CheckIPDestAddr
jnz :outtaHere
mov w, myIP1
call CheckIPDestAddr
jnz :outtaHere
mov w, myIP0
call CheckIPDestAddr
jnz :outtaHere
xor globTemp2, #4
snz
setb flags.RX_IS_IP_BCST ; IP broadcast addr detected
; ok! determine which higher-level protocol
mov w, #1 ; ICMP
xor w, ipProtocol
snz
setb flags.RX_IS_ICMP
mov w, #17 ; UDP
xor w, ipProtocol
snz
setb flags.RX_IS_UDP
mov w, #6 ; TCP
xor w, ipProtocol
snz
setb flags.RX_IS_TCP
retp
:outtaHere jmp NICDumpRxFrame_2 ; if it ain't IP, forget it!
; ******************************************************************************
_CheckIPDestAddr
; Helper function for CheckIPDatagram
; Check for a match of the IP <destination_IP> field
; INPUT: w = byte of IP to check against
; OUTPUT: z = set if match
; globTemp2 = incremented if matched against 0xFF
; ******************************************************************************
mov globTemp1, w
call NICReadAgain_2
xor globTemp1, w
snz
retp
xor w, #$FF ; IP broadcast addr
sz
retp
inc globTemp2
stz
retp
; ******************************************************************************
_ICMPProcPktIn
; Process ICMP message. Only Echo Request ICMP messages are handled. All others
; are ignored. If Echo Request message is detected, this will generate the echo
; reply.
; INPUT: nicCurrPktPtr = points to beginning of received packet
; OUTPUT: none
; ******************************************************************************
; check <type>
call NICReadAgain_2
xor w, #$08 ; echo-request
jnz :outtaHere
bank IP_BANK
add ipLengthLSB, #(2+20)
snc
inc ipLengthMSB
bank NIC_BANK
mov nicCopySrcMSB, nicCurrPktPtr ; point to receive buffer
mov nicCopySrcLSB, #(4+6+6) ; don't copy NIC header, eth src & destn
mov nicCopyDestMSB, #TXBUF1_START ; point to transmit buffer
mov nicCopyDestLSB, #(6+6)
bank IP_BANK
mov w, ipLengthMSB
bank NIC_BANK
mov nicCopyLenMSB, w
bank IP_BANK
mov w, ipLengthLSB
bank NIC_BANK
mov nicCopyLenLSB, w
mov w, #TXBUF1_START ; point to transmit buffer
bank ARP_BANK
mov stPktTxBufStart ,w ; Store ICMP packet start address
bank NIC_BANK
call @NICInitTxFrame
call @NICBufCopy
; change ICMP <type> to echo reply (0)
mov nicCopySrcMSB, #TXBUF1_START ; point to transmit buffer
mov nicCopySrcLSB, #(6+6+2+20) ; point to ICMP <type>
mov w, #$00
call @NICBufWrite
; generate ICMP <checksum>
mov nicCopySrcMSB, #TXBUF1_START ; point to transmit buffer
bank IP_BANK
mov w, ipLengthMSB
bank NIC_BANK
mov nicCopyLenMSB, w
bank IP_BANK
mov w, ipLengthLSB
bank NIC_BANK
mov nicCopyLenLSB, w
sub nicCopyLenLSB, #(2+20+4)
sc
dec nicCopyLenMSB
call @ICMPGenCheckSum
; adjust IP <source_IP> and <destination_IP>
mov nicCopySrcMSB, #TXBUF1_START ; point to transmit buffer
mov nicCopySrcLSB, #(6+6+2+12) ; point to IP <source_IP>
call @NICBufIPAddrWr
bank IP_BANK
sub ipLengthLSB, #2
sc
dec ipLengthMSB
call @NICSendTxFrame
:outtaHere jmp NICDumpRxFrame_2
ORG $600 ; Page3
TCPTransmit jmp _TCPTransmit
TCPReTransmit jmp _TCPReTransmit
TCPAppPassiveOpen jmp _TCPAppPassiveOpen
TCPAppActiveOpen jmp _TCPAppActiveOpen
TCPAppClose jmp _TCPAppClose
; ******************************************************************************
NICWrite_3
; Shortform for calling NICWrite(), which is in Page1 (This is in Page3)
; ******************************************************************************
jmp @NICWrite
; ******************************************************************************
NICWriteAgain_3
; Shortform for calling NICWriteAgain(), which is in Page1 (This is in Page3)
; ******************************************************************************
jmp @NICWriteAgain
; ******************************************************************************
NICDumpRxFrame_3
; Shortform for calling NICWriteAgain(), which is in Page1 (This is in Page3)
; ******************************************************************************
jmp @NICDumpRxFrame
; ******************************************************************************
ICMPGenCheckSum
; Goes through the ICMP message stored in the NIC's SRAM buffer and computes
; the ICMP message checksum.
; INPUT: nicCopySrcMSB = transmit buffer page
; {nicCopyLenMSB,nicCopyLenLSB} = (length of ICMP message - 4)
; OUTPUT: {ipCheckSumMSB,ipCheckSumLSB} = new checksum value
; ******************************************************************************
call IPCheckSumInit
bank NIC_BANK
mov nicCopyTemp, nicCopySrcMSB
clr nicIOAddr ; CR
mov w, #%00100010 ; Page0, abort DMA
mov nicIOAddr, #$08 ; RSAR0
mov w, #(6+6+2+20+4) ; point to ICMP <identifier>
call NICWrite_3
inc nicIOAddr ; ($09) RSAR1
mov w, nicCopySrcMSB
call NICWrite_3
inc nicIOAddr ; ($0A) RBCR0
mov w, nicCopyLenLSB
call NICWrite_3
inc nicIOAddr ; ($0B) RBCR1
mov w, nicCopyLenMSB
call NICWrite_3
clr nicIOAddr ; CR
mov w, #%00001010 ; Page0, remote read
call NICWrite_3
mov nicIOAddr, #$10 ; RDMA
; configure data bus for input
_mode DIR_W
mov w, #$FF ; input
mov !NIC_DATA_PORT, w
; put addr out on addr bus
mov w, NIC_CTRL_PORT
and w, #%11100000
or w, nicIOAddr
mov NIC_CTRL_PORT, w
inc nicCopyLenMSB ; in order to loop easier later
:loop call @NICReadAgain
call IPCheckSumAcc
bank NIC_BANK
decsz nicCopyLenLSB
jmp :loop
decsz nicCopyLenMSB
jmp :loop
mov nicCopySrcMSB, nicCopyTemp
mov nicCopySrcLSB, #(6+6+2+20+2)
bank IP_BANK
mov w, /ipCheckSumMSB
call @NICBufWrite
inc nicCopySrcLSB
bank IP_BANK
mov w, /ipCheckSumLSB
call @NICBufWrite
retp
; ******************************************************************************
IPCheckSumInit
; Initializes the IP checksum routine.
; INPUT: none
; OUTPUT: none
; ******************************************************************************
bank IP_BANK
clr ipCheckSumMSB
clr ipCheckSumLSB
clrb flags.IP_CHKSUM_LSB ; next byte is MSB
retp
; ******************************************************************************
IPCheckSumAcc
; Accumulate the IP checksum value by adding the next 16-bit number
; IP header checksum (also used to compute ICMP checksum) is computed by doing
; the one's complement of the one's complement sum of the 16-bit numbers in the
; header.
; INPUT: w = byte to accumulate
; flags.IP_CHKSUM_LSB = set if processing LSB, clear if processing MSB
; OUTPUT: {ipCheckSumMSB,ipCheckSumLSB} = new checksum value
; ******************************************************************************
bank IP_BANK
jnb flags.IP_CHKSUM_LSB, :msb ; are we processing an MSB?
:lsb add ipCheckSumLSB, w ; add it to the checksum
sc ; was there a carry?
jmp :done
inc ipCheckSumMSB ; yes
snz
inc ipCheckSumLSB
jmp :done
:msb add ipCheckSumMSB, w ; add it to the checksum
sc ; was there a carry?
jmp :done
inc ipCheckSumLSB ; yes, this time it is added to the LSB
snz
inc ipCheckSumMSB
:done xor flags, #(1<<IP_CHKSUM_LSB)
retp
; ******************************************************************************
IPGenCheckSum
; Generate the IP header checksum
; INPUT: {ipLengthMSB,ipLengthLSB} = IP <total_length>
; {ipIdentMSB,ipIdentLSB} = IP <identification>
; ipProtocol = 1(ICMP)/ 6(TCP)/ 17(UDP)
; OUTPUT: {ipCheckSumMSB,ipCheckSumLSB} = new checksum value
; ******************************************************************************
bank IP_BANK
call IPCheckSumInit
mov w, #$45 ; Version 4, 5x 32 bit words in IP header
call IPCheckSumAcc
mov w, #$00
call IPCheckSumAcc
mov w, ipLengthMSB
call IPCheckSumAcc
mov w, ipLengthLSB
call IPCheckSumAcc
mov w, ipIdentMSB
call IPCheckSumAcc
mov w, ipIdentLSB
call IPCheckSumAcc
mov w, #%01000000 ; Don't fragment
call IPCheckSumAcc
mov w, #0
call IPCheckSumAcc
mov w, #IP_TTL
call IPCheckSumAcc
mov w, ipProtocol
call IPCheckSumAcc
jnb flags.GOT_IP_ADDR, :remoteIP ; IP = 0.0.0.0 if no IP
mov w, myIP3
call IPCheckSumAcc
mov w, myIP2
call IPCheckSumAcc
mov w, myIP1
call IPCheckSumAcc
mov w, myIP0
call IPCheckSumAcc
:remoteIP mov w, remoteIP3
call IPCheckSumAcc
mov w, remoteIP2
call IPCheckSumAcc
mov w, remoteIP1
call IPCheckSumAcc
mov w, remoteIP0
call IPCheckSumAcc
retp
; ******************************************************************************
IPStartPktOut
; Starts an outgoing IP packet by constructing the IP packet header
; INPUT: {ipLengthMSB,ipLengthLSB} = IP <total_length>
; {ipIdentMSB,ipIdentLSB} = IP <identification>
; ipProtocol = 1(ICMP)/ 6(TCP)/ 17(UDP)
; {ipCheckSumMSB,ipCheckSumLSB} = IP <header_checksum>
; OUTPUT: none
; ******************************************************************************
bank IP_BANK
mov w, #6 ; TCP protocol
xor w, ipProtocol
sz
mov w, #TXBUF1_START ; default tx buffer is TXBUF1
snz
mov w, #TXBUF2_START ; unless it's TCP, then we use TXBUF2
bank ARP_BANK
sb arpFlags.ARP_REQ_SENT ; check if a prev packet is stalled
mov stPktTxBufStart, w ; no, store new address pointer to new packet
call @NICInitTxFrame
; <type> = 0x0800
mov w, #$08
call NICWrite_3
mov w, #$00
call NICWriteAgain_3
; <version> = 4, <HLEN> = 5
mov w, #$45
call NICWriteAgain_3
; <service_type>
mov w, #$00 ; normal precedence, D=T=R=0
call NICWriteAgain_3
; <total_length>
bank IP_BANK
mov w, ipLengthMSB
call NICWriteAgain_3
mov w, ipLengthLSB
call NICWriteAgain_3
; <identification>
mov w, ipIdentMSB
call NICWriteAgain_3
mov w, ipIdentLSB
call NICWriteAgain_3
; <flags>, <fragment_offset>
mov w, #%01000000 ; do not fragment
call NICWriteAgain_3
mov w, #0 ; offset = 0
call NICWriteAgain_3
; <time_to_live>
mov w, #IP_TTL
call NICWriteAgain_3
; <protocol>
mov w, ipProtocol
call NICWriteAgain_3
; <header_checksum>
mov w, /ipCheckSumMSB
call NICWriteAgain_3
mov w, /ipCheckSumLSB
call NICWriteAgain_3
; <source_IP>
call @NICWriteSrcIP
; <destination_IP>
call @NICWriteDestIP
retp
; ******************************************************************************
TCPProcPktIn
; Process a received TCP packet. This function implements the TCP state machine
; INPUT: none
; OUTPUT: none
; ******************************************************************************
call @TCPRxHeader ; receive the header
snz ; is the packet OK?
retp ; no, return
; check the special states
bank TCP_BANK
cje tcpState, #TCP_ST_CLOSED, :CLOSED
cje tcpState, #TCP_ST_LISTEN, :LISTEN
cje tcpState, #TCP_ST_SYNSENT, :SYNSENT
cje tcpState, #TCP_ST_FINWAIT1, :FINWAIT1
cje tcpState, #TCP_ST_FINWAIT2, :FINWAIT2
cje tcpState, #TCP_ST_LASTACK, :LASTACK
; check the flags
bank TCB_BANK
snb tcbFlags.TCP_FLAG_RST ; is the reset flag set?
jmp :gotoClosed ; yes, drop packet and close the connection
snb tcbFlags.TCP_FLAG_SYN ; is the SYN bit set?
jmp @TCPSendReset ; yes, drop the packet and send a reset
sb tcbFlags.TCP_FLAG_ACK ; is the ACK bit set?
jmp NICDumpRxFrame_3 ; no, drop the packet
call @TCPChkSeq ; check if received packet is expected
; we only accept ACKs of complete packets. Assume the ACK is for our last packet
bank TCP_BANK
mov tcpState, #TCP_ST_ESTABED ; switch to the established state
:noOutstanding ; does the packet contain data? (Determine this from the length)
test tcpLengthMSB
jnz :packetHasData ; MSB is not zero
test tcpLengthLSB ; MSB is zero
jz :noData ; MSB = LSB = 0
:packetHasData call @TCPAppRxBytes ; inform app how many bytes available
_bank TCP_BANK
inc tcpLengthMSB
:processData call @NICReadAgain ; receive a byte
call @TCPAppRxData ; pass the byte to the application
_bank TCP_BANK ; _bank cus we called TCPAppRxData priorly
decsz tcpLengthLSB
jmp :processData
decsz tcpLengthMSB
jmp :processData
inc tcpLengthLSB ; indicate for later there was data received
:noData call @TCPAckUpdate
; send an ACK packet
bank TCP_BANK
test tcpLengthLSB ; was data received?
jz :checkFIN ; no, it was an ACK packet. Just return
call @TCPAppRxDone ; indicate the packet was OK to the application
_bank TCP_BANK ; _bank cus we called TCPAppRxDone priorly
jb tcpRxFlags.TCP_FLAG_FIN, :doClose ; if FIN bit set, close the connection
jmp @TCPSendAck
:checkFIN bank TCP_BANK
jb tcpRxFlags.TCP_FLAG_FIN, :doClose; is the FIN bit set?
jmp NICDumpRxFrame_3
:doClose call @TCPIncRcvNxt ; ACK the FIN
bank TCP_BANK
mov tcpState, #TCP_ST_CLOSEWAIT ; change state
jmp @TCPSendAck
:gotoClosed bank TCP_BANK
mov tcpState, #TCP_ST_CLOSED ; go to the closed state
jmp NICDumpRxFrame_3 ; discard received packet
:FINWAIT1 call NICDumpRxFrame_3
bank TCP_BANK
sb tcpRxFlags.TCP_FLAG_ACK ; check for ACK of FIN
retp
mov tcpState, #TCP_ST_FINWAIT2 ; rcved ACK of FIN
retp
:FINWAIT2 call NICDumpRxFrame_3
bank TCP_BANK
sb tcpRxFlags.TCP_FLAG_FIN ; check for FIN
retp
mov tcpState, #TCP_ST_CLOSED ; rcved FIN
call @TCPIncRcvNxt ; ACK the FIN
jmp @TCPSendAck
:LASTACK ; ignore the packet
; should check the packet is actually an ACK
mov tcpState, #TCP_ST_CLOSED ; go to the closed state
jmp NICDumpRxFrame_3
:CLOSED jmp @TCPSendReset ; we shouldn't receive packets while closed
:LISTEN call NICDumpRxFrame_3 ; discard received packet
bank TCB_BANK
snb tcbFlags.TCP_FLAG_RST ; check for an RST
retp ; ignore a packet with RST
snb tcbFlags.TCP_FLAG_ACK ; check for an ACK
jmp @TCPSendReset ; bad ACK, send a RST
call @TCPCopySeqToNxt
call @TCPSendSynAck
bank TCP_BANK
mov tcpState, #TCP_ST_SYNRCVED ; change state
retp
:SYNSENT call NICDumpRxFrame_3
bank TCB_BANK
jb tcbFlags.TCP_FLAG_RST, :rst ; is the reset bit set?
sb tcbFlags.TCP_FLAG_SYN ; if SYN bit not set,
retp ; ignore packet
sb tcbFlags.TCP_FLAG_ACK ; if ACK bit not set,
retp ; ignore packet
; check that SND.UNA <= SEG.ACK <= SND.NXT
bank TCP_BANK
mov tcpState, #TCP_ST_ESTABED ; the connection is now estabished
bank IP_BANK
clr ipLengthMSB ; set the received data length to one
mov ipLengthLSB, #1 ; "
call @TCPAckUpdate
jmp @TCPSendAck
:rst bank TCP_BANK
mov tcpState, #TCP_ST_CLOSED ; close the TCP
retp
; ******************************************************************************
_TCPTransmit
; See if the application has any data to transmit. If there are no outstanding
; packets and the application has data, then transmit a packet.
; INPUT: none
; OUTPUT: none
; ******************************************************************************
_bank TCP_BANK ; _bank cus we called TCPAppInit priorly
cje tcpState, #TCP_ST_SYNSENT, :timeout ; check for SYN timeout
cje tcpState, #TCP_ST_CLOSEWAIT, :closeWait
cjae tcpState, #TCP_ST_ESTABED, :ok
retp
:ok test tcpUnAckMSB ; are there any bytes unacknowledged?
jnz :timeout
test tcpUnAckLSB
jnz :timeout
cje tcpState, #TCP_ST_FINWAIT1, :finTimeout ; check for FIN timeout
:askAppTxData cse tcpState, #TCP_ST_ESTABED
retp ; only ask if connection is established
call @TCPAppTxBytes ; no, ask the application if it wants to transmit
_bank TCP_BANK ; _bank cus we called TCPAppTxBytes priorly
mov w, tcpUnAckMSB
or w, tcpUnAckLSB
jnz :appHasTxData
retp ; nope, it doesn't; so we're done here then
:appHasTxData ; start a TCP packet
mov tcpLengthLSB, tcpUnAckLSB ; tcpLength = # bytes to transmit
mov tcpLengthMSB, tcpUnAckMSB
bank TCB_BANK
mov tcbFlags, #((1<<TCP_FLAG_PSH)|(1<<TCP_FLAG_ACK))
call @TCPCheckSumInit
call @TCPStartPktOut ; send the header
call @TCPUpdateSeq ; Update the outgoing sequence no
; insert the packet data while computing the checksum over the data
bank TCP_BANK
mov tcpTmpLSB, tcpUnAckLSB
mov tcpTmpMSB, tcpUnAckMSB
inc tcpTmpMSB ; so that we can loop easier later
:dataLoop call @TCPAppTxData
_banky TCP_BANK ; cus we called TCPAppTxData priorly
call NICWriteAgain_3 ; which doesn't clobber w, which is nice
call @TCPCheckSumAcc ; accumulate the checksum
decsz tcpTmpLSB
jmp :dataLoop
decsz tcpTmpMSB
jmp :dataLoop
; now go back and fill in the TCP checksum
bank NIC_BANK
mov nicCopySrcMSB, #TXBUF2_START
mov nicCopySrcLSB, #(6+6+2+20+16) ; TCP <checksum> (MSB)
bank TCP_BANK
mov w, /tcpCheckSumMSB
call @NICBufWrite
bank NIC_BANK
inc nicCopySrcLSB
bank TCP_BANK
mov w, /tcpCheckSumLSB
call @NICBufWrite
call @NICSendTxFrame ; end and send the packet
bank TIMER_BANK ; initialise the restart timer
clr tcpTimerMSB
clr tcpTimerLSB
retp
:finTimeout bank TIMER_BANK
csae tcpTimerMSB, #TCP_RESTART_EXP ; has the restart timer expired?
retp ; no
clr tcpTimerMSB ; yes, initialise the restart timer
clr tcpTimerLSB
jmp @TCPSendFin
:timeout bank TIMER_BANK
csae tcpTimerMSB, #TCP_RESTART_EXP ; has the restart timer expired?
retp ; no
clr tcpTimerMSB ; yes, initialise the restart timer
clr tcpTimerLSB
jmp @TCPReTransmit ; transmit the packet again
:closeWait mov tcpState, #TCP_ST_LASTACK
jmp @TCPSendFin ; send FIN, ACK
; ******************************************************************************
_TCPReTransmit
; This is called to retransmit the TCP packet that's already setup in the NIC's
; TCP transmit buffer. Remember that a UDP/ICMP/ARP packet may have been sent
; after the TCP packet was initially sent, so we have to re-setup the NIC
; carefully.
; INPUT: none
; OUTPUT: none
; ******************************************************************************
; re-initialize the NIC's TPSR
bank NIC_BANK
clr nicIOAddr ; CR
:wait call @NICRead
jb wreg.2, :wait ; wait for prior transmission to complete
mov w, #%00100010 ; Page0, abort DMA
call NICWrite_3
mov nicIOAddr, #$04 ; TPSR
mov w, #TXBUF2_START
call NICWrite_3
; read the NIC's TCP transmit buffer to find out the IP <length>
; so that we can re-initialize the NIC's TBCR
mov nicCopySrcMSB, #TXBUF2_START
mov nicCopySrcLSB, #(6+6+2+2) ; IP <length> (MSB)
call @NICBufRead
bank IP_BANK
mov ipLengthMSB, w
bank NIC_BANK
inc nicCopySrcLSB ; IP <length> (LSB)
call @NICBufRead
bank IP_BANK
mov ipLengthLSB, w
jmp @NICSendTxFrame ; re-transmit the ethernet frame
; ******************************************************************************
_TCPAppPassiveOpen
; Do a passive open. i.e. listen for connections on a given port.
; [TCP API Function]
; INPUT: {tcbLocalPortMSB,tcbLocalPortLSB} = TCP port to listen on
; OUTPUT: none
; ******************************************************************************
_bank TCP_BANK
mov tcpState, #TCP_ST_LISTEN
clr tcpUnAckMSB
clr tcpUnAckLSB
retp
; ******************************************************************************
_TCPAppActiveOpen
; Do a active open. i.e. initiate a connect to a remote TCP.
; [TCP API Function]
; INPUT: {remoteIP0-3} = destination IP addr
; {tcbLocalPortMSB,tcbLocalPortLSB} = local TCP port
; {tcpRemotePortMSB,tcbRemotePortLSB} = remote TCP port
; OUTPUT: none
; ******************************************************************************
_bank TCP_BANK
clr tcpUnAckMSB
clr tcpUnAckLSB
mov tcpState, #TCP_ST_SYNSENT
bank TCB_BANK
mov tcbFlags, #(1<<TCP_FLAG_SYN)
jmp @TCPSendSyn
; ******************************************************************************
_TCPAppClose
; Force the current connection to close
; [TCP API Function]
; INPUT: none
; OUTPUT: none
; ******************************************************************************
_bank TCP_BANK
mov tcpState, #TCP_ST_FINWAIT1
clr tcpUnAckMSB
clr tcpUnAckLSB
bank TCB_BANK
mov tcbFlags, #((1<<TCP_FLAG_FIN)|(1<<TCP_FLAG_ACK))
jmp @TCPSendEmptyPkt
ORG $800 ; Page4
TCPRxHeader jmp _TCPRxHeader
TCPChkSeq jmp _TCPChkSeq
TCPRestorePrev jmp _TCPRestorePrev
TCPUpdateSeq jmp _TCPUpdateSeq
; ******************************************************************************
NICReadAgain_4
; Shortform for calling NICReadAgain(), which is in Page1 (This is in Page4)
; ******************************************************************************
jmp @NICReadAgain
; ******************************************************************************
NICWriteAgain_4
; Shortform for calling NICWriteAgain(), which is in Page1 (This is in Page4)
; ******************************************************************************
jmp @NICWriteAgain
; ******************************************************************************
NICDumpRxFrame_4
; Shortform for calling NICDumpRxFrame(), which is in Page1 (This is in Page4)
; ******************************************************************************
jmp @NICDumpRxFrame
; ******************************************************************************
TCPAddRcvNxt
; Add an 16-bit number to RCV.NXT
; INPUT: {ipLengthMSB,ipLengthLSB} = number to add
; OUTPUT: {tcbRcvNxt1-4}
; ******************************************************************************
bank IP_BANK
mov w, ipLengthLSB
bank TCB_BANK
add tcbRcvNxt1, w
bank IP_BANK
mov w, ipLengthMSB
snc
mov w, ++ipLengthMSB
bank TCB_BANK
add tcbRcvNxt2, w
sc
retp
incsz tcbRcvNxt3
retp
inc tcbRcvNxt4
retp
; ******************************************************************************
TCPIncRcvNxt
; Increment RCV.NXT by one
; INPUT: none
; OUTPUT: {tcbRcvNxt1-4}
; ******************************************************************************
bank TCB_BANK
inc tcbRcvNxt1
sz
retp
incsz tcbRcvNxt2
retp
incsz tcbRcvNxt3
retp
inc tcbRcvNxt4
retp
; ******************************************************************************
TCPIncSndUna
; Increment SND.UNA by one
; INPUT: none
; OUTPUT: {tcbSndUna1-4}
; ******************************************************************************
bank TCB_BANK
inc tcbSndUna1
sz
retp
incsz tcbSndUna2
retp
incsz tcbSndUna3
retp
inc tcbSndUna4
retp
; ******************************************************************************
TCPCopySeqToNxt
; Copy {tcpTmpSeq4-1} -> {tcbRcvNxt4-1}
; INPUT: {tcpTmpSeq4-1}
; OUTPUT: {tcbRcvNxt4-1}
; ******************************************************************************
bank TCP_BANK
mov w, tcpTmpSeq4
bank TCB_BANK
mov tcbRcvNxt4, w
bank TCP_BANK
mov w, tcpTmpSeq3
bank TCB_BANK
mov tcbRcvNxt3, w
bank TCP_BANK
mov w, tcpTmpSeq2
bank TCB_BANK
mov tcbRcvNxt2, w
bank TCP_BANK
mov w, tcpTmpSeq1
bank TCB_BANK
mov tcbRcvNxt1, w
retp
; ******************************************************************************
TCPAckUpdate
; Update SND.UNA and RCV.NXT
; INPUT: {tcpTmpAck4-1}
; {tcpTmpSeq4-1}
; {ipLengthMSB,ipLengthLSB} = length of received TCP data
; OUTPUT: {tcpSndUna4-1}
; {tcpRcvNxt4-1}
; ******************************************************************************
call @TCPCopySeqToNxt ; set RCV.NXT = SEG.SEQ
jmp @TCPAddRcvNxt ; add the length of the received packet to the ACK
; ******************************************************************************
TCPCmpNxtSeq
; Check if RCV.NXT == SEG.SEQ
; INPUT: {tcpTmpSeq4-1} = SEG.SEQ
; {tcbRcvNxt4-1} = RCV.NXT
; OUTPUT: z is set if RCV.NXT == SEG.SEQ
; ******************************************************************************
bank TCB_BANK
mov w, tcbRcvNxt1
bank TCP_BANK
xor w, tcpTmpSeq1
sz
retp
bank TCB_BANK
mov w, tcbRcvNxt2
bank TCP_BANK
xor w, tcpTmpSeq2
sz
retp
bank TCB_BANK
mov w, tcbRcvNxt3
bank TCP_BANK
xor w, tcpTmpSeq3
sz
retp
bank TCB_BANK
mov w, tcbRcvNxt4
bank TCP_BANK
xor w, tcpTmpSeq4
retp
; ******************************************************************************
TCPSendEmptyPkt
; Constructs and sends a TCP packet containing no data
; INPUT: {remoteIP0-3} = destination IP addr for TCP pkt
; {tcbSndUna4-1} = sequence number
; {tcbRcvNxt4-1} = acknowledgement number
; tcbFlags = code flags
; {tcbLocalPortMSB,tcbLocalPortLSB} = TCP Source Port
; {tcbRemotePortMSB,tcbRemotePortLSB} = TCP Destination Port
; OUTPUT:
; ******************************************************************************
call @TCPCheckSumInit
bank TCP_BANK
clr tcpLengthMSB
clr tcpLengthLSB
call @TCPStartPktOut
call @NICSendTxFrame
bank TIMER_BANK
clr tcpTimerMSB
clr tcpTimerLSB
retp
; ******************************************************************************
TCPSendReset
; Send a reset packet with <SEQ=SEG.ACK><CTL=RST> and discard the received
; packet
; INPUT: {remoteIP0-3} = destination IP addr for TCP pkt
; {tcbRcvNxt4-1} = acknowledgement number
; {tcbLocalPortMSB,tcbLocalPortLSB} = TCP Source Port
; {tcbRemotePortMSB,tcbRemotePortLSB} = TCP Destination Port
; OUTPUT:
; ******************************************************************************
bank TCB_BANK
mov tcbFlags, #(1<<TCP_FLAG_RST)
call @TCPSendEmptyPkt
jmp NICDumpRxFrame_4 ; discard the received pkt
; ******************************************************************************
TCPSendSyn
; Send a SYN packet
; INPUT: {remoteIP0-3} = destination IP addr for TCP pkt
; {tcbRcvNxt4-1} = acknowledgement number
; {tcbLocalPortMSB,tcbLocalPortLSB} = TCP Source Port
; {tcbRemotePortMSB,tcbRemotePortLSB} = TCP Destination Port
; OUTPUT: {tcpSndUna4-1} = new sequence number
; ******************************************************************************
bank TCB_BANK
mov tcbFlags, #(1<<TCP_FLAG_SYN)
jmp TCPSendISN
; ******************************************************************************
TCPSendISN
; Send the TCP initial sequence number
; INPUT: {remoteIP0-3} = destination IP addr for TCP pkt
; {tcbRcvNxt4-1} = acknowledgement number
; {tcbLocalPortMSB,tcbLocalPortLSB} = TCP Source Port
; {tcbRemotePortMSB,tcbRemotePortLSB} = TCP Destination Port
; OUTPUT: {tcpSndUna4-1} = new sequence number
; ******************************************************************************
; obtain a random number for starting sequence number
bank NIC_BANK
mov w, nicCurrPktPtr
xor w, nicRemoteEth0
bank IP_BANK
xor w, ipIdentLSB
bank TCB_BANK
mov tcbSndUna4, w
mov tcbSndUna3, w
mov tcbSndUna2, w
mov tcbSndUna1, w
call @TCPIncRcvNxt
call @TCPSendEmptyPkt
jmp @TCPIncSndUna
; ******************************************************************************
TCPSendSynAck
; Send an SYN-ACK packet with <SEQ=SND.NXT><ACK=RCV.NXT><CTL=SYN>
; INPUT: {remoteIP0-3} = destination IP addr for TCP pkt
; {tcbRcvNxt4-1} = acknowledgement number
; {tcbLocalPortMSB,tcbLocalPortLSB} = TCP Source Port
; {tcbRemotePortMSB,tcbRemotePortLSB} = TCP Destination Port
; OUTPUT: {tcpSndUna4-1} = new sequence number
; ******************************************************************************
bank TCB_BANK
mov tcbFlags, #((1<<TCP_FLAG_SYN)|(1<<TCP_FLAG_ACK))
jmp @TCPSendISN
; ******************************************************************************
TCPSendAck
; Send an ACK packet with <SEQ=SND.NXT><ACK=RCV.NXT><CTL=ACK> and discard the
; received packet
; INPUT: {remoteIP0-3} = destination IP addr for TCP pkt
; {tcbSndUna4-1} = sequence number
; {tcbRcvNxt4-1} = acknowledgement number
; {tcbLocalPortMSB,tcbLocalPortLSB} = TCP Source Port
; {tcbRemotePortMSB,tcbRemotePortLSB} = TCP Destination Port
; OUTPUT:
; ******************************************************************************
bank TCB_BANK
mov tcbFlags, #(1<<TCP_FLAG_ACK)
call @TCPSendEmptyPkt
jmp NICDumpRxFrame_4 ; discard the received pkt
; ******************************************************************************
TCPSendFin
; Send a FIN packet and discard the received packet
; INPUT: {remoteIP0-3} = destination IP addr for TCP pkt
; {tcbSndUna4-1} = sequence number
; {tcbRcvNxt4-1} = acknowledgement number
; tcbFlags = code flags
; {tcbLocalPortMSB,tcbLocalPortLSB} = TCP Source Port
; {tcbRemotePortMSB,tcbRemotePortLSB} = TCP Destination Port
; OUTPUT:
; ******************************************************************************
bank TCB_BANK
mov tcbFlags, #(1<<TCP_FLAG_FIN)|(1<<TCP_FLAG_ACK)
call @TCPSendEmptyPkt
jmp NICDumpRxFrame_4 ; discard the received pkt
; ******************************************************************************
TCPCheckSumInit
; Clear TCP checksum value to prepare for new checksum calculation
; INPUT: none
; OUTPUT: {tcpCheckSumMSB,tcpCheckSumLSB}
; ******************************************************************************
bank TCP_BANK
clr tcpCheckSumMSB
clr tcpCheckSumLSB
clrb flags.TCP_CHKSUM_LSB ; next byte is MSB
retp
; ******************************************************************************
TCPCheckSumAcc
; Accumulate the TCP checksum. Checksum is computed by doing the one's
; complement of the one's complement sum of 16-bit numbers
; INPUT: w = byte to accumulate
; flags.TCP_CHKSUM_LSB = set if processing LSB, clear if processing MSB
; OUTPUT: {tcpCheckSumMSB,tcpCheckSumLSB}
; ******************************************************************************
bank TCP_BANK
jnb flags.TCP_CHKSUM_LSB, :msb ; are we processing an MSB?
:lsb add tcpCheckSumLSB, w ; add it to the checksum
sc ; was there a carry?
jmp :done
inc tcpCheckSumMSB ; yes
snz
inc tcpCheckSumLSB
jmp :done
:msb add tcpCheckSumMSB, w ; add it to the checksum
sc ; was there a carry?
jmp :done
inc tcpCheckSumLSB ; yes, this time it is added to the LSB
snz
inc tcpCheckSumMSB
:done xor flags, #(1<<TCP_CHKSUM_LSB)
retp
; ******************************************************************************
TCPCheckSumAddHdr
; Add to the TCP checksum, the pseudo-header fields
; INPUT: {myIP0-3} = source IP addr
; {remoteIP0-3} = destination IP addr
; {tcpLengthMSB,tcpLengthLSB} = length of TCP header and data
; OUTPUT: {tcpCheckSumMSB,tcpCheckSumLSB}
; ******************************************************************************
bank TCP_BANK
; <TCP_length>
mov w, tcpLengthMSB
call TCPCheckSumAcc
mov w, tcpLengthLSB
call TCPCheckSumAcc
; <zero>,<protocol>
mov w, #0
call TCPCheckSumAcc
mov w, #6
call TCPCheckSumAcc
; <source_IP>
bank IP_BANK
mov w, myIP3
call TCPCheckSumAcc
bank IP_BANK
mov w, myIP2
call TCPCheckSumAcc
bank IP_BANK
mov w, myIP1
call TCPCheckSumAcc
bank IP_BANK
mov w, myIP0
call TCPCheckSumAcc
; <destination_IP>
bank IP_BANK
mov w, remoteIP3
call TCPCheckSumAcc
bank IP_BANK
mov w, remoteIP2
call TCPCheckSumAcc
bank IP_BANK
mov w, remoteIP1
call TCPCheckSumAcc
bank IP_BANK
mov w, remoteIP0
call TCPCheckSumAcc
retp
; ******************************************************************************
TCPTxByte
; Transmit a TCP byte accumulating the checksum each time
; INPUT: w = byte to send
; OUTPUT: none
; ******************************************************************************
mov globTemp1, w
call @TCPCheckSumAcc
mov w, globTemp1
call NICWriteAgain_4
retp
; ******************************************************************************
TCPStartPktOut
; Constructs the TCP and IP headers
; INPUT: {remoteIP0-3} = destination IP addr for TCP pkt
; {tcpLengthMSB,tcpLengthLSB} = length of TCP data (just data)
; {tcpCheckSumMSB,tcpCheckSumLSB} = TCP checksum computed over just data
; {tcbSndUna4-1} = sequence number
; {tcbRcvNxt4-1} = acknowledgement number
; tcbFlags = code flags
; {tcbLocalPortMSB,tcbLocalPortLSB} = TCP Source Port
; {tcbRemotePortMSB,tcbRemotePortLSB} = TCP Destination Port
; OUTPUT:
; ******************************************************************************
; tcpLength += <TCP header length>
_bank TCP_BANK
mov w, #(TCP_HDR_LENGTH<<2) ; add in size of TCP hdr (20)
add tcpLengthLSB, w
snc
inc tcpLengthMSB ; tcpLength now is the length of TCP hdr and data
; IP <total_length> = tcpLength + <IP header length>
mov w, #20 ; add in size of IP hdr (20)
add w, tcpLengthLSB
bank IP_BANK
mov ipLengthLSB, w
bank TCP_BANK
mov w, tcpLengthMSB
bank IP_BANK
mov ipLengthMSB, w
snc
inc ipLengthMSB
; update IP <identifier>
inc ipIdentLSB
snz
inc ipIdentMSB
; set IP <protocol> for TCP
mov ipProtocol, #6
; compute IP <header_checksum>
call @IPGenCheckSum
; now we're ready to construct the IP header
call @IPStartPktOut
; then construct the TCP header
; TCP <source_port>,<destination_port>,<sequence_number>,
; <acknowledgement_number>,<hlen>,<code>,<window>
bank TCB_BANK
mov tcbOffset, #(TCP_HDR_LENGTH<<4)
mov tcbSendWinMSB, #((TCP_WINDOW_SIZE&$FF00)>>8)
mov tcbSendWinLSB, #(TCP_WINDOW_SIZE&$00FF)
mov globTemp3, #TCB_BANK ; send the TCB fields
:loop mov fsr, globTemp3
mov w, indf ; load the value
call @TCPTxByte ; transmit and accumulate header checksum
inc globTemp3
cse globTemp3, #TCB_END ; is the loop finished?
jmp :loop
; TCP <checksum>
call @TCPCheckSumAddHdr
bank TCP_BANK
mov w, /tcpCheckSumMSB
call NICWriteAgain_4
mov w, /tcpCheckSumLSB
call NICWriteAgain_4
; TCP <urgent_ptr>
mov w, #0
call NICWriteAgain_4
call NICWriteAgain_4
retp
; ******************************************************************************
_TCPRxHeader
; Process the TCP header of a received TCP packet
; INPUT: none
; OUTPUT: Z is set to 1 if the packet is invalid, 0 otherwise
; {tcbRemotePortMSB,tcbRemotePortLSB}
; {tcbSendWinMSB,tcbSendWinLSB}
; tcbOffset
; tcbFlags
; tcpRxFlags
; {tcpTmpSeq4-1} = <sequence_number>
; {tcpTmpAck4-1} = <acknowledgement_number>
; {tcpLengthMSB,tcpLengthLSB} = length of TCP data
; {ipLengthMSB,ipLengthLSB} = length of TCP data
; ******************************************************************************
; Check port and refuse packet if not for current connection
bank TCP_BANK
cjne tcpState, #TCP_ST_LISTEN, :checkSrc
; <source_port>
:readSrc ; read the source port
bank TCB_BANK
call NICReadAgain_4
mov tcbRemotePortMSB, w
call NICReadAgain_4
mov tcbRemotePortLSB, w
jmp :checkDest
:checkSrc ; check the source port is for the current connection
bank TCB_BANK
call NICReadAgain_4
xor w, tcbRemotePortMSB
sz ; is the high byte the same?
jmp :ignorePacket ; no, ignore the packet
call NICReadAgain_4 ; get the low byte
xor w, tcbRemotePortLSB
sz ; is the low byte the same?
jmp :ignorePacket ; no, ignore the packet
; <destination_port>
:checkDest ; check the destination port matches our port
call NICReadAgain_4
xor w, tcbLocalPortMSB
sz ; is the high byte the same?
jmp :ignorePacket ; no, ignore the packet
call NICReadAgain_4 ; get the low byte
xor w, tcbLocalPortLSB
sz ; Is the low byte the same?
jmp :ignorePacket ; no, ignore the packet
; <sequence_number>
bank TCP_BANK
call NICReadAgain_4
mov tcpTmpSeq4, w
call NICReadAgain_4
mov tcpTmpSeq3, w
call NICReadAgain_4
mov tcpTmpSeq2, w
call NICReadAgain_4
mov tcpTmpSeq1, w
; <acknowledgement_number>
call NICReadAgain_4
mov tcpTmpAck4, w
call NICReadAgain_4
mov tcpTmpAck3, w
call NICReadAgain_4
mov tcpTmpAck2,w
call NICReadAgain_4
mov tcpTmpAck1, w
; <hlen>
call NICReadAgain_4 ; receive the data offset. Used to skip the options
and w, #TCP_OFFSET_MASK ; mask out the offset
bank TCB_BANK
mov tcbOffset, w
clc
rr tcbOffset ; shift right to get the number of bytes
rr tcbOffset
; ipLength = tcpLength = length of TCP data
mov w, tcbOffset ; size of TCP header in bytes
bank IP_BANK
sub ipLengthLSB, w ; subtract out size of TCP header
mov w, ipLengthLSB
bank TCP_BANK
mov tcpLengthLSB, w
bank IP_BANK
sc
dec ipLengthMSB
mov w, ipLengthMSB
bank TCP_BANK
mov tcpLengthMSB, w
; <code>
call NICReadAgain_4 ; receive the flags
mov tcpRxFlags, w
bank TCB_BANK
mov tcbFlags, w ; take a copy of the flags
; <window>
call NICReadAgain_4
mov tcbSendWinMSB, w ; receive the window
call NICReadAgain_4
mov tcbSendWinLSB, w
; <checksum>,<urgent_ptr>,<options>
; skip over these
bank TCB_BANK
sub tcbOffset, #((TCP_HDR_LENGTH<<2)-4)
:loop call NICReadAgain_4
decsz tcbOffset
jmp :loop
clz
retp
:ignorePacket ; ignore the rest of the packet.
call NICDumpRxFrame_4
; ## Need to send a reset in response to this packet.
; ## Unfortunately sending a packet would overwrite the TCB.
; ## Need to create a second TCB?
stz
retp
; ******************************************************************************
_TCPUpdateSeq
; Add an 16-bit number to outgoing Sequence nr
; INPUT: {tcbSndUna1-4}{tcpUnAckMSB/LSB} = number to add
; OUTPUT: {tcbSndUna1-4}
; ******************************************************************************
bank TCP_BANK
mov w, tcpUnAckLSB
bank TCB_BANK
add tcbSndUna1, w
bank TCP_BANK
mov w, tcpUnAckMSB
snc
mov w, ++tcpUnAckMSB
bank TCB_BANK
add tcbSndUna2, w
sc
retp
incsz tcbSndUna3
retp
inc tcbSndUna4
retp
; ******************************************************************************
_TCPChkSeq
; This is called in the TCPProcPktIn to check if the received packet is the one
; expected or if it is a previous unacked packet.
; [TCP API Function]
; INPUT: none
; OUTPUT: z flag is set if the received packet is incorrect
; ******************************************************************************
call TCPCmpNxtSeq ; Check if received is expected
jz :equal ; z is set if RCV.NXT == SEG.SEQ
_bank TCP_BANK
test tcpUnAckLSB
sz
jmp :outstanding
test tcpUnAckMSB
snz
jmp :noOutstanding
:outstanding call TCPRestorePrev ; RCV.NXT = RCV.NXT - tcpUnAck
call TCPCmpNxtSeq ; Check if received is ack on previous packet
jnz :noOutstanding ; z is set if RCV.NXT == SEG.SEQ
setb z ; Return value = "OK"
retp
:equal _bank TCP_BANK
clr tcpUnAckLSB
clr tcpUnAckMSB ; Z is set (return value = "OK")
retp
:noOutstanding clrb LED_PIN ; DEBUG TODO
jmp $ ; DEBUG
; ******************************************************************************
_TCPRestorePrev
; Subtract an 16-bit number from RCV.NXT
; INPUT: {tcpUnAckLSB,tcpUnAckMSB} = number to add
; OUTPUT: {tcbRcvNxt1-4}
; ******************************************************************************
bank TCP_BANK
mov w, tcpUnAckLSB
bank TCB_BANK
sub tcbRcvNxt1, w
bank TCP_BANK
mov w, tcpUnAckMSB
jc :dontBorrow
mov w, ++tcpUnAckMSB ; if prev.sub was negative
test w ; carry on inc?
jz :exit ; yes (w = $100)
:dontBorrow
bank TCB_BANK
sub tcbRcvNxt2, w
snc ; c=0 => negative result
retp
:exit bank TCB_BANK
test tcbRcvNxt3
snz
dec tcbRcvNxt4
dec tcbRcvNxt3
retp
ORG $A00 ; Page5
E2Read8Ack jmp _E2Read8Ack
E2Read8NoAckStop jmp _E2Read8NoAckStop
E2RecvAck jmp _E2RecvAck
E2SendAck jmp _E2SendAck
E2SendNotAck jmp _E2SendNotAck
E2SendRdCmd jmp _E2SendRdCmd
E2SendWrCmd jmp _E2SendWrCmd
E2SetAddr jmp _E2SetAddr
Bin8ToBCD jmp _Bin8ToBCD
BCDToASCII jmp _BCDToASCII
; ******************************************************************************
TCPAppInit
; Called repeatedly as long as TCP connection state is closed
; [TCP API Function]
; INPUT: none
; OUTPUT: none
; ******************************************************************************
bank TCB_BANK
mov tcbLocalPortLSB, #HTTP_PORT_LSB
mov tcbLocalPortMSB, #HTTP_PORT_MSB
bank HTTP_BANK
clr httpParseState
clr httpURIHash
jmp @TCPAppPassiveOpen
; ******************************************************************************
TCPAppTxBytes
; Called before transmitting a TCP packet to see if the application has any
; data it wishes to send. The application cannot send more than TCP_SEG_SIZE
; bytes at one go.
; [TCP API Function]
; INPUT: none
; OUTPUT: {tcpUnAckMSB,tcpUnAckLSB} = number of bytes to transmit
; ******************************************************************************
bank HTTP_BANK
cje httpParseState, #2, :state2
cje httpParseState, #3, :state3
cje httpParseState, #4, :state4
retp
:state2 ; check how much there is to send
bank EEPROM_BANK
csae e2FileLenMSB, #(HTTP_SEG_SIZE>>8)
jmp :lastSegment ; msb#1 < msb#2
cse e2FileLenMSB, #(HTTP_SEG_SIZE>>8)
jmp :notLast ; msb#1 > msb#2
csa e2FileLenLSB, #(HTTP_SEG_SIZE&$00FF)
jmp :lastSegment ; #1 <= #2
:notLast ; not the last segment so send as much as possible (i.e. full segment)
sub e2FileLenLSB, #(HTTP_SEG_SIZE&$00FF) ; e2FileLen -= HTTP_SEG_SIZE
sc ;
dec e2FileLenMSB ;
sub e2FileLenMSB, #(HTTP_SEG_SIZE>>8) ;
bank TCP_BANK
mov tcpUnAckMSB, #(HTTP_SEG_SIZE>>8)
mov tcpUnAckLSB, #(HTTP_SEG_SIZE&$00FF)
retp
:lastSegment ; last segment so send whatever is leftover
mov w, e2FileLenMSB
bank TCP_BANK
mov tcpUnAckMSB, w
bank EEPROM_BANK
mov w, e2FileLenLSB
bank TCP_BANK
mov tcpUnAckLSB, w
bank HTTP_BANK
inc httpParseState ; next-state = 3
retp
:state3 ; no more to send so we close
call @TCPAppClose
retp
:state4 retp
; ******************************************************************************
TCPAppTxData
; This routine is called once for each byte the application has says it wishes
; to transmit.
; [TCP API Function]
; INPUT: none
; OUTPUT: w = data byte to transmit
; ******************************************************************************
bank HTTP_BANK
cje httpURIHash, #URI1, :specialFile ; resource.htm
cje httpURIHash, #URI2, :specialFile ; temperature.htm
call @E2Read8Ack
retp
:specialFile call @E2Read8Ack
mov globTemp1, w ; save temporarily
csb globTemp1, #$F0
jmp :match
mov w, globTemp1
retp
:match cjne globTemp1, #$F0, :subMatch ; 0xF0 is the magic number
:firstMatch bank HTTP_BANK
mov globTemp2, httpURIHash
mov fsr, #bcd3
cjne globTemp2, #URI1, :here
mov w, pageCount
inc pageCount
jmp :here1
:here _bank ADC_BANK
mov w, adc
:here1 call @Bin8ToBCD
mov w, bcd3+0
call @BCDToASCII
retp
:subMatch sub globTemp1, #$F0
_bank MISC_BANK
mov fsr, #bcd3
add fsr, globTemp1
mov w, indf
call @BCDToASCII
retp
; ******************************************************************************
TCPAppTxDone
; This is called following the last call to TCPAppTxData(). It signifies the
; transmitted data has successfully reached the remote host
; [TCP API Function]
; INPUT: none
; OUTPUT: none
; ******************************************************************************
retp
; ******************************************************************************
TCPAppRxBytes
; Indicator to the application that a packet has been received and that
; TCPAppRxByte is about to be called as many times as they are bytes of data
; [TCP API Function]
; INPUT: {tcpAppRxBytesMSB,tcpAppRxBytesLSB} = number of received data bytes
; OUTPUT: none
; ******************************************************************************
retp
; ******************************************************************************
TCPAppRxData
; Called once for each byte received in a packet.
; [TCP API Function]
; INPUT: w = received data byte
; OUTPUT: none
; ******************************************************************************
mov globTemp1, w
bank HTTP_BANK
test httpParseState
jz :state0
cje httpParseState, #1, :state1
cjae httpParseState, #2, :state2
:state0 cse globTemp1, #' '
retp
inc httpParseState ; next-state = 1
retp
:state1 cje globTemp1, #' ', :gotURI
add httpURIHash, globTemp1
retp
:gotURI ; obtain pointer to file
mov w, httpURIHash
bank EEPROM_BANK
mov e2AddrLSB, w
clr e2AddrMSB
clc ; e2Addr = httpURIHash * 2
rl e2AddrLSB ;
rl e2AddrMSB ;
call @E2Init ; reset EEPROM
call @E2SetAddr
call @E2SendRdCmd
call @E2Read8Ack
mov e2AddrMSB, w
call @E2Read8NoAckStop
mov e2AddrLSB, w
; start reading from file
call @E2SetAddr
call @E2SendRdCmd
; file length
call @E2Read8Ack
mov e2FileLenMSB, w
call @E2Read8Ack
mov e2FileLenLSB, w
; file checksum (ignore)
call @E2Read8Ack
call @E2Read8Ack
inc httpParseState ; next-state = 2
retp
:state2 retp
; ******************************************************************************
TCPAppRxDone
; This is called following the last call to TCPAppRxData(). It signifies the
; end of the received packet
; [TCP API Function]
; INPUT: none
; OUTPUT: none
; ******************************************************************************
retp
; ******************************************************************************
E2Delay600ns
; Delay 600ns
; INPUT: none
; OUTPUT: none
; ******************************************************************************
mov w, #6
:loop decsz wreg
jmp :loop
retp
; ******************************************************************************
E2Delay900ns
; Delay 900ns
; INPUT: none
; OUTPUT: none
; ******************************************************************************
mov w, #8
:loop decsz wreg
jmp :loop
retp
; ******************************************************************************
E2Delay1300ns
; Delay 1300ns
; INPUT: none
; OUTPUT: none
; ******************************************************************************
mov w, #13
:loop decsz wreg
jmp :loop
retp
; ******************************************************************************
E2SDAInput
E2SDAOutputHi
; Set SDA as input
; INPUT: none
; OUTPUT: none
; ******************************************************************************
mov !E2_PORT, #E2_DDR_SDA_IN
retp
; ******************************************************************************
E2SDAOutputLo
; Set SDA as output-low
; INPUT: none
; OUTPUT: none
; ******************************************************************************
clrb E2SDA_PIN
mov !E2_PORT, #E2_DDR_SDA_OUT
retp
; ******************************************************************************
E2GenStartCond
; Generate START condition
; INPUT: none
; OUTPUT: none
; ******************************************************************************
call E2SDAOutputHi
setb E2SCL_PIN
call E2Delay600ns
call E2SDAOutputLo
call E2Delay600ns
clrb E2SCL_PIN
call E2Delay600ns
retp
; ******************************************************************************
E2GenStopCond
; Generate STOP condition
; INPUT: none
; OUTPUT: none
; ******************************************************************************
call E2SDAOutputLo
setb E2SCL_PIN
call E2Delay600ns
call E2SDAOutputHi
call E2Delay1300ns
retp
; ******************************************************************************
E2Write8
; Write 8 bits out the I2C bus
; INPUT: w = data to write
; OUTPUT: none
; ******************************************************************************
mov globTemp1, w ; data buffer
mov globTemp2, #8 ; bit counter
:loop call E2Delay900ns
sb globTemp1.7
call E2SDAOutputLo
snb globTemp1.7
call E2SDAOutputHi
call E2Delay900ns
setb E2SCL_PIN
call E2Delay600ns
clrb E2SCL_PIN
rl globTemp1
decsz globTemp2
jmp :loop
retp
; ******************************************************************************
E2Read8
; Read 8 bits from the I2C bus
; INPUT: none
; OUTPUT: w = data read
; ******************************************************************************
call E2SDAInput
mov globTemp2, #8 ; bit counter
:loop call E2Delay900ns
sb E2SDA_PIN
clc
snb E2SDA_PIN
stc
rl globTemp1
setb E2SCL_PIN
call E2Delay600ns
clrb E2SCL_PIN
call E2Delay900ns
decsz globTemp2
jmp :loop
mov w, globTemp1
retp
; ******************************************************************************
_E2Read8Ack
; Read 8 bits from the I2C bus and send ACK
; INPUT: none
; OUTPUT: w = data read
; ******************************************************************************
call E2Read8
mov globTemp1, w
call E2SendAck
mov w, globTemp1
retp
; ******************************************************************************
_E2Read8NoAckStop
; Read 8 bits from the I2C bus and send a no-ACK and stop-condition
; (terminates sequential read mode on EEPROM)
; INPUT: none
; OUTPUT: w = data read
; ******************************************************************************
call E2Read8
mov globTemp1, w
call E2SendNotAck
call E2GenStopCond
mov w, globTemp1
retp
; ******************************************************************************
_E2RecvAck
; Receive ACK bit from I2C receiver
; INPUT: none
; OUTPUT: z: 1 = received ACK, 0 = didn't receive ACK
; ******************************************************************************
call E2SDAInput
call E2Delay900ns
setb E2SCL_PIN
sb E2SDA_PIN
stz
snb E2SDA_PIN
clz
call E2Delay600ns
clrb E2SCL_PIN
call E2Delay900ns
retp
; ******************************************************************************
_E2SendAck
; Send ACK bit as acknowledge
; INPUT: none
; ******************************************************************************
call E2SDAOutputLo
call E2Delay900ns
setb E2SCL_PIN
call E2Delay600ns
clrb E2SCL_PIN
call E2Delay900ns
retp
; ******************************************************************************
_E2SendNotAck
; Send ACK bit as not-acknowledge
; INPUT: none
; ******************************************************************************
call E2SDAOutputHi
call E2Delay900ns
setb E2SCL_PIN
call E2Delay600ns
clrb E2SCL_PIN
call E2Delay900ns
retp
; ******************************************************************************
_E2SendRdCmd
; Tell I2C device we wish to read from it for this transaction
; INPUT: none
; OUTPUT: none
; ******************************************************************************
call E2GenStartCond
mov w, #E2_CMD_RD
call E2Write8
call E2RecvAck
retp
; ******************************************************************************
_E2SendWrCmd
; Tell I2C Device we wish to write to it for this transaction
; INPUT: none
; OUTPUT: none
; ******************************************************************************
call E2GenStartCond
mov w, #E2_CMD_WR
call E2Write8
call E2RecvAck
retp
; ******************************************************************************
_E2SetAddr
; Set address pointer
; INPUT: {e2AddrMSB, e2AddrLSB} = address to set to
; OUTPUT: none
; ******************************************************************************
call E2SendWrCmd
_bank EEPROM_BANK
mov w, e2AddrMSB
call E2Write8
call E2RecvAck
mov w, e2AddrLSB
call E2Write8
call E2RecvAck
retp
; ******************************************************************************
_Bin8ToBCD
; Converts 8-bit binary number to unpacked BCD
; INPUT: w = binary number to convert
; fsr = pointer to MSD (lowest addr) of a 3-byte buffer
; OUTPUT: [fsr] = unpacked BCD
; ******************************************************************************
clr indf
inc fsr
clr indf
inc fsr ; LSD
mov indf, w
:loopHun mov w, #100
mov w, indf-w
jnc :loopTen
mov indf, w
dec fsr
dec fsr ; MSD
inc indf
inc fsr
inc fsr ; LSD
jmp :loopHun
:loopTen mov w, #10
mov w, indf-w
sc
jmp :exit
mov indf, w
dec fsr
inc indf
inc fsr
jmp :loopTen
:exit retp
; ******************************************************************************
_BCDToASCII
; Converts an unpacked BCD number to an ASCII character
; INPUT: w = unpacked BCD
; OUTPUT: w = ASCII character
; ******************************************************************************
mov globTemp1, w
mov w, #'0'
add w, globTemp1
retp
ORG $C00 ; Page6
IF DHCP
DHCPREQUESTSend jmp _DHCPREQUESTSend
ENDIF
; ******************************************************************************
NICReadAgain_6
; Shortform for calling NICReadAgain(), which is in Page1 (This is in Page6)
; ******************************************************************************
jmp @NICReadAgain
; ******************************************************************************
NICWriteAgain_6
; Shortform for calling NICWriteAgain(), which is in Page1 (This is in Page6)
; ******************************************************************************
jmp @NICWriteAgain
; ******************************************************************************
UDPStartPktOut
; Starts an outgoing UDP packet by constructing an IP and UDP packet header
; [UDP API Function]
; INPUT: {remoteIP0-3} = destination IP addr for UDP pkt
; {udpTxSrcPortMSB,udpTxSrcPortLSB} = UDP Source Port
; {udpTxDestPortMSB,udpTxDestPortLSB} = UDP Destination Port
; {udpTxDataLenMSB,udpTxDataLenLSB} = UDP Data Length (just data)
; OUTPUT: none
; ******************************************************************************
; compute IP <total_length>
_bank UDP_BANK
mov w, udpTxDataLenLSB
bank IP_BANK
mov ipLengthLSB, w
bank UDP_BANK
mov w, udpTxDataLenMSB
bank IP_BANK
mov ipLengthMSB, w
add ipLengthLSB, #(20+8) ; add in size of UDP hdr (8) and IP hdr (20)
snc
inc ipLengthMSB
; update IP <identifier>
inc ipIdentLSB
snz
inc ipIdentMSB
; set IP <protocol> for UDP
mov ipProtocol, #17
; compute IP <header_checksum>
call @IPGenCheckSum
; now we're ready to construct the IP header
call @IPStartPktOut
; then construct the UDP header
bank UDP_BANK
; UDP <source_port>
mov w, udpTxSrcPortMSB
call NICWriteAgain_6
mov w, udpTxSrcPortLSB
call NICWriteAgain_6
; UDP <destination_port>
mov w, udpTxDestPortMSB
call NICWriteAgain_6
mov w, udpTxDestPortLSB
call NICWriteAgain_6
; UDP <length>
mov w, #8
add w, udpTxDataLenLSB
mov w, udpTxDataLenMSB
snc
inc wreg
call NICWriteAgain_6
mov w, #8
add w, udpTxDataLenLSB
call NICWriteAgain_6
; UDP <checksum> = 0
mov w, #$0
call NICWriteAgain_6
call NICWriteAgain_6
retp
; ******************************************************************************
UDPEndPktOut
; Wraps up and transmits the UDP packet
; [UDP API Function]
; INPUT: none
; OUTPUT: none
; ******************************************************************************
_bank NIC_BANK
jmp @NICSendTxFrame
; ******************************************************************************
UDPProcPktIn
; Processes an Incoming UDP packet
; INPUT: nicCurrPktPtr = points to beginning of received packet
; OUTPUT: none
; ******************************************************************************
bank UDP_BANK
; UDP <source_port>
call NICReadAgain_6
mov udpRxSrcPortMSB, w
call NICReadAgain_6
mov udpRxSrcPortLSB, w
; UDP <destination_port>
call NICReadAgain_6
xor w, udpRxDestPortMSB
jnz :outtaHere
call NICReadAgain_6
xor w, udpRxDestPortLSB
jnz :outtaHere
; UDP <message_length>
call NICReadAgain_6
mov udpRxDataLenMSB, w
call NICReadAgain_6
mov udpRxDataLenLSB, w
; ignore UDP <checksum>
REPT 2
call NICReadAgain_6
ENDR
; UDP <data>
snb flags.RX_IS_IP_BCST
call UDPProcBcstPktIn
sb flags.RX_IS_IP_BCST
call @UDPAppProcPktIn
:outtaHere call @NICDumpRxFrame
retp
IF DHCP
; ******************************************************************************
UDPProcBcstPktIn
; The only kind of broadcast UDP packets accepted are DHCP messages: DHCPOFFER
; and DHCPACK
; INPUT: none
; OUTPUT: myIP0-3
; ******************************************************************************
clrb flags.GOT_DHCP_OFFER
clrb flags.GOT_IP_ADDR
call NICReadAgain_6
xor w, #2 ; check <op> = BOOTP reply
jnz :outtaHere
call NICReadAgain_6
xor w, #1 ; check <htype> = 1
jnz :outtaHere
call NICReadAgain_6
xor w, #6 ; check <hlen> = 6
jnz :outtaHere
; ignore <hops>
call NICReadAgain_6
; check <transaction_id> = 0xABABABAB
REPT 4
call NICReadAgain_6
xor w, #$AB
jnz :outtaHere
ENDR
; ignore <seconds>, <flags>, <client_IP>
mov globTemp1, #(2+2+4)
:loop1 call NICReadAgain_6
decsz globTemp1
jmp :loop1
; record <your_IP>
bank IP_BANK
call NICReadAgain_6
mov myIP3, w
call NICReadAgain_6
mov myIP2, w
call NICReadAgain_6
mov myIP1, w
call NICReadAgain_6
mov myIP0, w
; check if it is non-zero
mov w, myIP3
or w, myIP2
or w, myIP1
or w, myIP0
jz :outtaHere
; skip <server_IP>, <router_IP>, <client_hw_addr>,
; <sever_host_name>, <boot_filename>, <option_magic_cookie>
mov globTemp1, #(4+4+16+64+128+4)
:loop2 call @NICPseudoRead
decsz globTemp1
jmp :loop2
; <option-message_type>
call NICReadAgain_6
xor w, #53 ; DHCP Message Type
jnz :outtaHere
call NICReadAgain_6
xor w, #1
jnz :outtaHere
call NICReadAgain_6
xor w, #2 ; DHCPOFFER
snz
setb flags.GOT_DHCP_OFFER
xor w, #2
xor w, #5 ; DHCPACK
snz
setb flags.GOT_IP_ADDR
; now search for that dang(!) <option-server_id>
:loop4 call NICReadAgain_6
xor w, #54 ; Server Identifier
jz :foundServId
call NICReadAgain_6 ; length
mov globTemp1, w
:loop3 call @NICPseudoRead
decsz globTemp1
jmp :loop3
jmp :loop4
:foundServId call NICReadAgain_6 ; ignore length
bank DHCP_BANK
call NICReadAgain_6
mov dhcpServerId3, w
call NICReadAgain_6
mov dhcpServerId2, w
call NICReadAgain_6
mov dhcpServerId1, w
call NICReadAgain_6
mov dhcpServerId0, w
:outtaHere retp
; ******************************************************************************
DHCPSendCommon1
; Helper function for DHCPDISCOVERSend and DHCPREQUESTSend
; INPUT: none
; OUTPUT: none
; ******************************************************************************
; set ethernet addr to broadcast addr
bank NIC_BANK
mov w, #$FF
mov nicRemoteEth0, w
mov nicRemoteEth1, w
mov nicRemoteEth2, w
mov nicRemoteEth3, w
mov nicRemoteEth4, w
mov nicRemoteEth5, w
; set IP addr to broadcast addr
bank IP_BANK
mov w, #$FF
mov remoteIP3, w
mov remoteIP2, w
mov remoteIP1, w
mov remoteIP0, w
; tell ARP not to send out an ARP REQUEST for this pkt
setb arpFlags.ARP_BYPASS
bank UDP_BANK
clr udpTxSrcPortMSB ; DHCP client
mov udpTxSrcPortLSB, #68 ;
clr udpTxDestPortMSB ; DHCP server
mov udpTxDestPortLSB, #67 ;
call @UDPStartPktOut
; <op>
mov w, #1
call NICWriteAgain_6
; <htype>
mov w, #1
call NICWriteAgain_6
; <hlen>
mov w, #6
call NICWriteAgain_6
; <hops>
mov w, #0
call NICWriteAgain_6
; <transaction_id> = 0xABABABAB
mov w, #$AB
REPT 4
call NICWriteAgain_6
ENDR
; <seconds> = 256
mov w, #1
REPT 2
call NICWriteAgain_6
ENDR
; <flags>
mov w, #$80
call NICWriteAgain_6
mov w, #0
call NICWriteAgain_6
retp
; ******************************************************************************
DHCPSendCommon2
; Helper function for DHCPDISCOVERSend and DHCPREQUESTSend
; INPUT: none
; OUTPUT: none
; ******************************************************************************
; <client_hw_addr>
mov w, #SX_ETH_ADDR0
call NICWriteAgain_6
mov w, #SX_ETH_ADDR1
call NICWriteAgain_6
mov w, #SX_ETH_ADDR2
call NICWriteAgain_6
mov w, #SX_ETH_ADDR3
call NICWriteAgain_6
mov w, #SX_ETH_ADDR4
call NICWriteAgain_6
mov w, #SX_ETH_ADDR5
call NICWriteAgain_6
; <client_hw_addr>,<server_host_name>,<boot_filename>
mov globTemp1, #(10+64+128)
mov w, #0
:loop2 call NICWriteAgain_6
decsz globTemp1
jmp :loop2
; <option_magic_cookie>
mov w, #99
call NICWriteAgain_6
mov w, #130
call NICWriteAgain_6
mov w, #83
call NICWriteAgain_6
mov w, #99
call NICWriteAgain_6
retp
; ******************************************************************************
DHCPDISCOVERSend
; Send DHCPDISCOVER message
; INPUT: none
; OUTPUT: none
; ******************************************************************************
bank UDP_BANK
clr udpTxDataLenMSB
mov udpTxDataLenLSB, #(240+3+0+1) ; without requested-IP option
;mov udpTxDataLenLSB, #(240+3+6+1) ; with requested-IP option
call DHCPSendCommon1
; <client_IP>, <your_IP>,<server_IP>,<router_IP> = 0
mov globTemp1, #(4+4+4+4)
mov w, #0
:loop1 call NICWriteAgain_6
decsz globTemp1
jmp :loop1
call DHCPSendCommon2
; <option-message_type>
mov w, #53
call NICWriteAgain_6
mov w, #1
call NICWriteAgain_6
mov w, #1 ; DHCPDISCOVER
call NICWriteAgain_6
; <option-requested_IP> -- optional
;mov w, #50
;call NICWriteAgain_6
;mov w, #4
;call NICWriteAgain_6
;mov w, #SX_IP_ADDR3
;call NICWriteAgain_6
;mov w, #SX_IP_ADDR2
;call NICWriteAgain_6
;mov w, #SX_IP_ADDR1
;call NICWriteAgain_6
;mov w, #SX_IP_ADDR0
;call NICWriteAgain_6
; <option-end_option> -- not optional
mov w, #255
call NICWriteAgain_6
; and ... that should do it!
call @UDPEndPktOut
clrb arpFlags.ARP_BYPASS
retp
; ******************************************************************************
_DHCPREQUESTSend
; Send DHCPREQUEST message
; INPUT: none
; OUTPUT: none
; ******************************************************************************
bank UDP_BANK
mov udpTxDataLenMSB, #((240+3+6+6+1)>>8)
mov udpTxDataLenLSB, #((240+3+6+6+1)&$FF)
call DHCPSendCommon1
; <client_IP>
bank IP_BANK
mov w, myIP3
call NICWriteAgain_6
mov w, myIP2
call NICWriteAgain_6
mov w, myIP1
call NICWriteAgain_6
mov w, myIP0
call NICWriteAgain_6
; <your_IP>,<server_IP>,<router_IP> = 0
mov globTemp1, #(4+4+4)
mov w, #0
:loop1 call NICWriteAgain_6
decsz globTemp1
jmp :loop1
call DHCPSendCommon2
; <option-message_type>
mov w, #53
call NICWriteAgain_6
mov w, #1
call NICWriteAgain_6
mov w, #3 ; DHCPREQUEST
call NICWriteAgain_6
; <option-server_id>
mov w, #54 ; option server identifier
call NICWriteAgain_6
mov w, #4 ; length
call NICWriteAgain_6
bank DHCP_BANK
mov w, dhcpServerId3
call NICWriteAgain_6
mov w, dhcpServerId2
call NICWriteAgain_6
mov w, dhcpServerId1
call NICWriteAgain_6
mov w, dhcpServerId0
call NICWriteAgain_6
; <option-requested_IP> -- not optional
mov w, #50
call NICWriteAgain_6
mov w, #4
call NICWriteAgain_6
bank IP_BANK
mov w, myIP3
call NICWriteAgain_6
mov w, myIP2
call NICWriteAgain_6
mov w, myIP1
call NICWriteAgain_6
mov w, myIP0
call NICWriteAgain_6
; <option-end_option> -- not optional
mov w, #255
call NICWriteAgain_6
; and ... that should do it!
call @UDPEndPktOut
clrb arpFlags.ARP_BYPASS
retp
ELSE ; DHCP
; ******************************************************************************
UDPProcBcstPktIn
; The only kind of broadcast UDP packets accepted are DHCP messages: DHCPOFFER
; and DHCPACK
; INPUT: none
; OUTPUT: none
; ******************************************************************************
retp ; cus DHCP not enabled
ENDIF ; DHCP
ORG $E00 ; Page7 (Holly Cow! Still not done??)
; ******************************************************************************
UDPAppInit
; Application UDP Initialization code (Example)
; This function is called automatically once by the stack during startup
; [UDP API Function]
; INPUT: none
; OUTPUT: none
; ******************************************************************************
_bank UDP_BANK
mov udpRxDestPortMSB, #UDP_RX_DEST_MSB
mov udpRxDestPortLSB, #UDP_RX_DEST_LSB
retp
; ******************************************************************************
UDPAppProcPktIn
; Application Incoming UDP packet handler (Example)
; This function is called whenever an application (matches udpRxDestPortxSB)
; packet is received. The appplication can call NICReadAgain() to extract
; sequentially extract each byte of the <data> field in the UDP packet.
; [UDP API Function]
; INPUT: {udpRxDataLenMSB,udpRxDataLenLSB} = number of bytes in UDP <data>
; {udpRxSrcPortMSB,udpRxSrcPortLSB} = UDP <source_port>
; OUTPUT: none
; ******************************************************************************
call @NICReadAgain
IF CREDENCE
xor re, w ; toggle I/O pins
_bank MISC_BANK
mov ledPort, re
ELSE
and w, #%01000000
xor ra, w ; toggle I/O pins
_bank MISC_BANK
mov ledPort, ra
ENDIF
_bank UDP_BANK
clr udpTxSrcPortMSB
clr udpTxSrcPortLSB
mov udpTxDestPortMSB, udpRxSrcPortMSB
mov udpTxDestPortLSB, udpRxSrcPortLSB
mov udpTxDataLenMSB, #0
mov udpTxDataLenLSB, #2
call @UDPStartPktOut
IF CREDENCE
mov w, re ; send new port state
ELSE
mov w, ra ; send new port state
ENDIF
call @NICWriteAgain
mov w, #$00 ; one-byte padding
call @NICWriteAgain
call @UDPEndPktOut
retp
; ***********
; *** END ***
; ***********
END
| file: /Techref/scenix/lib/io/osi3/tcpip/isx_1_6_8.src, 128KB, , updated: 2002/2/21 11:32, local time: 2024/11/19 09:05,
|
| | ©2024 These pages are served without commercial sponsorship. (No popup ads, etc...).Bandwidth abuse increases hosting cost forcing sponsorship or shutdown. This server aggressively defends against automated copying for any reason including offline viewing, duplication, etc... Please respect this requirement and DO NOT RIP THIS SITE. Questions?
<A HREF="http://linistepper.com/techref/scenix/lib/io/osi3/tcpip/isx_1_6_8.src"> scenix lib io osi3 tcpip isx_1_6_8</A> |
| Did you find what you needed?
|