Dev3C501.cpp@ 96407

Last change on this file since 96407 was 96407, checked in by vboxsync, 2 years ago
scm copyright and license note update
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 100.9 KB

Rev	Line
[93560]	1	/* $Id: Dev3C501.cpp 96407 2022-08-22 17:43:14Z vboxsync $ */
	2	/** @file
	3	* Dev3C501 - 3Com EtherLink (3C501) Ethernet Adapter Emulation.
	4	*/
	5
	6	/*
[96407]	7	* Copyright (C) 2022 Oracle and/or its affiliates.
[93560]	8	*
[96407]	9	* This file is part of VirtualBox base platform packages, as
	10	* available from https://www.virtualbox.org.
	11	*
	12	* This program is free software; you can redistribute it and/or
	13	* modify it under the terms of the GNU General Public License
	14	* as published by the Free Software Foundation, in version 3 of the
	15	* License.
	16	*
	17	* This program is distributed in the hope that it will be useful, but
	18	* WITHOUT ANY WARRANTY; without even the implied warranty of
	19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	20	* General Public License for more details.
	21	*
	22	* You should have received a copy of the GNU General Public License
	23	* along with this program; if not, see <https://www.gnu.org/licenses>.
	24	*
	25	* SPDX-License-Identifier: GPL-3.0-only
[93560]	26	*/
	27
	28	/** @page pg_dev_3c501 3Com 3C501 Ethernet Controller Emulation.
	29	*
	30	* This software was written based on the following documents:
	31	*
	32	* - 3Com IBM Ethernet (IE) Controller/Transceiver
	33	* External Reference Specification, March 15, 1983
	34	* - 3Com EtherLink (3C501) Adapter Technical Reference
	35	* Manual Part No. 6405-00, November 26, 1988
	36	* - SEEQ 8001 EDLC Ethernet Data Link Controller
	37	* Preliminary Data Sheet, December 1982
	38	*
	39	* The emulation is compatible with 3Com 3C501 EtherLink aka IE4. It also
	40	* appears to be compatible with the original 1982 3C500 IBM Ethernet aka
	41	* IE; the IE and IE4 documentation is nearly identical.
	42	*
	43	* The EtherLink is a very early design. It has only a single 2K buffer for
	44	* both send and receive, and was desgined long before full-duplex Ethernet
	45	* was possible (it is capable of simultaneous send and receive, but only in
	46	* loopback mode). If it has just received a packet, the EtherLink can't
	47	* receive another packet until the first one has been processed by the
	48	* host.
	49	*
	50	* The above problem is greatly alleviated in a VM because incoming packets
	51	* can be buffered for a short while and don't have to be immediately
	52	* dropped just because the adapter is currently sending or because the
	53	* receive status register has not been read yet.
	54	*
	55	* The first 8 registers (station address, receive and transmit command and
	56	* status) are implemented in the SEEQ 8001 EDLC chip. The remaining 8
	57	* registers are provided by the 3Com ASIC (0755-02) on the 3C501 or
	58	* discrete chips on the 3C500.
	59	*
	60	* The '16 collisions' bit in the transmit command/status register is nearly
	61	* useless. The SEEQ 8001 could retransmit automatically, but the IE/IE4 can
	62	* not because the GP Buffer Pointer needs to be reinitialized by software
	63	* prior to each transmit attempt. It is unclear if the 16-collision counter
	64	* only rolls over modulo 16 or if it is cleared by something other than
	65	* reset.
	66	*
	67	* The 3C501 supports DMA transfers to/from the packet buffer. Many drivers
	68	* don't use DMA by default or at all. Due to the overhead of programming
	69	* the DMA controller, direct I/O access (rep insb/outsb) is always faster
	70	* in a VM. DMA would only be a win for very ancient drivers which don't use
	71	* the rep insb/outsb instructions (those didn't exist on the 8086/8088).
	72	*
	73	* NB: The default DMA channel (channel 1) conflicts with the default Sound
	74	* Blaster settings. If both 3C501 and SB16 are used, then one of them
	75	* either needs to be reconfigured to use DMA channel other than 1 or the
	76	* 3C501 must not use DMA.
	77	*
	78	* The 3Com documentation implies that writing the low byte of the Receive
	79	* Buffer Pointer is enough to clear the pointer. Yet almost all drivers,
	80	* including 3Com's sample code, write zeros to both the low and high bytes
	81	* of the Receive Buffer Pointer when clearing it. BSD drivers (if_el.c)
	82	* notably only write the low byte. It has been verified on a real 3C501
	83	* that the documentation is correct. Writing anything to the Receive Buffer
	84	* Pointer LSB clears the pointer (writing to the MSB appears to have no
	85	* effect whatsoever).
	86	*
	87	* If the Receive Buffer Pointer is not explicitly cleared prior to
	88	* receiving a packet, it will simply keep incrementing from wherever it
	89	* was. Once it hits the end of the buffer (wraps around to zero), a
	90	* receive overflow will be triggered (because the EDLC's FIFO will no
	91	* longer be serviced) but the buffer will contain however much data there
	92	* was room for. Note that the SEEQ 8001 datasheet is not explicit, but the
	93	* EDLC can probably receive frames with more than 1,500 octets of payload.
	94	*
	95	* The GP Buffer Pointer behavior is quite curious. It appears to be
	96	* internally a 12-bit pointer, and its top bit (that is, bit 11) is ignored
	97	* when addressing into the 2K buffer. When writing the MSB, the top 5 bits
	98	* are masked (always written as zero), i.e. only a 11-bit value can be
	99	* written. Through auto-increment, the GP Buffer Pointer can reach values
	100	* that can be read but not written.
	101	*
	102	* The implementation was tested for correctness using 3Com's diagnostic
	103	* utility (3C501.EXE, Version 2.4, 1986 and also DIAGNOSE.COM, Version 2.0,
	104	* 1983) and "passes diagnose with flying colors". Note that the interrupt
	105	* test does not pass in V2.3 diagnostics by default because it writes an
	106	* EOI to port 0F820h instead of 20h, relying on the system board to decode
	107	* only the low 10 bits of the address. PCI-based systems decode all address
	108	* bits and writes to address 0F820h do not reach the interrupt controller.
	109	* The 3C501.EXE utility can be run with the '-i' switch to skip interrupt
	110	* tests; the older DIAGNOSE.COM does not have that problem. In both
	111	* versions, the preliminary test fails if the MAC address OID is not
	112	* 02:60:8C (the utility thinks the PROM is corrupted).
	113	*
	114	* 3Com's XNS driver (ETH.SYS) likewise requires the OID to be 02:60:8C,
	115	* otherwise the driver uses 00:00:00:00:00:00 as its MAC address, which is
	116	* not something that produces useful results. Most old drivers (NetWare,
	117	* NDIS, XENIX) don't care about the OID, but some (BSDs, Linux, some SCO
	118	* UNIX versions) want to see the 3Com OID.
	119	*
	120	* The MS Networks Client setup also requires the OID to match 3Com's when
	121	* detecting the hardware, but the actual NDIS driver does not care. Note
	122	* that the setup fails to detect the emulated 3C501 at the default 0x300
	123	* base address, but finds it at 0x310 and other addresses.
	124	*
	125	* Note that especially newer Linux/BSD OSes are a lost cause. Their 3C501
	126	* drivers are very hard to configure, broken in various ways, and likely
	127	* untested. For example the Linux driver clears the receive buffer pointer
	128	* at the end of the interrupt handler, which may easily happen after a
	129	* packet was already received. In FreeBSD 6.4, the kernel crashes when the
	130	* el0 driver is loaded. In FreeBSD 5.0, the el0 driver sends packets and
	131	* reads packets from the card, but the OS never sees any incoming data
	132	* (even though the receive packet counter keeps going up).
	133	*
	134	* The precise receive logic (when a packet is copied to the buffer, when an
	135	* interrupt is signaled, when receive goes idle) is difficult to understand
	136	* from the 3Com documentation, but is extensively tested by the diagnostic
	137	* utility. The SEEQ 8001 datasheet may be easier to understand than the
	138	* EtherLink documentation.
	139	*
	140	* Some drivers (e.g. NetWare DOS IPX shell and ODI drivers) like to reset
	141	* the chip more or less after every packet is sent or received. That leads
	142	* to a situation where the NIC is briefly unable to receive anything. If we
	143	* drop packets in that case, we end up with well over 10% packet loss and
	144	* terrible performance. We have to hold off and not drop packets just
	145	* because the receiver is disabled for a moment.
	146	*
	147	* Note that the reset bit in the auxiliary command register does not nearly
	148	* reset the entire chip as the documentation suggests. It may only truly
	149	* reset the SEEQ 8001 EDLC chip. It is impossible to say how going out of
	150	* reset affects the auxiliary command register itself, since it must be
	151	* written to exit the reset state. The reset bit clears the EDLC transmit
	152	* and command registers, but not the programmed station address. It also
	153	* does not disturb the packet buffer, and it does not clear the GP Buffer
	154	* Pointer.
	155	*
	156	* The default EtherLink configuration uses I/O base 300h, IRQ 3, DMA
	157	* channel 1. Prior to May 1983, the default IRQ was 5. On old EtherLink
	158	* cards, the I/O address was configurable from 200h-3F0h in increments of
	159	* 16, DMA 1 or 3, and IRQ 3 or 5. Newer EtherLinks (starting circa in 1984)
	160	* in addition allow DMA 2 and IRQ 2, 4, 6, and 7.
	161	*
	162	*/
	163
	164
	165	/*********************************************************************************************************************************
	166	* Header Files *
	167	*********************************************************************************************************************************/
	168	#define LOG_GROUP LOG_GROUP_DEV_ELNK
	169	#include <VBox/vmm/pdmdev.h>
	170	#include <VBox/vmm/pdmnetifs.h>
	171	#include <VBox/vmm/pgm.h>
	172	#include <VBox/version.h>
	173	#include <iprt/asm.h>
	174	#include <iprt/assert.h>
	175	#include <iprt/critsect.h>
	176	#include <iprt/net.h>
	177	#include <iprt/string.h>
	178	#include <iprt/time.h>
	179	#ifdef IN_RING3
	180	# include <iprt/mem.h>
	181	# include <iprt/semaphore.h>
	182	# include <iprt/uuid.h>
	183	#endif
	184
	185	#include "VBoxDD.h"
	186
	187
	188	/*********************************************************************************************************************************
	189	* Defined Constants And Macros *
	190	*********************************************************************************************************************************/
	191
	192	#define ELNK_SAVEDSTATE_VERSION 1
	193
	194	/** Maximum number of times we report a link down to the guest (failure to send frame) */
	195	#define ELNK_MAX_LINKDOWN_REPORTED 3
	196
[93675]	197	/** Maximum number of times we postpone restoring a link that is temporarily down. */
	198	#define ELNK_MAX_LINKRST_POSTPONED 3
	199
[93560]	200	/** Maximum frame size we handle */
	201	#define MAX_FRAME 1536
	202
	203	/* Size of the packet buffer. */
	204	#define ELNK_BUF_SIZE 2048u
	205
	206	/* The packet buffer address mask. */
	207	#define ELNK_BUF_ADR_MASK (ELNK_BUF_SIZE - 1)
	208
	209	/* The GP buffer pointer address within the buffer. */
	210	#define ELNK_GP(pThis) ((pThis)->uGPBufPtr & ELNK_BUF_ADR_MASK)
	211
	212	/* The GP buffer pointer mask.
	213	* NB: The GP buffer pointer is internally a 12-bit counter. When addressing into the
	214	* packet buffer, bit 11 is ignored. Required to pass 3C501 diagnostics.
	215	*/
	216	#define ELNK_GP_MASK 0xfff
	217
	218	/* The EtherLink is an 8-bit adapter, hence DMA channels up to 3 are available. */
	219	#define ELNK_MAX_VALID_DMA 3
	220
	221
	222	/*********************************************************************************************************************************
	223	* Structures and Typedefs *
	224	*********************************************************************************************************************************/
	225
	226
	227	/**
	228	* EtherLink Transmit Command Register.
	229	*/
	230	typedef struct ELNK_XMIT_CMD {
	231	uint8_t det_ufl : 1; /* Detect underflow. */
	232	uint8_t det_coll : 1; /* Detect collision. */
	233	uint8_t det_16col : 1; /* Detect collision 16. */
	234	uint8_t det_succ : 1; /* Detect successful xmit. */
	235	uint8_t unused : 4;
	236	} EL_XMT_CMD;
	237
	238	/**
	239	* EtherLink Transmit Status Register.
	240	*
	241	* We will never see any real collisions, although collisions (including 16
	242	* successive collisions) may be useful to report when the link is down
	243	* (something the 3C501 does not have a concept of).
	244	*/
	245	typedef struct ELNK_XMIT_STAT {
	246	uint8_t uflow : 1; /* Underflow on transmit. */
	247	uint8_t coll : 1; /* Collision on transmit. */
	248	uint8_t coll16 : 1; /* 16 collisions on transmit. */
	249	uint8_t ready : 1; /* Ready for a new frame. */
	250	uint8_t undef : 4;
	251	} EL_XMT_STAT;
	252
	253	/** Address match (adr_match) modes. */
	254	typedef enum {
	255	EL_ADRM_DISABLED = 0, /* Receiver disabled. */
	256	EL_ADRM_PROMISC = 1, /* Receive all addresses. */
	257	EL_ADRM_BCAST = 2, /* Receive station + broadcast. */
	258	EL_ADRM_MCAST = 3 /* Receive station + multicast. */
	259	} EL_ADDR_MATCH;
	260
	261	/**
	262	* EtherLink Receive Command Register.
	263	*/
	264	typedef struct ELNK_RECV_CMD {
	265	uint8_t det_ofl : 1; /* Detect overflow errors. */
	266	uint8_t det_fcs : 1; /* Detect FCS errors. */
	267	uint8_t det_drbl : 1; /* Detect dribble error. */
	268	uint8_t det_runt : 1; /* Detect short frames. */
	269	uint8_t det_eof : 1; /* Detect EOF (frames without overflow). */
	270	uint8_t acpt_good : 1; /* Accept good frames. */
	271	uint8_t adr_match : 2; /* Address match mode. */
	272	} EL_RCV_CMD;
	273
	274	/**
	275	* EtherLink Receive Status Register.
	276	*/
	277	typedef struct ELNK_RECV_STAT {
	278	uint8_t oflow : 1; /* Overflow on receive. */
	279	uint8_t fcs : 1; /* FCS error. */
	280	uint8_t dribble : 1; /* Dribble error. */
	281	uint8_t runt : 1; /* Short frame. */
	282	uint8_t no_ovf : 1; /* Received packet w/o overflow. */
	283	uint8_t good : 1; /* Received good packet. */
	284	uint8_t undef : 1;
	285	uint8_t stale : 1; /* Stale receive status. */
	286	} EL_RCV_STAT;
	287
	288	/** Buffer control (buf_ctl) modes. */
	289	typedef enum {
	290	EL_BCTL_SYSTEM = 0, /* Host has buffer access. */
	291	EL_BCTL_XMT_RCV = 1, /* Transmit, then receive. */
	292	EL_BCTL_RECEIVE = 2, /* Receive. */
	293	EL_BCTL_LOOPBACK = 3 /* Loopback. */
	294	} EL_BUFFER_CONTROL;
	295
	296	/**
	297	* EtherLink Auxiliary Status Register.
	298	*/
	299	typedef struct ELNK_AUX_CMD {
	300	uint8_t ire : 1; /* Interrupt Request Enable. */
	301	uint8_t xmit_bf : 1; /* Xmit packets with bad FCS. */
	302	uint8_t buf_ctl : 2; /* Packet buffer control. */
	303	uint8_t unused : 1;
	304	uint8_t dma_req : 1; /* DMA request. */
	305	uint8_t ride : 1; /* Request Interrupt and DMA Enable. */
	306	uint8_t reset : 1; /* Card in reset while set. */
	307	} EL_AUX_CMD;
	308
	309	/**
	310	* EtherLink Auxiliary Status Register.
	311	*/
	312	typedef struct ELNK_AUX_STAT {
	313	uint8_t recv_bsy : 1; /* Receive busy. */
	314	uint8_t xmit_bf : 1; /* Xmit packets with bad FCS. */
	315	uint8_t buf_ctl : 2; /* Packet buffer control. */
	316	uint8_t dma_done : 1; /* DMA done. */
	317	uint8_t dma_req : 1; /* DMA request. */
	318	uint8_t ride : 1; /* Request Interrupt and DMA Enable. */
	319	uint8_t xmit_bsy : 1; /* Transmit busy. */
	320	} EL_AUX_STAT;
	321
	322	/**
	323	* Internal interrupt status.
	324	*/
	325	typedef struct ELNK_INTR_STAT {
	326	uint8_t recv_intr : 1; /* Receive interrupt status. */
	327	uint8_t xmit_intr : 1; /* Transmit interrupt status. */
	328	uint8_t dma_intr : 1; /* DMA interrupt status. */
	329	uint8_t unused : 5;
	330	} EL_INTR_STAT;
	331
	332
	333	/**
	334	* EtherLink 3C501 state.
	335	*/
	336	typedef struct ELNKSTATE
	337	{
	338	/** Restore timer.
	339	* This is used to disconnect and reconnect the link after a restore. */
	340	TMTIMERHANDLE hTimerRestore;
	341
	342	/** Transmit signaller. */
	343	PDMTASKHANDLE hXmitTask;
	344	/** Receive ready signaller. */
	345	PDMTASKHANDLE hCanRxTask;
	346
	347	/** Internal interrupt flag. */
	348	bool fISR;
	349	/** Internal DMA active flag. */
	350	bool fDMA;
	351	/** Internal in-reset flag. */
	352	bool fInReset;
	353
	354	/** The PROM contents. Only 8 bytes addressable, R/O. */
	355	uint8_t aPROM[8];
	356
	357	/** The station address programmed by the guest, W/O. */
	358	uint8_t aStationAddr[6];
	359	/** General Purpose (GP) Buffer Pointer, R/W. */
	360	uint16_t uGPBufPtr;
	361
	362	/** Receive (RCV) Buffer Pointer, R/WC. */
	363	uint16_t uRCVBufPtr;
	364	/** Transmit Command Register, W/O. */
	365	union {
	366	uint8_t XmitCmdReg;
	367	EL_XMT_CMD XmitCmd;
	368	};
	369	/** Transmit Status Register, R/O. */
	370	union {
	371	uint8_t XmitStatReg;
	372	EL_XMT_STAT XmitStat;
	373	};
	374	/** Receive Command Register, W/O. */
	375	union {
	376	uint8_t RcvCmdReg;
	377	EL_RCV_CMD RcvCmd;
	378	};
	379	/** Receive Status Register, R/O. */
	380	union {
	381	uint8_t RcvStatReg;
	382	EL_RCV_STAT RcvStat;
	383	};
	384	/** Auxiliary Command Register, W/O. */
	385	union {
	386	uint8_t AuxCmdReg;
	387	EL_AUX_CMD AuxCmd;
	388	};
	389	/** Auxiliary Status Register, R/O. */
	390	union {
	391	uint8_t AuxStatReg;
	392	EL_AUX_STAT AuxStat;
	393	};
	394
	395	/** Base port of the I/O space region. */
	396	RTIOPORT IOPortBase;
	397	/** The configured ISA IRQ. */
	398	uint8_t uIsaIrq;
	399	/** The configured ISA DMA channel. */
	400	uint8_t uIsaDma;
	401	/** If set the link is currently up. */
	402	bool fLinkUp;
	403	/** If set the link is temporarily down because of a saved state load. */
	404	bool fLinkTempDown;
	405	/** Number of times we've reported the link down. */
	406	uint16_t cLinkDownReported;
[93675]	407	/** Number of times we've postponed the link restore. */
	408	uint16_t cLinkRestorePostponed;
[93560]	409
	410	/** The "hardware" MAC address. */
	411	RTMAC MacConfigured;
	412	/** Internal interrupt state. */
	413	union {
	414	uint8_t IntrStateReg;
	415	EL_INTR_STAT IntrState;
	416	};
	417
[93601]	418	/** Set if ELNKSTATER3::pDrv is not NULL. */
	419	bool fDriverAttached;
[93560]	420	/** The LED. */
	421	PDMLED Led;
	422	/** Status LUN: The LED ports. */
	423	PDMILEDPORTS ILeds;
	424	/** Partner of ILeds. */
	425	R3PTRTYPE(PPDMILEDCONNECTORS) pLedsConnector;
	426
	427	/** Access critical section. */
	428	PDMCRITSECT CritSect;
	429	/** Event semaphore for blocking on receive. */
	430	RTSEMEVENT hEventOutOfRxSpace;
	431	/** We are waiting/about to start waiting for more receive buffers. */
	432	bool volatile fMaybeOutOfSpace;
	433
	434	/* MS to wait before we enable the link. */
	435	uint32_t cMsLinkUpDelay;
	436	/** The device instance number (for logging). */
	437	uint32_t iInstance;
	438
	439	STAMCOUNTER StatReceiveBytes;
	440	STAMCOUNTER StatTransmitBytes;
	441	STAMCOUNTER StatPktsLostReset;
	442	#ifdef VBOX_WITH_STATISTICS
	443	STAMPROFILEADV StatIOReadRZ;
	444	STAMPROFILEADV StatIOReadR3;
	445	STAMPROFILEADV StatIOWriteRZ;
	446	STAMPROFILEADV StatIOWriteR3;
	447	STAMPROFILEADV StatReceive;
	448	STAMPROFILEADV StatTransmitR3;
	449	STAMPROFILEADV StatTransmitRZ;
	450	STAMPROFILE StatTransmitSendR3;
	451	STAMPROFILE StatTransmitSendRZ;
	452	STAMPROFILE StatRxOverflow;
	453	STAMCOUNTER StatRxOverflowWakeup;
	454	STAMPROFILEADV StatInterrupt;
	455	STAMCOUNTER StatResets;
	456	STAMCOUNTER StatDropPktAdrmDis;
	457	STAMCOUNTER StatDropPktZeroLen;
	458	STAMCOUNTER StatDropPktVMNotRunning;
	459	STAMCOUNTER StatDropPktNoLink;
	460	STAMCOUNTER StatDropPktStaleRcv;
	461	#endif /* VBOX_WITH_STATISTICS */
	462
	463	/** ISA I/O ports. */
	464	IOMIOPORTHANDLE hIoPortsIsa;
	465
	466	/** The loopback transmit buffer (avoid stack allocations). */
	467	uint8_t abLoopBuf[ELNK_BUF_SIZE];
	468
	469	/** The runt pad buffer (only really needs 60 bytes). */
	470	uint8_t abRuntBuf[64];
	471
	472	/** The packet buffer. */
	473	uint8_t abPacketBuf[ELNK_BUF_SIZE];
	474	} ELNKSTATE, *PELNKSTATE;
	475
	476
[93601]	477	/**
	478	* EtherLink state for ring-3.
	479	*
	480	* @implements PDMIBASE
	481	* @implements PDMINETWORKDOWN
	482	* @implements PDMINETWORKCONFIG
	483	* @implements PDMILEDPORTS
	484	*/
	485	typedef struct ELNKSTATER3
	486	{
	487	/** Pointer to the device instance. */
	488	PPDMDEVINSR3 pDevIns;
	489	/** Pointer to the connector of the attached network driver. */
	490	PPDMINETWORKUPR3 pDrv;
	491	/** Pointer to the attached network driver. */
	492	R3PTRTYPE(PPDMIBASE) pDrvBase;
	493	/** LUN\#0 + status LUN: The base interface. */
	494	PDMIBASE IBase;
	495	/** LUN\#0: The network port interface. */
	496	PDMINETWORKDOWN INetworkDown;
	497	/** LUN\#0: The network config port interface. */
	498	PDMINETWORKCONFIG INetworkConfig;
	499
	500	/** Status LUN: The LED ports. */
	501	PDMILEDPORTS ILeds;
	502	/** Partner of ILeds. */
	503	R3PTRTYPE(PPDMILEDCONNECTORS) pLedsConnector;
	504	} ELNKSTATER3;
	505	/** Pointer to an EtherLink state structure for ring-3. */
	506	typedef ELNKSTATER3 *PELNKSTATER3;
	507
	508
	509	/**
	510	* EtherLink state for ring-0.
	511	*/
	512	typedef struct ELNKSTATER0
	513	{
	514	/** Pointer to the connector of the attached network driver. */
	515	PPDMINETWORKUPR0 pDrv;
	516	} ELNKSTATER0;
	517	/** Pointer to an EtherLink state structure for ring-0. */
	518	typedef ELNKSTATER0 *PELNKSTATER0;
	519
	520
	521	/**
	522	* EtherLink state for raw-mode.
	523	*/
	524	typedef struct ELNKSTATERC
	525	{
	526	/** Pointer to the connector of the attached network driver. */
	527	PPDMINETWORKUPRC pDrv;
	528	} ELNKSTATERC;
	529	/** Pointer to an EtherLink state structure for raw-mode. */
	530	typedef ELNKSTATERC *PELNKSTATERC;
	531
	532
	533	/** The EtherLink state structure for the current context. */
	534	typedef CTX_SUFF(ELNKSTATE) ELNKSTATECC;
	535	/** Pointer to an EtherLink state structure for the current
	536	* context. */
	537	typedef CTX_SUFF(PELNKSTATE) PELNKSTATECC;
	538
	539
[93560]	540	#ifndef VBOX_DEVICE_STRUCT_TESTCASE
	541
	542
	543	/*********************************************************************************************************************************
	544	* Internal Functions *
	545	*********************************************************************************************************************************/
	546
[93601]	547	static int elnkAsyncTransmit(PPDMDEVINS pDevIns, PELNKSTATE pThis, PELNKSTATECC pThisCC, bool fOnWorkerThread);
[93560]	548
	549	/**
	550	* Checks if the link is up.
	551	* @returns true if the link is up.
	552	* @returns false if the link is down.
	553	*/
	554	DECLINLINE(bool) elnkIsLinkUp(PELNKSTATE pThis)
	555	{
[93601]	556	return pThis->fDriverAttached && !pThis->fLinkTempDown && pThis->fLinkUp;
[93560]	557	}
	558
	559
	560	#ifndef ETHER_IS_MULTICAST /* Net/Open BSD macro it seems */
	561	#define ETHER_IS_MULTICAST(a) (((uint8_t )(a)) & 1)
	562	#endif
	563
	564	#define ETHER_ADDR_LEN ETH_ALEN
	565	#define ETH_ALEN 6
	566	#pragma pack(1)
	567	struct ether_header /** @todo Use RTNETETHERHDR? */
	568	{
	569	uint8_t ether_dhost[ETH_ALEN]; /*< destination ethernet address /
	570	uint8_t ether_shost[ETH_ALEN]; /*< source ethernet address /
	571	uint16_t ether_type; /*< packet type ID field /
	572	};
	573	#pragma pack()
	574
	575
	576	/**
	577	* Check if incoming frame matches the station address.
	578	*/
	579	DECLINLINE(int) padr_match(PELNKSTATE pThis, const uint8_t *buf)
	580	{
	581	struct ether_header hdr = (struct ether_header )buf;
	582	int result;
	583
	584	/* Checks own + broadcast as well as own + multicast. */
	585	result = (pThis->RcvCmd.adr_match >= EL_ADRM_BCAST) && !memcmp(hdr->ether_dhost, pThis->aStationAddr, 6);
	586
	587	return result;
	588	}
	589
	590
	591	/**
	592	* Check if incoming frame is an accepted broadcast frame.
	593	*/
	594	DECLINLINE(int) padr_bcast(PELNKSTATE pThis, const uint8_t *buf)
	595	{
	596	static uint8_t aBCAST[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
	597	struct ether_header hdr = (struct ether_header )buf;
	598	int result = (pThis->RcvCmd.adr_match == EL_ADRM_BCAST) && !memcmp(hdr->ether_dhost, aBCAST, 6);
	599	return result;
	600	}
	601
	602
	603	/**
	604	* Check if incoming frame is an accepted multicast frame.
	605	*/
	606	DECLINLINE(int) padr_mcast(PELNKSTATE pThis, const uint8_t *buf)
	607	{
	608	struct ether_header hdr = (struct ether_header )buf;
	609	int result = (pThis->RcvCmd.adr_match == EL_ADRM_MCAST) && ETHER_IS_MULTICAST(hdr->ether_dhost);
	610	return result;
	611	}
	612
	613
	614	/**
	615	* Update the device IRQ line based on internal state.
	616	*/
[93601]	617	static void elnkUpdateIrq(PPDMDEVINS pDevIns, PELNKSTATE pThis)
[93560]	618	{
	619	bool fISR = false;
	620
	621	STAM_PROFILE_ADV_START(&pThis->StatInterrupt, a);
	622
	623	/* IRQ is active if any interrupt source is active and interrupts
	624	* are enabled via RIDE or IRE.
	625	*/
	626	if (pThis->IntrStateReg && (pThis->AuxCmd.ride \|\| pThis->AuxCmd.ire))
	627	fISR = true;
	628
[93601]	629	Log2(("#%d set irq fISR=%d\n", pThis->iInstance, fISR));
[93560]	630
	631	/* The IRQ line typically does not change. */
	632	if (RT_UNLIKELY(fISR != pThis->fISR))
	633	{
[93601]	634	Log(("#%d IRQ=%d, state=%d\n", pThis->iInstance, pThis->uIsaIrq, fISR));
	635	PDMDevHlpISASetIrq(pDevIns, pThis->uIsaIrq, fISR);
[93560]	636	pThis->fISR = fISR;
	637	}
	638	STAM_PROFILE_ADV_STOP(&pThis->StatInterrupt, a);
	639	}
	640
	641
	642	/**
	643	* Perform a software reset of the NIC.
	644	*/
[93601]	645	static void elnkSoftReset(PPDMDEVINS pDevIns, PELNKSTATE pThis)
[93560]	646	{
[93601]	647	LogFlowFunc(("#%d:\n", pThis->iInstance));
[93560]	648
	649	/* Clear some of the user-visible register state. */
	650	pThis->XmitCmdReg = 0;
	651	pThis->XmitStatReg = 0;
	652	pThis->RcvCmdReg = 0;
	653	pThis->RcvStatReg = 0;
	654	pThis->AuxCmdReg = 0;
	655	pThis->AuxStatReg = 0;
	656
	657	/* The "stale receive status" is cleared by receiving an "interesting" packet. */
	658	pThis->RcvStat.stale = 1;
	659
	660	/* By virtue of setting the buffer control to system, transmit is set to busy. */
	661	pThis->AuxStat.xmit_bsy = 1;
	662
	663	/* Clear internal interrupt state. */
	664	pThis->IntrStateReg = 0;
[93601]	665	elnkUpdateIrq(pDevIns, pThis);
[93560]	666
	667	/* Note that a soft reset does not clear the packet buffer; software often
	668	* assumes that it survives soft reset. The programmed station address is
	669	* likewise not reset, and the buffer pointers are not reset either.
	670	* Verified on a real 3C501.
	671	*/
	672
	673	/* No longer in reset state. */
	674	pThis->fInReset = false;
	675	}
	676
	677	#ifdef IN_RING3
	678
	679	static DECLCALLBACK(void) elnkR3WakeupReceive(PPDMDEVINS pDevIns)
	680	{
[93601]	681	PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
[93560]	682	STAM_COUNTER_INC(&pThis->StatRxOverflowWakeup);
	683	if (pThis->hEventOutOfRxSpace != NIL_RTSEMEVENT)
	684	RTSemEventSignal(pThis->hEventOutOfRxSpace);
	685	}
	686
	687	/**
	688	* @callback_method_impl{FNPDMTASKDEV,
	689	* Signal to R3 that NIC is ready to receive a packet.
	690	*/
	691	static DECLCALLBACK(void) elnkR3CanRxTaskCallback(PPDMDEVINS pDevIns, void *pvUser)
	692	{
	693	RT_NOREF(pvUser);
	694	elnkR3WakeupReceive(pDevIns);
	695	}
	696
	697	#endif /* IN_RING3 */
	698
	699
	700	/**
	701	* Write incoming data into the packet buffer.
	702	*/
[93601]	703	static void elnkReceiveLocked(PPDMDEVINS pDevIns, PELNKSTATE pThis, const uint8_t *src, size_t cbToRecv, bool fLoopback)
[93560]	704	{
	705	int is_padr = 0, is_bcast = 0, is_mcast = 0;
	706	union {
	707	uint8_t RcvStatNewReg;
	708	EL_RCV_STAT RcvStatNew;
	709	};
	710
	711	/*
	712	* Drop all packets if the VM is not running yet/anymore.
	713	*/
	714	VMSTATE enmVMState = PDMDevHlpVMState(pDevIns);
	715	if ( enmVMState != VMSTATE_RUNNING
	716	&& enmVMState != VMSTATE_RUNNING_LS)
	717	{
	718	STAM_COUNTER_INC(&pThis->StatDropPktVMNotRunning);
	719	return;
	720	}
	721
	722	/* Drop everything if address matching is disabled. */
	723	if (RT_UNLIKELY(pThis->RcvCmd.adr_match == EL_ADRM_DISABLED))
	724	{
	725	STAM_COUNTER_INC(&pThis->StatDropPktAdrmDis);
	726	return;
	727	}
	728
	729	/* Drop zero-length packets (how does that even happen?). */
	730	if (RT_UNLIKELY(!cbToRecv))
	731	{
	732	STAM_COUNTER_INC(&pThis->StatDropPktZeroLen);
	733	return;
	734	}
	735
	736	/*
	737	* Drop all packets if the cable is not connected (and not in loopback).
	738	*/
	739	if (RT_UNLIKELY(!elnkIsLinkUp(pThis) && !fLoopback))
	740	{
	741	STAM_COUNTER_INC(&pThis->StatDropPktNoLink);
	742	return;
	743	}
	744
	745	/*
	746	* Do not receive further packets until receive status was read.
	747	*/
	748	if (RT_UNLIKELY(pThis->RcvStat.stale == 0))
	749	{
	750	STAM_COUNTER_INC(&pThis->StatDropPktStaleRcv);
	751	return;
	752	}
	753
[93601]	754	LogFlowFunc(("#%d: size on wire=%d, RCV ptr=%u\n", pThis->iInstance, cbToRecv, pThis->uRCVBufPtr));
[93560]	755
	756	/*
	757	* Perform address matching. Packets which do not pass the address
	758	* filter are always ignored.
	759	*/
	760	/// @todo cbToRecv must be 6 or more (complete address)
	761	if ( pThis->RcvCmd.adr_match == EL_ADRM_PROMISC /* promiscuous enabled */
	762	\|\| (is_padr = padr_match(pThis, src))
	763	\|\| (is_bcast = padr_bcast(pThis, src))
	764	\|\| (is_mcast = padr_mcast(pThis, src)))
	765	{
	766	uint8_t *dst = pThis->abPacketBuf + pThis->uRCVBufPtr;
	767
[93601]	768	Log2Func(("#%d Packet passed address filter (is_padr=%d, is_bcast=%d, is_mcast=%d), size=%d\n", pThis->iInstance, cbToRecv, is_padr, is_bcast, is_mcast));
[93560]	769
	770	/* Receive status is evaluated from scratch. The stale bit must remain set until we know better. */
	771	RcvStatNewReg = 0;
	772	RcvStatNew.stale = 1;
	773	pThis->RcvStatReg = 0x80;
	774
	775	/* Detect errors: Runts, overflow, and FCS errors.
	776	* NB: Dribble errors can not happen because we can only receive an
	777	* integral number of bytes. FCS errors are only possible in loopback
	778	* mode in case the FCS is deliberately corrupted.
	779	*/
	780
	781	/* See if we need to pad, and how much. Have to be careful because the
	782	* Receive Buffer Pointer might be near the end of the buffer.
	783	*/
	784	if (RT_UNLIKELY(cbToRecv < 60))
	785	{
	786	/* In loopback mode only, short packets are flagged as errors because
	787	* diagnostic tools want to see the errors. Otherwise they're padded to
	788	* minimum length (if packet came over the wire, it should have been
	789	* properly padded).
	790	*/
	791	/// @todo This really is kind of wrong. We shouldn't be doing any
	792	/// padding here, it should be done by the sending side!
	793	if (!fLoopback)
	794	{
	795	memset(pThis->abRuntBuf, 0, sizeof(pThis->abRuntBuf));
	796	memcpy(pThis->abRuntBuf, src, cbToRecv);
	797	cbToRecv = 60;
	798	src = pThis->abRuntBuf;
	799	}
	800	else
	801	{
[93601]	802	LogFunc(("#%d runt, size=%d\n", pThis->iInstance, cbToRecv));
[93560]	803	RcvStatNew.runt = 1;
	804	}
	805	}
	806
	807	/* We don't care how big the frame is; if it fits into the buffer, all is
	808	* good. But conversely if the Receive Buffer Pointer is initially near the
	809	* end of the buffer, a small frame can trigger an overflow.
	810	*/
	811	if (pThis->uRCVBufPtr + cbToRecv <= ELNK_BUF_SIZE)
	812	{
	813	RcvStatNew.no_ovf = 1;
	814	}
	815	else
	816	{
[93601]	817	LogFunc(("#%d overflow, size=%d\n", pThis->iInstance, cbToRecv));
[93560]	818	RcvStatNew.oflow = 1;
	819	}
	820
	821	if (fLoopback && pThis->AuxCmd.xmit_bf)
	822	{
[93601]	823	LogFunc(("#%d bad FCS\n", pThis->iInstance));
[93560]	824	RcvStatNew.fcs = 1;
	825	}
	826
	827	/* Error-free packets are considered good. */
	828	if (RcvStatNew.no_ovf && !RcvStatNew.fcs && !RcvStatNew.runt)
	829	RcvStatNew.good = 1;
	830
	831	uint16_t cbCopy = (uint16_t)RT_MIN(ELNK_BUF_SIZE - pThis->uRCVBufPtr, cbToRecv);
	832
	833	/* All packets that passed the address filter are copied to the buffer. */
	834
	835	STAM_REL_COUNTER_ADD(&pThis->StatReceiveBytes, cbCopy);
	836
	837	/* Copy incoming data to the packet buffer. NB: Starts at the current
	838	* Receive Buffer Pointer position.
	839	*/
	840	memcpy(dst, src, cbCopy);
	841
	842	/* Packet length is indicated via the receive buffer pointer. */
	843	pThis->uRCVBufPtr = (pThis->uRCVBufPtr + cbCopy) & ELNK_GP_MASK;
	844
	845	Log2Func(("Received packet, size=%d, RP=%u\n", cbCopy, pThis->uRCVBufPtr));
	846
	847	/*
	848	* If one of the "interesting" conditions was hit, stop receiving until
	849	* the status register is read (mark it not stale).
	850	* NB: The precise receive logic is not very well described in the EtherLink
	851	* documentation. It was refined using the 3C501.EXE diagnostic utility.
	852	*/
	853	if ( (RcvStatNew.good && pThis->RcvCmd.acpt_good)
	854	\|\| (RcvStatNew.no_ovf && pThis->RcvCmd.det_eof)
	855	\|\| (RcvStatNew.runt && pThis->RcvCmd.det_runt)
	856	\|\| (RcvStatNew.dribble && pThis->RcvCmd.det_drbl)
	857	\|\| (RcvStatNew.fcs && pThis->RcvCmd.det_fcs)
	858	\|\| (RcvStatNew.oflow && pThis->RcvCmd.det_ofl))
	859	{
	860	pThis->AuxStat.recv_bsy = 0;
	861	pThis->IntrState.recv_intr = 1;
	862	RcvStatNew.stale = 0; /* Prevents further receive until set again. */
	863	}
	864	/* Finally update the receive status. */
	865	pThis->RcvStat = RcvStatNew;
	866
[93601]	867	LogFlowFunc(("#%d: RcvCmd=%02X, RcvStat=%02X, RCVBufPtr=%u\n", pThis->iInstance, pThis->RcvCmdReg, pThis->RcvStatReg, pThis->uRCVBufPtr));
	868	elnkUpdateIrq(pDevIns, pThis);
[93560]	869	}
	870	}
	871
	872
	873	/**
	874	* Transmit data from the packet buffer.
	875	*
	876	* @returns VBox status code. VERR_TRY_AGAIN is returned if we're busy.
	877	*
[93601]	878	* @param pDevIns The device instance.
	879	* @param pThis The EtherLink shared instance
	880	* data.
	881	* @param pThisCC The EtherLink state data for the
	882	* current context.
[93560]	883	* @param fOnWorkerThread Whether we're on a worker thread or on an EMT.
	884	*/
[93601]	885	static int elnkXmitBuffer(PPDMDEVINS pDevIns, PELNKSTATE pThis, PELNKSTATECC pThisCC, bool fOnWorkerThread)
[93560]	886	{
	887	RT_NOREF_PV(fOnWorkerThread);
	888	int rc;
	889
	890	/*
	891	* Grab the xmit lock of the driver as well as the 3C501 device state.
	892	*/
[93601]	893	PPDMINETWORKUP pDrv = pThisCC->pDrv;
[93560]	894	if (pDrv)
	895	{
	896	rc = pDrv->pfnBeginXmit(pDrv, false /fOnWorkerThread/);
	897	if (RT_FAILURE(rc))
	898	return rc;
	899	}
	900	rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
	901	if (RT_SUCCESS(rc))
	902	{
	903	/** @todo check if we're supposed to suspend now. */
	904	/*
	905	* Do the transmitting.
	906	*/
[93601]	907	int rc2 = elnkAsyncTransmit(pDevIns, pThis, pThisCC, false /fOnWorkerThread/);
[93560]	908	AssertReleaseRC(rc2);
	909
	910	/*
	911	* Release the locks.
	912	*/
	913	PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
	914	}
	915	else
	916	AssertLogRelRC(rc);
	917	if (pDrv)
	918	pDrv->pfnEndXmit(pDrv);
	919
	920	return rc;
	921	}
	922
	923
	924	#ifdef IN_RING3
	925
	926	/**
	927	* @callback_method_impl{FNPDMTASKDEV,
	928	* This is just a very simple way of delaying sending to R3.
	929	*/
	930	static DECLCALLBACK(void) elnkR3XmitTaskCallback(PPDMDEVINS pDevIns, void *pvUser)
	931	{
[93601]	932	PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
	933	PELNKSTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PELNKSTATECC);
[93560]	934	NOREF(pvUser);
	935
	936	/*
	937	* Transmit if we can.
	938	*/
[93601]	939	elnkXmitBuffer(pDevIns, pThis, pThisCC, true /fOnWorkerThread/);
[93560]	940	}
	941	#endif /* IN_RING3 */
	942
	943
	944	/**
	945	* Allocates a scatter/gather buffer for a transfer.
	946	*
	947	* @returns See PPDMINETWORKUP::pfnAllocBuf.
[93601]	948	* @param pThis The shared state data.
	949	* @param pThisCC The current context state data.
[93560]	950	* @param cbMin The minimum buffer size.
	951	* @param fLoopback Set if we're in loopback mode.
	952	* @param pSgLoop Pointer to stack storage for the loopback SG.
	953	* @param ppSgBuf Where to return the SG buffer descriptor on success.
	954	* Always set.
	955	*/
[93601]	956	DECLINLINE(int) elnkXmitAllocBuf(PELNKSTATE pThis, PELNKSTATECC pThisCC, size_t cbMin, bool fLoopback,
[93560]	957	PPDMSCATTERGATHER pSgLoop, PPPDMSCATTERGATHER ppSgBuf)
	958	{
	959	int rc;
	960
	961	if (!fLoopback)
	962	{
[93601]	963	PPDMINETWORKUP pDrv = pThisCC->pDrv;
[93560]	964	if (RT_LIKELY(pDrv))
	965	{
	966	rc = pDrv->pfnAllocBuf(pDrv, cbMin, NULL /pGso/, ppSgBuf);
	967	AssertMsg(rc == VINF_SUCCESS \|\| rc == VERR_TRY_AGAIN \|\| rc == VERR_NET_DOWN \|\| rc == VERR_NO_MEMORY, ("%Rrc\n", rc));
	968	if (RT_FAILURE(rc))
	969	*ppSgBuf = NULL;
	970	}
	971	else
	972	{
	973	rc = VERR_NET_DOWN;
	974	*ppSgBuf = NULL;
	975	}
	976	}
	977	else
	978	{
	979	/* Fake loopback allocator. */
	980	pSgLoop->fFlags = PDMSCATTERGATHER_FLAGS_MAGIC \| PDMSCATTERGATHER_FLAGS_OWNER_1;
	981	pSgLoop->cbUsed = 0;
	982	pSgLoop->cbAvailable = sizeof(pThis->abLoopBuf);
	983	pSgLoop->pvAllocator = pThis;
	984	pSgLoop->pvUser = NULL;
	985	pSgLoop->cSegs = 1;
	986	pSgLoop->aSegs[0].cbSeg = sizeof(pThis->abLoopBuf);
	987	pSgLoop->aSegs[0].pvSeg = pThis->abLoopBuf;
	988	*ppSgBuf = pSgLoop;
	989	rc = VINF_SUCCESS;
	990	}
	991	return rc;
	992	}
	993
	994
	995	/**
	996	* Sends the scatter/gather buffer.
	997	*
	998	* Wrapper around PDMINETWORKUP::pfnSendBuf, so check it out for the fine print.
	999	*
	1000	* @returns See PDMINETWORKUP::pfnSendBuf.
[93601]	1001	* @param pDevIns The device instance.
	1002	* @param pThis The shared EtherLink state data.
	1003	* @param pThisCC The current context state data.
[93560]	1004	* @param fLoopback Set if we're in loopback mode.
	1005	* @param pSgBuf The SG to send.
	1006	* @param fOnWorkerThread Set if we're being called on a work thread. Clear
	1007	* if an EMT.
	1008	*/
[93601]	1009	DECLINLINE(int) elnkXmitSendBuf(PPDMDEVINS pDevIns, PELNKSTATE pThis, PELNKSTATECC pThisCC, bool fLoopback, PPDMSCATTERGATHER pSgBuf, bool fOnWorkerThread)
[93560]	1010	{
	1011	int rc;
	1012	STAM_REL_COUNTER_ADD(&pThis->StatTransmitBytes, pSgBuf->cbUsed);
	1013	if (!fLoopback)
	1014	{
	1015	STAM_PROFILE_START(&pThis->CTX_SUFF_Z(StatTransmitSend), a);
	1016	if (pSgBuf->cbUsed > 70) /* unqualified guess */
	1017	pThis->Led.Asserted.s.fWriting = pThis->Led.Actual.s.fWriting = 1;
	1018
[93601]	1019	PPDMINETWORKUP pDrv = pThisCC->pDrv;
[93560]	1020	if (RT_LIKELY(pDrv))
	1021	{
	1022	rc = pDrv->pfnSendBuf(pDrv, pSgBuf, fOnWorkerThread);
	1023	AssertMsg(rc == VINF_SUCCESS \|\| rc == VERR_NET_DOWN \|\| rc == VERR_NET_NO_BUFFER_SPACE, ("%Rrc\n", rc));
	1024	}
	1025	else
	1026	rc = VERR_NET_DOWN;
	1027
	1028	pThis->Led.Actual.s.fWriting = 0;
	1029	STAM_PROFILE_STOP(&pThis->CTX_SUFF_Z(StatTransmitSend), a);
	1030	}
	1031	else
	1032	{
	1033	/* Loopback, immediately send buffer to the receive path. */
	1034	Assert(pSgBuf->pvAllocator == (void *)pThis);
	1035	pThis->Led.Asserted.s.fReading = pThis->Led.Actual.s.fReading = 1;
	1036
[93601]	1037	LogFlowFunc(("#%d: loopback (%u bytes)\n", pThis->iInstance, pSgBuf->cbUsed));
	1038	elnkReceiveLocked(pDevIns, pThis, pThis->abLoopBuf, pSgBuf->cbUsed, fLoopback);
[93560]	1039	pThis->Led.Actual.s.fReading = 0;
	1040	rc = VINF_SUCCESS;
	1041	}
	1042	return rc;
	1043	}
	1044
	1045
	1046	/**
	1047	* Reads the entire frame into the scatter gather buffer.
	1048	*/
	1049	DECLINLINE(void) elnkXmitRead(PPDMDEVINS pDevIns, PELNKSTATE pThis, const unsigned cbFrame, PPDMSCATTERGATHER pSgBuf)
	1050	{
	1051	Assert(PDMDevHlpCritSectIsOwner(pDevIns, &pThis->CritSect)); RT_NOREF(pDevIns);
	1052	Assert(pSgBuf->cbAvailable >= cbFrame);
	1053
	1054	pSgBuf->cbUsed = cbFrame;
	1055	memcpy(pSgBuf->aSegs[0].pvSeg, &pThis->abPacketBuf[ELNK_GP(pThis)], cbFrame);
	1056	}
	1057
	1058	/**
	1059	* Try to transmit a frame.
	1060	*/
[93601]	1061	static void elnkTransmit(PPDMDEVINS pDevIns, PELNKSTATE pThis)
[93560]	1062	{
[93601]	1063	PELNKSTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PELNKSTATECC);
	1064
[93560]	1065	/*
	1066	* Transmit the packet if possible, defer it if we cannot do it
	1067	* in the current context.
	1068	*/
	1069	#if defined(IN_RING0) \|\| defined(IN_RC)
[93601]	1070	if (!pThisCC->pDrv)
[93560]	1071	{
[93601]	1072	int rc = PDMDevHlpTaskTrigger(pDevIns, pThis->hXmitTask);
[93560]	1073	AssertRC(rc);
	1074	}
	1075	else
	1076	#endif
	1077	{
[93601]	1078	int rc = elnkXmitBuffer(pDevIns, pThis, pThisCC, false /fOnWorkerThread/);
[93560]	1079	if (rc == VERR_TRY_AGAIN)
	1080	rc = VINF_SUCCESS;
	1081	AssertRC(rc);
	1082	}
	1083	}
	1084
	1085
	1086	/**
	1087	* If a packet is waiting, poke the receiving machinery.
	1088	*
	1089	* @threads EMT.
	1090	*/
[93601]	1091	static void elnkKickReceive(PPDMDEVINS pDevIns, PELNKSTATE pThis)
[93560]	1092	{
	1093	/* Some drivers (e.g. NetWare IPX shell/ODI drivers) first go to receive mode through
	1094	* the aux command register and only then enable address matching.
	1095	*/
	1096	if ((pThis->AuxStat.recv_bsy == 1) && (pThis->RcvCmd.adr_match != EL_ADRM_DISABLED))
	1097	{
	1098	if (pThis->fMaybeOutOfSpace)
	1099	{
	1100	#ifdef IN_RING3
[93601]	1101	elnkR3WakeupReceive(pDevIns);
[93560]	1102	#else
[93601]	1103	int rc = PDMDevHlpTaskTrigger(pDevIns, pThis->hCanRxTask);
[93560]	1104	AssertRC(rc);
	1105	#endif
	1106	}
	1107	}
	1108
	1109	}
	1110
	1111	/**
	1112	* Try transmitting a frame.
	1113	*
	1114	* @threads TX or EMT.
	1115	*/
[93601]	1116	static int elnkAsyncTransmit(PPDMDEVINS pDevIns, PELNKSTATE pThis, PELNKSTATECC pThisCC, bool fOnWorkerThread)
[93560]	1117	{
	1118	Assert(PDMDevHlpCritSectIsOwner(pDevIns, &pThis->CritSect));
	1119
	1120	/*
	1121	* Just drop it if not transmitting. Can happen with delayed transmits
	1122	* if transmit was disabled in the meantime.
	1123	*/
	1124	if (RT_UNLIKELY(!pThis->AuxStat.xmit_bsy))
	1125	{
[93601]	1126	LogFunc(("#%d: Nope, xmit disabled (fOnWorkerThread=%RTbool)\n", pThis->iInstance, fOnWorkerThread));
[93560]	1127	return VINF_SUCCESS;
	1128	}
	1129
	1130	if (RT_UNLIKELY((pThis->AuxCmd.buf_ctl != EL_BCTL_XMT_RCV) && (pThis->AuxCmd.buf_ctl != EL_BCTL_LOOPBACK)))
	1131	{
[93601]	1132	LogFunc(("#%d: Nope, not in xmit-then-receive or loopback state (fOnWorkerThread=%RTbool)\n", pThis->iInstance, fOnWorkerThread));
[93560]	1133	return VINF_SUCCESS;
	1134	}
	1135
	1136	/*
	1137	* Blast out data from the packet buffer.
	1138	*/
	1139	int rc;
	1140	STAM_PROFILE_ADV_START(&pThis->CTX_SUFF_Z(StatTransmit), a);
	1141	do
	1142	{
	1143	/* Don't send anything when the link is down. */
	1144	if (RT_UNLIKELY( !elnkIsLinkUp(pThis)
	1145	&& pThis->cLinkDownReported > ELNK_MAX_LINKDOWN_REPORTED)
	1146	)
	1147	break;
	1148
	1149	bool const fLoopback = pThis->AuxCmd.buf_ctl == EL_BCTL_LOOPBACK;
	1150	PDMSCATTERGATHER SgLoop;
	1151	PPDMSCATTERGATHER pSgBuf;
	1152
	1153	/*
	1154	* Sending is easy peasy, there is by definition always
	1155	* a complete packet on hand.
	1156	*/
	1157	const unsigned cb = ELNK_BUF_SIZE - ELNK_GP(pThis); /* Packet size. */
[93601]	1158	LogFunc(("#%d: cb=%d\n", pThis->iInstance, cb));
[93560]	1159
	1160	pThis->XmitStatReg = 0; /* Clear transmit status before filling it out. */
	1161
	1162	if (RT_LIKELY(elnkIsLinkUp(pThis) \|\| fLoopback))
	1163	{
	1164	if (RT_LIKELY(cb <= MAX_FRAME))
	1165	{
[93601]	1166	rc = elnkXmitAllocBuf(pThis, pThisCC, cb, fLoopback, &SgLoop, &pSgBuf);
[93560]	1167	if (RT_SUCCESS(rc))
	1168	{
	1169	elnkXmitRead(pDevIns, pThis, cb, pSgBuf);
[93601]	1170	rc = elnkXmitSendBuf(pDevIns, pThis, pThisCC, fLoopback, pSgBuf, fOnWorkerThread);
	1171	Log2Func(("#%d: rc=%Rrc\n", pThis->iInstance, rc));
[93560]	1172	}
	1173	else if (rc == VERR_TRY_AGAIN)
	1174	{
	1175	STAM_PROFILE_ADV_STOP(&pThis->CTX_SUFF_Z(StatTransmit), a);
[93601]	1176	LogFunc(("#%d: rc=%Rrc\n", pThis->iInstance, rc));
[93560]	1177	return VINF_SUCCESS;
	1178	}
	1179	if (RT_SUCCESS(rc))
	1180	pThis->XmitStat.ready = 1;
	1181	else
	1182	pThis->XmitStat.coll = 1; /* Pretend there was a collision. */
	1183	}
	1184	else
	1185	{
	1186	/* Signal error, as this violates the Ethernet specs. */
	1187	/** @todo check if the correct error is generated. */
[93601]	1188	LogRel(("3C501#%d: illegal giant frame (%u bytes) -> signalling error\n", pThis->iInstance, cb));
[93560]	1189	}
	1190	}
	1191	else
	1192	{
	1193	/* Signal a transmit error pretending there was a collision. */
[93601]	1194	pThis->cLinkDownReported++;
[93560]	1195	pThis->XmitStat.coll = 1;
	1196	}
	1197	/* Transmit officially done, update register state. */
	1198	pThis->AuxStat.xmit_bsy = 0;
	1199	pThis->IntrState.xmit_intr = !!(pThis->XmitCmdReg & pThis->XmitStatReg);
[93601]	1200	LogFlowFunc(("#%d: XmitCmd=%02X, XmitStat=%02X\n", pThis->iInstance, pThis->XmitCmdReg, pThis->XmitStatReg));
[93560]	1201
	1202	/* NB: After a transmit, the GP Buffer Pointer points just past
	1203	* the end of the packet buffer (3C501 diagnostics).
	1204	*/
[93601]	1205	pThis->uGPBufPtr = ELNK_BUF_SIZE;
[93560]	1206
	1207	/* NB: The buffer control does not change to Receive and stays the way it was. */
	1208	if (RT_UNLIKELY(!fLoopback))
	1209	{
	1210	pThis->AuxStat.recv_bsy = 1; /* Receive Busy now set until a packet is received. */
[93601]	1211	elnkKickReceive(pDevIns, pThis);
[93560]	1212	}
	1213	} while (0); /* No loop, because there isn't ever more than one packet to transmit. */
	1214
[93601]	1215	elnkUpdateIrq(pDevIns, pThis);
[93560]	1216
	1217	STAM_PROFILE_ADV_STOP(&pThis->CTX_SUFF_Z(StatTransmit), a);
	1218
	1219	return VINF_SUCCESS;
	1220	}
	1221
	1222	/* -=-=-=-=-=- I/O Port access -=-=-=-=-=- */
	1223
	1224
[93601]	1225	static int elnkCsrWrite(PPDMDEVINS pDevIns, PELNKSTATE pThis, uint8_t data)
[93560]	1226	{
	1227	int rc = VINF_SUCCESS;
	1228	bool fTransmit = false;
	1229	bool fReceive = false;
	1230	bool fDMAR;
	1231	union {
	1232	uint8_t reg;
	1233	EL_AUX_CMD val;
	1234	};
	1235
	1236	reg = data;
	1237
	1238	/* Handle reset first. */
	1239	if (pThis->AuxCmd.reset != val.reset)
	1240	{
	1241	if (val.reset)
	1242	{
	1243	/* Card is placed into reset. Just set the flag. NB: When in reset
	1244	* state, we permit writes to other registers, but those have no
	1245	* effect and will be overwritten when the card is taken out of reset.
	1246	*/
[93601]	1247	LogFunc(("#%d: Card going into reset\n", pThis->iInstance));
[93560]	1248	pThis->fInReset = true;
	1249
	1250	/* Many EtherLink drivers like to reset the card a lot. That can lead to
	1251	* packet loss if a packet was already received before the card was reset.
	1252	*/
	1253	if (RT_UNLIKELY(!pThis->RcvStat.stale))
	1254	STAM_REL_COUNTER_INC(&pThis->StatPktsLostReset);
	1255	}
	1256	else
	1257	{
	1258	/* Card is being taken out of reset. */
[93601]	1259	LogFunc(("#%d: Card going out of reset\n", pThis->iInstance));
[93560]	1260	STAM_COUNTER_INC(&pThis->StatResets);
[93601]	1261	elnkSoftReset(pDevIns, pThis);
[93560]	1262	}
	1263	pThis->AuxCmd.reset = val.reset; /* Update the reset bit, if nothing else. */
	1264	}
	1265
	1266	/* If the card is in reset, stop right here. */
	1267	if (pThis->fInReset)
	1268	return rc;
	1269
	1270	/* Evaluate DMA state. If it changed, we'll have to go back to R3. */
	1271	fDMAR = val.dma_req && val.ride;
	1272	if (fDMAR != pThis->fDMA)
	1273	#ifdef IN_RING3
	1274	{
	1275	/* Start/stop DMA as requested. */
	1276	pThis->fDMA = fDMAR;
[93601]	1277	PDMDevHlpDMASetDREQ(pDevIns, pThis->uIsaDma, fDMAR);
[93560]	1278	if (fDMAR)
[93601]	1279	PDMDevHlpDMASchedule(pDevIns);
	1280	Log(("3C501#%d: DMARQ for channel %u set to %u\n", pThis->iInstance, pThis->uIsaDma, fDMAR));
[93560]	1281	}
	1282	#else
	1283	return VINF_IOM_R3_IOPORT_WRITE;
	1284	#endif
	1285
	1286	/* Interrupt enable changes. */
	1287	if ((pThis->AuxCmd.ire != val.ire) \|\| (pThis->AuxCmd.ride != val.ride))
	1288	{
	1289	pThis->AuxStat.ride = pThis->AuxCmd.ride = val.ride;
	1290	pThis->AuxCmd.ire = val.ire; /* NB: IRE is not visible in the aux status register. */
	1291	}
	1292
	1293	/* DMA Request changes. */
	1294	if (pThis->AuxCmd.dma_req != val.dma_req)
	1295	{
	1296	pThis->AuxStat.dma_req = pThis->AuxCmd.dma_req = val.dma_req;
	1297	if (!val.dma_req)
	1298	{
	1299	/* Clearing the DMA Request bit also clears the DMA Done status bit and any DMA interrupt. */
	1300	pThis->IntrState.dma_intr = 0;
	1301	pThis->AuxStat.dma_done = 0;
	1302	}
	1303	}
	1304
	1305	/* Packet buffer control changes. */
	1306	if (pThis->AuxCmd.buf_ctl != val.buf_ctl)
	1307	{
	1308	#ifdef LOG_ENABLED
	1309	static const char *apszBuffCntrl[4] = { "System", "Xmit then Recv", "Receive", "Loopback" };
[93601]	1310	Log(("3C501#%d: Packet buffer control `%s' -> `%s'\n", pThis->iInstance, apszBuffCntrl[pThis->AuxCmd.buf_ctl], apszBuffCntrl[val.buf_ctl]));
[93560]	1311	#endif
	1312	if (val.buf_ctl == EL_BCTL_XMT_RCV)
	1313	{
	1314	/* Transmit, then receive. */
[93601]	1315	Log2(("3C501#%d: Transmit %u bytes\n%Rhxs\nxmit_bsy=%u\n", pThis->iInstance, ELNK_BUF_SIZE - pThis->uGPBufPtr, &pThis->abPacketBuf[pThis->uGPBufPtr], pThis->AuxStat.xmit_bsy));
[93560]	1316	fTransmit = true;
	1317	pThis->AuxStat.recv_bsy = 0;
	1318	}
	1319	else if (val.buf_ctl == EL_BCTL_SYSTEM)
	1320	{
	1321	pThis->AuxStat.xmit_bsy = 1; /* Transmit Busy is set here and cleared once actual transmit completes. */
	1322	pThis->AuxStat.recv_bsy = 0;
	1323	}
	1324	else if (val.buf_ctl == EL_BCTL_RECEIVE)
	1325	{
	1326	/* Special case: If going from xmit-then-receive mode to receive mode, and we received
	1327	* a packet already (right after the receive), don't restart receive and lose the already
	1328	* received packet.
	1329	*/
	1330	if (!pThis->uRCVBufPtr)
	1331	fReceive = true;
	1332	}
	1333	else
	1334	{
	1335	/* For loopback, we go through the regular transmit and receive path. That may be an
	1336	* overkill but the receive path is too complex for a special loopback-only case.
	1337	*/
	1338	fTransmit = true;
	1339	pThis->AuxStat.recv_bsy = 1; /* Receive Busy now set until a packet is received. */
	1340	}
	1341	pThis->AuxStat.buf_ctl = pThis->AuxCmd.buf_ctl = val.buf_ctl;
	1342	}
	1343
	1344	/* NB: Bit 1 (xmit_bf, transmit packets with bad FCS) is a simple control
	1345	* bit which does not require special handling here. Just copy it over.
	1346	*/
	1347	pThis->AuxStat.xmit_bf = pThis->AuxCmd.xmit_bf = val.xmit_bf;
	1348
	1349	/* There are multiple bits that affect interrupt state. Handle them now. */
[93601]	1350	elnkUpdateIrq(pDevIns, pThis);
[93560]	1351
	1352	/* After fully updating register state, do a transmit (including loopback) or receive. */
	1353	if (fTransmit)
[93601]	1354	elnkTransmit(pDevIns, pThis);
[93560]	1355	else if (fReceive)
	1356	{
	1357	pThis->AuxStat.recv_bsy = 1; /* Receive Busy now set until a packet is received. */
[93601]	1358	elnkKickReceive(pDevIns, pThis);
[93560]	1359	}
	1360
	1361	return rc;
	1362	}
	1363
[93601]	1364	static int elIoWrite(PPDMDEVINS pDevIns, PELNKSTATE pThis, uint32_t addr, uint32_t val)
[93560]	1365	{
	1366	int reg = addr & 0xf;
	1367	int rc = VINF_SUCCESS;
	1368
[93601]	1369	Log2Func(("#%d: addr=%#06x val=%#04x\n", pThis->iInstance, addr, val & 0xff));
[93560]	1370
	1371	switch (reg)
	1372	{
	1373	case 0x00: /* Six bytes of station address. */
	1374	case 0x01:
	1375	case 0x02:
	1376	case 0x03:
	1377	case 0x04:
	1378	case 0x05:
	1379	pThis->aStationAddr[reg] = val;
	1380	break;
	1381
	1382	case 0x06: /* Receive command. */
	1383	{
	1384	EL_RCV_CMD OldRcvCmd = pThis->RcvCmd;
	1385
	1386	pThis->RcvCmdReg = val;
	1387	/* If address filter just got enabled, receive may need a kick. */
	1388	if (OldRcvCmd.adr_match == EL_ADRM_DISABLED && pThis->RcvCmd.adr_match != EL_ADRM_DISABLED)
[93601]	1389	elnkKickReceive(pDevIns, pThis);
[93560]	1390	Log2(("Receive Command register set to %02X\n", pThis->RcvCmdReg));
	1391	break;
	1392	}
	1393
	1394	case 0x07: /* Transmit command. */
	1395	pThis->XmitCmdReg = val;
	1396	Log2(("Transmit Command register set to %02X\n", pThis->XmitCmdReg));
	1397	break;
	1398
	1399	case 0x08: /* GP Buffer pointer LSB. */
	1400	pThis->uGPBufPtr = (pThis->uGPBufPtr & 0xff00) \| (uint8_t)val;
	1401	Log2(("GP Buffer Pointer LSB write, now %u\n", pThis->uGPBufPtr));
	1402	break;
	1403
	1404	case 0x09: /* GP Buffer pointer MSB. */
	1405	pThis->uGPBufPtr = ((uint8_t)val << 8) \| RT_LOBYTE(pThis->uGPBufPtr);
	1406	Log2(("GP Buffer Pointer MSB write, now %u\n", pThis->uGPBufPtr));
	1407	break;
	1408
	1409	case 0x0a: /* RCV Buffer pointer clear. */
	1410	pThis->uRCVBufPtr = 0;
	1411	Log2(("RCV Buffer Pointer cleared (%02X)\n", val));
	1412	break;
	1413
	1414	case 0x0b: /* RCV buffer pointer MSB. */
	1415	case 0x0c: /* Ethernet address PROM window. */
	1416	case 0x0d: /* Undocumented. */
	1417	Log(("Writing read-only register %02X!\n", reg));
	1418	break;
	1419
	1420	case 0x0e: /* Auxiliary Command (CSR). */
[93601]	1421	rc = elnkCsrWrite(pDevIns, pThis, val);
[93560]	1422	break;
	1423
	1424	case 0x0f: /* Buffer window. */
	1425	/* Writes use low 11 bits of GP buffer pointer, auto-increment. */
	1426	if (pThis->AuxCmd.buf_ctl != EL_BCTL_SYSTEM)
	1427	{
	1428	Log(("Packet buffer write ignored, buf_ctl=%u!\n", pThis->AuxCmd.buf_ctl));
	1429	/// @todo Does this still increment GPBufPtr?
	1430	break;
	1431	}
	1432	pThis->abPacketBuf[ELNK_GP(pThis)] = val;
	1433	pThis->uGPBufPtr = (pThis->uGPBufPtr + 1) & ELNK_GP_MASK;
	1434	break;
	1435	}
	1436
	1437	return rc;
	1438	}
	1439
[93601]	1440	static uint32_t elIoRead(PPDMDEVINS pDevIns, PELNKSTATE pThis, uint32_t addr, int *pRC)
[93560]	1441	{
	1442	uint32_t val = UINT32_MAX;
	1443
	1444	*pRC = VINF_SUCCESS;
	1445
	1446	switch (addr & 0x0f)
	1447	{
	1448	case 0x00: /* Receive status register aliases. The SEEQ 8001 */
	1449	case 0x02: /* EDLC clearly only decodes one bit for reads. */
	1450	case 0x04:
	1451	case 0x06: /* Receive status register. */
	1452	val = pThis->RcvStatReg;
	1453	pThis->RcvStat.stale = 1; /* Allows further reception. */
	1454	pThis->IntrState.recv_intr = 0; /* Reading clears receive interrupt. */
[93601]	1455	elnkUpdateIrq(pDevIns, pThis);
[93560]	1456	break;
	1457
	1458	case 0x01: /* Transmit status register aliases. */
	1459	case 0x03:
	1460	case 0x05:
	1461	case 0x07: /* Transmit status register. */
	1462	val = pThis->XmitStatReg;
	1463	pThis->IntrState.xmit_intr = 0; /* Reading clears transmit interrupt. */
[93601]	1464	elnkUpdateIrq(pDevIns, pThis);
[93560]	1465	break;
	1466
	1467	case 0x08: /* GP Buffer pointer LSB. */
	1468	val = RT_LOBYTE(pThis->uGPBufPtr);
	1469	break;
	1470
	1471	case 0x09: /* GP Buffer pointer MSB. */
	1472	val = RT_HIBYTE(pThis->uGPBufPtr);
	1473	break;
	1474
	1475	case 0x0a: /* RCV Buffer pointer LSB. */
	1476	val = RT_LOBYTE(pThis->uRCVBufPtr);
	1477	break;
	1478
	1479	case 0x0b: /* RCV Buffer pointer MSB. */
	1480	val = RT_HIBYTE(pThis->uRCVBufPtr);
	1481	break;
	1482
	1483	case 0x0c: /* Ethernet address PROM window. */
	1484	case 0x0d: /* Alias. */
	1485	/* Reads use low 3 bits of GP buffer pointer, no auto-increment. */
	1486	val = pThis->aPROM[pThis->uGPBufPtr & 7];
	1487	break;
	1488
	1489	case 0x0e: /* Auxiliary status register. */
	1490	val = pThis->AuxStatReg;
	1491	break;
	1492
	1493	case 0x0f: /* Buffer window. */
	1494	/* Reads use low 11 bits of GP buffer pointer, auto-increment. */
	1495	val = pThis->abPacketBuf[ELNK_GP(pThis)];
	1496	pThis->uGPBufPtr = (pThis->uGPBufPtr + 1) & ELNK_GP_MASK;
	1497	break;
	1498	}
	1499
[93601]	1500	elnkUpdateIrq(pDevIns, pThis);
[93560]	1501
[93601]	1502	Log2Func(("#%d: addr=%#06x val=%#04x\n", pThis->iInstance, addr, val & 0xff));
[93560]	1503	return val;
	1504	}
	1505
	1506
	1507	/**
	1508	* @callback_method_impl{FNIOMIOPORTIN}
	1509	*/
	1510	static DECLCALLBACK(VBOXSTRICTRC)
	1511	elnkIOPortRead(PPDMDEVINS pDevIns, void pvUser, RTIOPORT Port, uint32_t pu32, unsigned cb)
	1512	{
[93601]	1513	PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
[93560]	1514	int rc = VINF_SUCCESS;
	1515	uint8_t u8Lo, u8Hi;
	1516	STAM_PROFILE_ADV_START(&pThis->CTX_SUFF_Z(StatIORead), a);
	1517	Assert(PDMDevHlpCritSectIsOwner(pDevIns, &pThis->CritSect));
	1518	RT_NOREF_PV(pvUser);
	1519
	1520	switch (cb)
	1521	{
	1522	case 1:
[93601]	1523	*pu32 = elIoRead(pDevIns, pThis, Port, &rc);
[93560]	1524	break;
	1525	case 2:
	1526	/* Manually split word access. */
[93601]	1527	u8Lo = elIoRead(pDevIns, pThis, Port + 0, &rc);
[93560]	1528	Assert(RT_SUCCESS(rc));
[93601]	1529	u8Hi = elIoRead(pDevIns, pThis, Port + 1, &rc);
[93560]	1530	Assert(RT_SUCCESS(rc));
	1531	*pu32 = RT_MAKE_U16(u8Lo, u8Hi);
	1532	break;
	1533	default:
[93601]	1534	rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS,
[93560]	1535	"elnkIOPortRead: unsupported operation size: offset=%#10x cb=%u\n",
	1536	Port, cb);
	1537	}
	1538
[93601]	1539	Log2Func(("#%d: Port=%RTiop pu32=%#RX32 cb=%d rc=%Rrc\n", pThis->iInstance, Port, pu32, cb, rc));
[93560]	1540	STAM_PROFILE_ADV_STOP(&pThis->CTX_SUFF_Z(StatIORead), a);
	1541	return rc;
	1542	}
	1543
	1544
	1545	/**
	1546	* @callback_method_impl{FNIOMIOPORTOUT}
	1547	*/
	1548	static DECLCALLBACK(VBOXSTRICTRC)
	1549	elnkIOPortWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
	1550	{
[93601]	1551	PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
[93560]	1552	int rc = VINF_SUCCESS;
	1553	STAM_PROFILE_ADV_START(&pThis->CTX_SUFF_Z(StatIOWrite), a);
	1554	Assert(PDMDevHlpCritSectIsOwner(pDevIns, &pThis->CritSect));
	1555	RT_NOREF_PV(pvUser);
	1556
	1557	switch (cb)
	1558	{
	1559	case 1:
[93601]	1560	rc = elIoWrite(pDevIns, pThis, Port, RT_LOBYTE(u32));
[93560]	1561	break;
	1562	case 2:
	1563	/* Manually split word access. */
[93601]	1564	rc = elIoWrite(pDevIns, pThis, Port + 0, RT_LOBYTE(u32));
[93560]	1565	if (!RT_SUCCESS(rc))
	1566	break;
[93601]	1567	rc = elIoWrite(pDevIns, pThis, Port + 1, RT_HIBYTE(u32));
[93560]	1568	break;
	1569	default:
[93601]	1570	rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS,
[93560]	1571	"elnkIOPortWrite: unsupported operation size: offset=%#10x cb=%u\n",
	1572	Port, cb);
	1573	}
	1574
[93601]	1575	Log2Func(("#%d: Port=%RTiop u32=%#RX32 cb=%d rc=%Rrc\n", pThis->iInstance, Port, u32, cb, rc));
[93560]	1576	STAM_PROFILE_ADV_STOP(&pThis->CTX_SUFF_Z(StatIOWrite), a);
	1577	return rc;
	1578	}
	1579
	1580
	1581	#ifdef IN_RING3
	1582
	1583	/* Shamelessly stolen from DevDMA.cpp */
	1584
	1585	/* Test the decrement bit of mode register. */
	1586	#define IS_MODE_DEC(c) ((c) & 0x20)
	1587	/* Test the auto-init bit of mode register. */
	1588	#define IS_MODE_AI(c) ((c) & 0x10)
	1589	/* Extract the transfer type bits of mode register. */
	1590	#define GET_MODE_XTYP(c) (((c) & 0x0c) >> 2)
	1591
	1592	/* DMA transfer modes. */
	1593	enum {
	1594	DMODE_DEMAND, /* Demand transfer mode. */
	1595	DMODE_SINGLE, /* Single transfer mode. */
	1596	DMODE_BLOCK, /* Block transfer mode. */
	1597	DMODE_CASCADE /* Cascade mode. */
	1598	};
	1599
	1600	/* DMA transfer types. */
	1601	enum {
	1602	DTYPE_VERIFY, /* Verify transfer type. */
	1603	DTYPE_WRITE, /* Write transfer type. */
	1604	DTYPE_READ, /* Read transfer type. */
	1605	DTYPE_ILLEGAL /* Undefined. */
	1606	};
	1607
	1608	static DECLCALLBACK(uint32_t) elnkR3DMAXferHandler(PPDMDEVINS pDevIns, void *opaque,
	1609	unsigned nchan, uint32_t dma_pos, uint32_t dma_len)
	1610	{
	1611	RT_NOREF(pDevIns);
	1612	PELNKSTATE pThis = (PELNKSTATE)opaque;
	1613	int dma_mode;
	1614	int dma_type;
	1615	uint32_t cbToXfer;
	1616	uint32_t cbXferred;
	1617	uint16_t uLastPos;
	1618	int rc;
	1619
	1620	/*
	1621	* The 3C501 EtherLink uses DMA as an alternative to accessing
	1622	* the buffer window register. The GP Buffer Pointer controls
	1623	* the address into the packet buffer for both writing to and
	1624	* reading from the buffer.
	1625	*/
[93601]	1626	dma_mode = PDMDevHlpDMAGetChannelMode(pDevIns, pThis->uIsaDma);
[93560]	1627	dma_type = GET_MODE_XTYP(dma_mode);
	1628	LogFlowFunc(("dma_mode=%d, dma_type=%d, dma_pos=%u, dma_len=%u, GPBP=%u\n", dma_mode, dma_type, dma_pos, dma_len, pThis->uGPBufPtr));
	1629
	1630	cbToXfer = dma_len;
	1631
	1632	if (dma_type == DTYPE_WRITE)
	1633	{
	1634	/* Write transfer type. Reading from device, writing to memory. */
[93601]	1635	rc = PDMDevHlpDMAWriteMemory(pDevIns, nchan,
[93560]	1636	&pThis->abPacketBuf[ELNK_GP(pThis)],
	1637	dma_pos, cbToXfer, &cbXferred);
	1638	AssertMsgRC(rc, ("DMAWriteMemory -> %Rrc\n", rc));
	1639	uLastPos = pThis->uRCVBufPtr;
	1640	}
	1641	else
	1642	{
	1643	/* Read of Verify transfer type. Reading from memory, writing to device. */
[93601]	1644	rc = PDMDevHlpDMAReadMemory(pDevIns, nchan,
[93560]	1645	&pThis->abPacketBuf[ELNK_GP(pThis)],
	1646	dma_pos, cbToXfer, &cbXferred);
	1647	AssertMsgRC(rc, ("DMAReadMemory -> %Rrc\n", rc));
	1648	uLastPos = 0; /* Stop when buffer address wraps back to zero. */
	1649	}
	1650	Log2Func(("After DMA transfer: GPBufPtr=%u, lastpos=%u, cbXferred=%u\n", pThis->uGPBufPtr, uLastPos, cbXferred));
	1651
	1652	/* Advance the GP buffer pointer and see if transfer completed (it almost certainly did). */
	1653	pThis->uGPBufPtr = (pThis->uGPBufPtr + cbXferred) & ELNK_GP_MASK;
	1654	if (ELNK_GP(pThis) == uLastPos \|\| 1)
	1655	{
	1656	Log2(("DMA completed\n"));
[93601]	1657	PDMDevHlpDMASetDREQ(pDevIns, pThis->uIsaDma, 0);
[93560]	1658	pThis->IntrState.dma_intr = 1;
	1659	pThis->AuxStat.dma_done = 1;
[93601]	1660	elnkUpdateIrq(pDevIns, pThis);
[93560]	1661	}
	1662	else
	1663	{
	1664	Log(("DMA continuing: GPBufPtr=%u, lastpos=%u, cbXferred=%u\n", pThis->uGPBufPtr, uLastPos, cbXferred));
[93601]	1665	PDMDevHlpDMASchedule(pDevIns);
[93560]	1666	}
	1667
	1668	/* Returns the updated transfer count. */
	1669	return dma_pos + cbXferred;
	1670	}
	1671
	1672
	1673	/* -=-=-=-=-=- Timer Callbacks -=-=-=-=-=- */
	1674
	1675	/**
	1676	* @callback_method_impl{FNTMTIMERDEV, Restore timer callback}
	1677	*
	1678	* This is only called when we restore a saved state and temporarily
	1679	* disconnected the network link to inform the guest that network connections
	1680	* should be considered lost.
	1681	*/
[93675]	1682	static DECLCALLBACK(void) elnkR3TimerRestore(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
[93560]	1683	{
	1684	RT_NOREF(pvUser);
[93601]	1685	PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
[93560]	1686	int rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
	1687	AssertReleaseRC(rc);
	1688
	1689	rc = VERR_GENERAL_FAILURE;
[93675]	1690
	1691	/* The EhterLink cards have no concept of a link state, and cables were assumed to be
	1692	* permanently attached (AUI or BNC). We can simulate a disconnected cable by reporting
	1693	* collisions on transmit, but a guest that waits to receive something will never know.
	1694	* For that reason, the link is temporarily down, we will only postpone restoring it
	1695	* a couple of times, and then reconnect regardless of whether the guest noticed
	1696	* anything or not.
	1697	*/
	1698	if ( (pThis->cLinkDownReported <= ELNK_MAX_LINKDOWN_REPORTED)
	1699	&& (pThis->cLinkRestorePostponed <= ELNK_MAX_LINKRST_POSTPONED))
[93560]	1700	rc = PDMDevHlpTimerSetMillies(pDevIns, hTimer, 1500);
	1701	if (RT_FAILURE(rc))
	1702	{
	1703	pThis->fLinkTempDown = false;
	1704	if (pThis->fLinkUp)
	1705	{
	1706	LogRel(("3C501#%d: The link is back up again after the restore.\n",
[93601]	1707	pThis->iInstance));
[93675]	1708	LogFunc(("#%d: cLinkDownReported=%d\n",
[93601]	1709	pThis->iInstance, pThis->cLinkDownReported));
[93560]	1710	pThis->Led.Actual.s.fError = 0;
	1711	}
	1712	}
	1713	else
[93675]	1714	{
	1715	LogFunc(("#%d: cLinkDownReported=%d, cLinkRestorePostponed=%d, wait another 1500ms...\n",
	1716	pThis->iInstance, pThis->cLinkDownReported, pThis->cLinkRestorePostponed));
	1717	pThis->cLinkRestorePostponed++;
	1718	}
[93560]	1719
	1720	PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
	1721	}
	1722
	1723
	1724	/* -=-=-=-=-=- Debug Info Handler -=-=-=-=-=- */
	1725
	1726	/**
	1727	* @callback_method_impl{FNDBGFHANDLERDEV}
	1728	*/
[93675]	1729	static DECLCALLBACK(void) elnkR3Info(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
[93560]	1730	{
[93601]	1731	PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
[93560]	1732	bool fStationAddr = false;
	1733	bool fRecvBuffer = false;
	1734	bool fSendBuffer = false;
	1735	static const char *apszAddrMatch[4] = { "Disabled", "Promiscuous", "Broadcast", "Multicast" };
	1736	static const char *apszBuffCntrl[4] = { "System", "Xmit then Recv", "Receive", "Loopback" };
	1737	/*
	1738	* Parse args.
	1739	*/
	1740	if (pszArgs)
	1741	{
	1742	fStationAddr = strstr(pszArgs, "verbose") \|\| strstr(pszArgs, "addr");
	1743	fRecvBuffer = strstr(pszArgs, "verbose") \|\| strstr(pszArgs, "recvbuf");
	1744	fSendBuffer = strstr(pszArgs, "verbose") \|\| strstr(pszArgs, "sendbuf");
	1745	}
	1746
	1747	/*
	1748	* Show info.
	1749	*/
	1750	pHlp->pfnPrintf(pHlp,
[93601]	1751	"3C501 #%d: port=%RTiop IRQ=%u DMA=%u mac-cfg=%RTmac%s%s %s\n",
	1752	pThis->iInstance,
[93560]	1753	pThis->IOPortBase, pThis->uIsaIrq, pThis->uIsaDma, &pThis->MacConfigured,
[93601]	1754	pDevIns->fRCEnabled ? " RC" : "", pDevIns->fR0Enabled ? " RZ" : "",
	1755	pThis->fDriverAttached ? "attached" : "unattached!");
[93560]	1756
	1757	int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_INTERNAL_ERROR); /* Take it here so we know why we're hanging... */
	1758	PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->CritSect, rcLock);
	1759
	1760	pHlp->pfnPrintf(pHlp, " GP Buf Ptr : %u (masked %u)\n", pThis->uGPBufPtr, ELNK_GP(pThis));
	1761	pHlp->pfnPrintf(pHlp, " RCV Buf Ptr: %u\n", pThis->uRCVBufPtr);
[93601]	1762	pHlp->pfnPrintf(pHlp, " Recv Command: %02X Recv Status: %02X\n", pThis->RcvCmdReg, pThis->RcvStatReg);
	1763	pHlp->pfnPrintf(pHlp, " Xmit Command: %02X Xmit Status: %02X\n", pThis->XmitCmdReg, pThis->XmitStatReg);
	1764	pHlp->pfnPrintf(pHlp, " Aux Command: %02X Aux Status: %02X\n", pThis->AuxCmdReg, pThis->AuxStatReg);
[93560]	1765
	1766	pHlp->pfnPrintf(pHlp, " Address matching: %s\n", apszAddrMatch[pThis->RcvCmd.adr_match]);
	1767	pHlp->pfnPrintf(pHlp, " Buffer control : %s\n", apszBuffCntrl[pThis->AuxCmd.buf_ctl]);
	1768	pHlp->pfnPrintf(pHlp, " Interrupt state : xmit=%u recv=%u dma=%u\n", pThis->IntrState.xmit_intr, pThis->IntrState.recv_intr, pThis->IntrState.dma_intr);
[93675]	1769	if (pThis->fLinkTempDown)
	1770	{
[93601]	1771	pHlp->pfnPrintf(pHlp, " Link down count : %d\n", pThis->cLinkDownReported);
[93675]	1772	pHlp->pfnPrintf(pHlp, " Postpone count : %d\n", pThis->cLinkRestorePostponed);
	1773	}
[93560]	1774
	1775	/* Dump the station address. */
	1776	if (fStationAddr)
	1777	{
	1778	pHlp->pfnPrintf(pHlp, " Station address : %RTmac\n", &pThis->aStationAddr);
	1779	}
	1780
	1781	/* Dump the beginning of the send buffer. */
	1782	if (fSendBuffer)
	1783	{
	1784	pHlp->pfnPrintf(pHlp, "Send buffer (start at %u):\n", ELNK_GP(pThis));
	1785	unsigned dump_end = RT_MIN((ELNK_GP(pThis)) + 64, sizeof(pThis->abPacketBuf) - 16);
	1786	for (unsigned ofs = ELNK_GP(pThis); ofs < dump_end; ofs += 16)
	1787	pHlp->pfnPrintf(pHlp, " %04X: %Rhxs\n", ofs, &pThis->abPacketBuf[ofs]);
	1788	pHlp->pfnPrintf(pHlp, "pktbuf at %p, end at %p\n", &pThis->abPacketBuf[ELNK_GP(pThis)], &pThis->abPacketBuf[ELNK_BUF_SIZE]);
	1789	}
	1790
	1791	/* Dump the beginning of the receive buffer. */
	1792	if (fRecvBuffer)
	1793	{
[93563]	1794	pHlp->pfnPrintf(pHlp, "Receive buffer (start at 0):\n");
[93560]	1795	unsigned dump_end = RT_MIN(pThis->uRCVBufPtr, 64);
	1796	for (unsigned ofs = 0; ofs < dump_end; ofs += 16)
	1797	pHlp->pfnPrintf(pHlp, " %04X: %Rhxs\n", ofs, &pThis->abPacketBuf[ofs]);
	1798	pHlp->pfnPrintf(pHlp, "pktbuf at %p, end at %p\n", pThis->abPacketBuf, &pThis->abPacketBuf[pThis->uRCVBufPtr]);
	1799	}
	1800
	1801	PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
	1802	}
	1803
	1804
	1805	/* -=-=-=-=-=- Helper(s) -=-=-=-=-=- */
	1806
	1807
[93601]	1808	static void elnkR3HardReset(PPDMDEVINS pDevIns, PELNKSTATE pThis)
[93560]	1809	{
[93601]	1810	LogFlowFunc(("#%d:\n", pThis->iInstance));
[93560]	1811
	1812	/* Initialize the PROM */
	1813	Assert(sizeof(pThis->MacConfigured) == 6);
	1814	memcpy(pThis->aPROM, &pThis->MacConfigured, sizeof(pThis->MacConfigured));
	1815	pThis->aPROM[6] = pThis->aPROM[7] = 0; /* The two padding bytes. */
	1816
	1817	/* Clear the packet buffer and station address. */
	1818	memset(pThis->abPacketBuf, 0, sizeof(pThis->abPacketBuf));
	1819	memset(pThis->aStationAddr, 0, sizeof(pThis->aStationAddr));
	1820
	1821	/* Reset the buffer pointers. */
	1822	pThis->uGPBufPtr = 0;
	1823	pThis->uRCVBufPtr = 0;
	1824
[93601]	1825	elnkSoftReset(pDevIns, pThis);
[93560]	1826	}
	1827
	1828	/**
	1829	* Takes down the link temporarily if it's current status is up.
	1830	*
	1831	* This is used during restore and when replumbing the network link.
	1832	*
	1833	* The temporary link outage is supposed to indicate to the OS that all network
	1834	* connections have been lost and that it for instance is appropriate to
	1835	* renegotiate any DHCP lease.
	1836	*
[93601]	1837	* @param pDevIns The device instance.
[93560]	1838	* @param pThis The device instance data.
	1839	*/
[93601]	1840	static void elnkTempLinkDown(PPDMDEVINS pDevIns, PELNKSTATE pThis)
[93560]	1841	{
	1842	if (pThis->fLinkUp)
	1843	{
	1844	pThis->fLinkTempDown = true;
	1845	pThis->cLinkDownReported = 0;
[93675]	1846	pThis->cLinkRestorePostponed = 0;
[93560]	1847	pThis->Led.Asserted.s.fError = pThis->Led.Actual.s.fError = 1;
[93601]	1848	int rc = PDMDevHlpTimerSetMillies(pDevIns, pThis->hTimerRestore, pThis->cMsLinkUpDelay);
[93560]	1849	AssertRC(rc);
	1850	}
	1851	}
	1852
	1853
	1854	/* -=-=-=-=-=- Saved State -=-=-=-=-=- */
	1855
	1856	/**
	1857	* @callback_method_impl{FNSSMDEVLIVEEXEC, Pass 0 only.}
	1858	*/
	1859	static DECLCALLBACK(int) elnkLiveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uPass)
	1860	{
	1861	RT_NOREF(uPass);
[93601]	1862	PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
[93560]	1863	pDevIns->pHlpR3->pfnSSMPutMem(pSSM, &pThis->MacConfigured, sizeof(pThis->MacConfigured));
	1864	return VINF_SSM_DONT_CALL_AGAIN;
	1865	}
	1866
	1867
	1868	/**
	1869	* @callback_method_impl{FNSSMDEVSAVEPREP,
	1870	* Serializes the receive thread, it may be working inside the critsect.}
	1871	*/
	1872	static DECLCALLBACK(int) elnkSavePrep(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
	1873	{
	1874	RT_NOREF(pSSM);
[93601]	1875	PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
[93560]	1876
	1877	int rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
	1878	AssertRC(rc);
	1879	PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
	1880
	1881	return VINF_SUCCESS;
	1882	}
	1883
	1884
	1885	/**
	1886	* @callback_method_impl{FNSSMDEVSAVEEXEC}
	1887	*/
	1888	static DECLCALLBACK(int) elnkSaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
	1889	{
[93601]	1890	PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
[93560]	1891	PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
	1892
	1893	pHlp->pfnSSMPutU16(pSSM, pThis->uGPBufPtr);
	1894	pHlp->pfnSSMPutU16(pSSM, pThis->uRCVBufPtr);
	1895	pHlp->pfnSSMPutU8(pSSM, pThis->XmitCmdReg);
	1896	pHlp->pfnSSMPutU8(pSSM, pThis->XmitStatReg);
	1897	pHlp->pfnSSMPutU8(pSSM, pThis->RcvCmdReg);
	1898	pHlp->pfnSSMPutU8(pSSM, pThis->RcvStatReg);
	1899	pHlp->pfnSSMPutU8(pSSM, pThis->AuxCmdReg);
	1900	pHlp->pfnSSMPutU8(pSSM, pThis->AuxStatReg);
	1901
	1902	pHlp->pfnSSMPutU8(pSSM, pThis->IntrStateReg);
	1903	pHlp->pfnSSMPutBool(pSSM, pThis->fInReset);
	1904	pHlp->pfnSSMPutBool(pSSM, pThis->fLinkUp);
	1905	pHlp->pfnSSMPutBool(pSSM, pThis->fISR);
	1906	pHlp->pfnSSMPutMem(pSSM, pThis->aStationAddr, sizeof(pThis->aStationAddr));
	1907
[93675]	1908	/* Save the configured MAC address. */
	1909	pHlp->pfnSSMPutMem(pSSM, &pThis->MacConfigured, sizeof(pThis->MacConfigured));
	1910
[93560]	1911	return VINF_SUCCESS;
	1912	}
	1913
	1914
	1915	/**
	1916	* @callback_method_impl{FNSSMDEVLOADPREP},
	1917	* Serializes the receive thread, it may be working inside the critsect.}
	1918	*/
	1919	static DECLCALLBACK(int) elnkLoadPrep(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
	1920	{
[93601]	1921	PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
[93560]	1922	RT_NOREF(pSSM);
	1923
	1924	int rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
	1925	AssertRC(rc);
	1926
	1927	PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
	1928
	1929	return rc;
	1930	}
	1931
	1932
	1933	/**
	1934	* @callback_method_impl{FNSSMDEVLOADEXEC}
	1935	*/
	1936	static DECLCALLBACK(int) elnkLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
	1937	{
[93601]	1938	PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
	1939	PELNKSTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PELNKSTATECC);
	1940	PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
[93560]	1941
[93668]	1942	if (SSM_VERSION_MAJOR_CHANGED(uVersion, ELNK_SAVEDSTATE_VERSION))
[93560]	1943	return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
	1944
	1945	if (uPass == SSM_PASS_FINAL)
	1946	{
	1947	/* restore data */
	1948	pHlp->pfnSSMGetU16(pSSM, &pThis->uGPBufPtr);
	1949	pHlp->pfnSSMGetU16(pSSM, &pThis->uRCVBufPtr);
	1950	pHlp->pfnSSMGetU8(pSSM, &pThis->XmitCmdReg);
	1951	pHlp->pfnSSMGetU8(pSSM, &pThis->XmitStatReg);
	1952	pHlp->pfnSSMGetU8(pSSM, &pThis->RcvCmdReg);
	1953	pHlp->pfnSSMGetU8(pSSM, &pThis->RcvStatReg);
	1954	pHlp->pfnSSMGetU8(pSSM, &pThis->AuxCmdReg);
	1955	pHlp->pfnSSMGetU8(pSSM, &pThis->AuxStatReg);
	1956
	1957	pHlp->pfnSSMGetU8(pSSM, &pThis->IntrStateReg);
	1958	pHlp->pfnSSMGetBool(pSSM, &pThis->fInReset);
	1959	pHlp->pfnSSMGetBool(pSSM, &pThis->fLinkUp);
	1960	pHlp->pfnSSMGetBool(pSSM, &pThis->fISR);
[93675]	1961	pHlp->pfnSSMGetMem(pSSM, &pThis->aStationAddr, sizeof(pThis->aStationAddr));
[93560]	1962	}
	1963
	1964	/* check config */
	1965	RTMAC Mac;
	1966	int rc = pHlp->pfnSSMGetMem(pSSM, &Mac, sizeof(Mac));
	1967	AssertRCReturn(rc, rc);
	1968	if ( memcmp(&Mac, &pThis->MacConfigured, sizeof(Mac))
	1969	&& (uPass == 0 \|\| !PDMDevHlpVMTeleportedAndNotFullyResumedYet(pDevIns)) )
[93601]	1970	LogRel(("3C501#%u: The mac address differs: config=%RTmac saved=%RTmac\n", pThis->iInstance, &pThis->MacConfigured, &Mac));
[93560]	1971
	1972	if (uPass == SSM_PASS_FINAL)
	1973	{
	1974	/* update promiscuous mode. */
[93601]	1975	if (pThisCC->pDrv)
	1976	pThisCC->pDrv->pfnSetPromiscuousMode(pThisCC->pDrv, 0 /* promiscuous enabled */);
[93560]	1977
	1978	/* Indicate link down to the guest OS that all network connections have
	1979	been lost, unless we've been teleported here. */
	1980	if (!PDMDevHlpVMTeleportedAndNotFullyResumedYet(pDevIns))
[93601]	1981	elnkTempLinkDown(pDevIns, pThis);
[93560]	1982	}
	1983
	1984	return VINF_SUCCESS;
	1985	}
	1986
	1987
	1988	/* -=-=-=-=-=- ELNKSTATE::INetworkDown -=-=-=-=-=- */
	1989
	1990	/**
	1991	* Check if the device/driver can receive data now.
	1992	*
	1993	* Worker for elnkNet_WaitReceiveAvail(). This must be called before
	1994	* the pfnRecieve() method is called.
	1995	*
	1996	* @returns VBox status code.
[93601]	1997	* @param pDevIns The device instance data.
	1998	* @param pThis The shared instance data.
[93560]	1999	*/
[93601]	2000	static int elnkCanReceive(PPDMDEVINS pDevIns, PELNKSTATE pThis)
[93560]	2001	{
	2002	int rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
	2003	AssertReleaseRC(rc);
	2004
	2005	rc = VINF_SUCCESS;
	2006
	2007	/*
	2008	* The real 3C501 is very limited in that the packet buffer can only hold one
	2009	* frame and and it is shared between transmit and receive, which means the card
	2010	* frequently drops packets on a busy network. We cheat a bit and try to hold
	2011	* off when it looks like receive is only temporarily unavailable.
	2012	*
	2013	* If the receiver is disabled, accept packet and drop it to avoid
	2014	* packet pile-ups. If it's enabled, take a closer look.
	2015	*/
	2016	#if 0
	2017	if (pThis->RcvCmd.adr_match != EL_ADRM_DISABLED) {
	2018	/* The 3C501 is only prepared to accept a packet if the receiver is busy.
	2019	* When not busy, try to delay packets.
	2020	*/
	2021	if (!pThis->AuxStat.recv_bsy)
	2022	{
	2023	rc = VERR_NET_NO_BUFFER_SPACE;
	2024	}
	2025	}
	2026	#else
	2027	if (pThis->RcvCmd.adr_match == EL_ADRM_DISABLED \|\| !pThis->AuxStat.recv_bsy)
	2028	{
	2029	rc = VERR_NET_NO_BUFFER_SPACE;
	2030	}
	2031	#endif
	2032	PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
	2033	return rc;
	2034	}
	2035
	2036
	2037	/**
	2038	* @interface_method_impl{PDMINETWORKDOWN,pfnWaitReceiveAvail}
	2039	*/
	2040	static DECLCALLBACK(int) elnkNet_WaitReceiveAvail(PPDMINETWORKDOWN pInterface, RTMSINTERVAL cMillies)
	2041	{
[93601]	2042	PELNKSTATECC pThisCC = RT_FROM_MEMBER(pInterface, ELNKSTATECC, INetworkDown);
	2043	PPDMDEVINS pDevIns = pThisCC->pDevIns;
	2044	PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
[93560]	2045
[93601]	2046	int rc = elnkCanReceive(pDevIns, pThis);
[93560]	2047	if (RT_SUCCESS(rc))
	2048	return VINF_SUCCESS;
	2049	if (RT_UNLIKELY(cMillies == 0))
	2050	return VERR_NET_NO_BUFFER_SPACE;
	2051
	2052	rc = VERR_INTERRUPTED;
	2053	ASMAtomicXchgBool(&pThis->fMaybeOutOfSpace, true);
	2054	STAM_PROFILE_START(&pThis->StatRxOverflow, a);
	2055	VMSTATE enmVMState;
[93601]	2056	while (RT_LIKELY( (enmVMState = PDMDevHlpVMState(pDevIns)) == VMSTATE_RUNNING
[93560]	2057	\|\| enmVMState == VMSTATE_RUNNING_LS))
	2058	{
[93601]	2059	int rc2 = elnkCanReceive(pDevIns, pThis);
[93560]	2060	if (RT_SUCCESS(rc2))
	2061	{
	2062	rc = VINF_SUCCESS;
	2063	break;
	2064	}
[93601]	2065	LogFlowFunc(("waiting cMillies=%u...\n", cMillies));
[93560]	2066
	2067	/* Start the poll timer once which will remain active as long fMaybeOutOfSpace
	2068	* is true -- even if (transmit) polling is disabled. */
	2069	rc2 = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
	2070	AssertReleaseRC(rc2);
	2071	PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
	2072	RTSemEventWait(pThis->hEventOutOfRxSpace, cMillies);
	2073	}
	2074	STAM_PROFILE_STOP(&pThis->StatRxOverflow, a);
	2075	ASMAtomicXchgBool(&pThis->fMaybeOutOfSpace, false);
	2076
	2077	return rc;
	2078	}
	2079
	2080
	2081	/**
	2082	* @interface_method_impl{PDMINETWORKDOWN,pfnReceive}
	2083	*/
	2084	static DECLCALLBACK(int) elnkNet_Receive(PPDMINETWORKDOWN pInterface, const void *pvBuf, size_t cb)
	2085	{
[93601]	2086	PELNKSTATECC pThisCC = RT_FROM_MEMBER(pInterface, ELNKSTATECC, INetworkDown);
	2087	PPDMDEVINS pDevIns = pThisCC->pDevIns;
	2088	PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
	2089	int rc;
[93560]	2090
	2091	STAM_PROFILE_ADV_START(&pThis->StatReceive, a);
	2092	rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
	2093	AssertReleaseRC(rc);
	2094
	2095	if (cb > 50) /* unqualified guess */
	2096	pThis->Led.Asserted.s.fReading = pThis->Led.Actual.s.fReading = 1;
[93601]	2097	elnkReceiveLocked(pDevIns, pThis, (const uint8_t *)pvBuf, cb, false);
[93560]	2098	pThis->Led.Actual.s.fReading = 0;
	2099
	2100	PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
	2101	STAM_PROFILE_ADV_STOP(&pThis->StatReceive, a);
	2102
	2103	return VINF_SUCCESS;
	2104	}
	2105
	2106
	2107	/**
	2108	* @interface_method_impl{PDMINETWORKDOWN,pfnXmitPending}
	2109	*/
	2110	static DECLCALLBACK(void) elnkNet_XmitPending(PPDMINETWORKDOWN pInterface)
	2111	{
[93601]	2112	PELNKSTATECC pThisCC = RT_FROM_MEMBER(pInterface, ELNKSTATECC, INetworkDown);
	2113	PPDMDEVINS pDevIns = pThisCC->pDevIns;
	2114	PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
	2115
	2116	elnkXmitBuffer(pDevIns, pThis, pThisCC, true /fOnWorkerThread/);
[93560]	2117	}
	2118
	2119
	2120	/* -=-=-=-=-=- ELNKSTATE::INetworkConfig -=-=-=-=-=- */
	2121
	2122	/**
	2123	* @interface_method_impl{PDMINETWORKCONFIG,pfnGetMac}
	2124	*/
	2125	static DECLCALLBACK(int) elnkGetMac(PPDMINETWORKCONFIG pInterface, PRTMAC pMac)
	2126	{
[93601]	2127	PELNKSTATECC pThisCC = RT_FROM_MEMBER(pInterface, ELNKSTATECC, INetworkConfig);
	2128	PPDMDEVINS pDevIns = pThisCC->pDevIns;
	2129	PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
	2130
	2131	LogFlowFunc(("#%d\n", pThis->iInstance));
[93560]	2132	/// @todo This is broken!! We can't properly get the MAC address set by the guest
	2133	#if 0
	2134	memcpy(pMac, pThis->aStationAddr, sizeof(*pMac));
	2135	#else
	2136	memcpy(pMac, pThis->aPROM, sizeof(*pMac));
	2137	#endif
	2138	return VINF_SUCCESS;
	2139	}
	2140
	2141
	2142	/**
	2143	* @interface_method_impl{PDMINETWORKCONFIG,pfnGetLinkState}
	2144	*/
	2145	static DECLCALLBACK(PDMNETWORKLINKSTATE) elnkGetLinkState(PPDMINETWORKCONFIG pInterface)
	2146	{
[93601]	2147	PELNKSTATECC pThisCC = RT_FROM_MEMBER(pInterface, ELNKSTATECC, INetworkConfig);
	2148	PPDMDEVINS pDevIns = pThisCC->pDevIns;
	2149	PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
	2150
[93560]	2151	if (pThis->fLinkUp && !pThis->fLinkTempDown)
	2152	return PDMNETWORKLINKSTATE_UP;
	2153	if (!pThis->fLinkUp)
	2154	return PDMNETWORKLINKSTATE_DOWN;
	2155	if (pThis->fLinkTempDown)
	2156	return PDMNETWORKLINKSTATE_DOWN_RESUME;
	2157	AssertMsgFailed(("Invalid link state!\n"));
	2158	return PDMNETWORKLINKSTATE_INVALID;
	2159	}
	2160
	2161
	2162	/**
	2163	* @interface_method_impl{PDMINETWORKCONFIG,pfnSetLinkState}
	2164	*/
	2165	static DECLCALLBACK(int) elnkSetLinkState(PPDMINETWORKCONFIG pInterface, PDMNETWORKLINKSTATE enmState)
	2166	{
[93601]	2167	PELNKSTATECC pThisCC = RT_FROM_MEMBER(pInterface, ELNKSTATECC, INetworkConfig);
	2168	PPDMDEVINS pDevIns = pThisCC->pDevIns;
	2169	PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
	2170	bool fLinkUp;
[93560]	2171
	2172	AssertMsgReturn(enmState > PDMNETWORKLINKSTATE_INVALID && enmState <= PDMNETWORKLINKSTATE_DOWN_RESUME,
	2173	("Invalid link state: enmState=%d\n", enmState), VERR_INVALID_PARAMETER);
	2174
	2175	if (enmState == PDMNETWORKLINKSTATE_DOWN_RESUME)
	2176	{
[93601]	2177	elnkTempLinkDown(pDevIns, pThis);
[93560]	2178	/*
	2179	* Note that we do not notify the driver about the link state change because
	2180	* the change is only temporary and can be disregarded from the driver's
	2181	* point of view (see @bugref{7057}).
	2182	*/
	2183	return VINF_SUCCESS;
	2184	}
	2185	/* has the state changed? */
	2186	fLinkUp = enmState == PDMNETWORKLINKSTATE_UP;
	2187	if (pThis->fLinkUp != fLinkUp)
	2188	{
	2189	pThis->fLinkUp = fLinkUp;
	2190	if (fLinkUp)
	2191	{
	2192	/* Connect with a configured delay. */
	2193	pThis->fLinkTempDown = true;
	2194	pThis->cLinkDownReported = 0;
[93675]	2195	pThis->cLinkRestorePostponed = 0;
[93560]	2196	pThis->Led.Asserted.s.fError = pThis->Led.Actual.s.fError = 1;
[93601]	2197	int rc = PDMDevHlpTimerSetMillies(pDevIns, pThis->hTimerRestore, pThis->cMsLinkUpDelay);
[93560]	2198	AssertRC(rc);
	2199	}
	2200	else
	2201	{
	2202	/* Disconnect. */
	2203	pThis->cLinkDownReported = 0;
[93675]	2204	pThis->cLinkRestorePostponed = 0;
[93560]	2205	pThis->Led.Asserted.s.fError = pThis->Led.Actual.s.fError = 1;
	2206	}
[93601]	2207	Assert(!PDMDevHlpCritSectIsOwner(pDevIns, &pThis->CritSect));
	2208	if (pThisCC->pDrv)
	2209	pThisCC->pDrv->pfnNotifyLinkChanged(pThisCC->pDrv, enmState);
[93560]	2210	}
	2211	return VINF_SUCCESS;
	2212	}
	2213
	2214
	2215	/* -=-=-=-=-=- ELNKSTATE::ILeds (LUN#0) -=-=-=-=-=- */
	2216
	2217	/**
	2218	* @interface_method_impl{PDMILEDPORTS,pfnQueryStatusLed}
	2219	*/
	2220	static DECLCALLBACK(int) elnkQueryStatusLed(PPDMILEDPORTS pInterface, unsigned iLUN, PPDMLED *ppLed)
	2221	{
[93601]	2222	PELNKSTATECC pThisCC = RT_FROM_MEMBER(pInterface, ELNKSTATECC, ILeds);
	2223	PPDMDEVINS pDevIns = pThisCC->pDevIns;
	2224	PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
[93560]	2225	if (iLUN == 0)
	2226	{
	2227	*ppLed = &pThis->Led;
	2228	return VINF_SUCCESS;
	2229	}
	2230	return VERR_PDM_LUN_NOT_FOUND;
	2231	}
	2232
	2233
	2234	/* -=-=-=-=-=- ELNKSTATE::IBase (LUN#0) -=-=-=-=-=- */
	2235
	2236	/**
	2237	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
	2238	*/
	2239	static DECLCALLBACK(void ) elnkQueryInterface(struct PDMIBASE pInterface, const char *pszIID)
	2240	{
[93601]	2241	PELNKSTATECC pThisCC = RT_FROM_MEMBER(pInterface, ELNKSTATECC, IBase);
	2242	Assert(&pThisCC->IBase == pInterface);
	2243	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThisCC->IBase);
	2244	PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKDOWN, &pThisCC->INetworkDown);
	2245	PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKCONFIG, &pThisCC->INetworkConfig);
	2246	PDMIBASE_RETURN_INTERFACE(pszIID, PDMILEDPORTS, &pThisCC->ILeds);
[93560]	2247	return NULL;
	2248	}
	2249
	2250
	2251	/* -=-=-=-=-=- PDMDEVREG -=-=-=-=-=- */
	2252
	2253	/**
	2254	* @interface_method_impl{PDMDEVREG,pfnPowerOff}
	2255	*/
[93601]	2256	static DECLCALLBACK(void) elnkR3PowerOff(PPDMDEVINS pDevIns)
[93560]	2257	{
	2258	/* Poke thread waiting for buffer space. */
	2259	elnkR3WakeupReceive(pDevIns);
	2260	}
	2261
	2262
	2263	/**
	2264	* @interface_method_impl{PDMDEVREG,pfnDetach}
	2265	*
	2266	* One port on the network card has been disconnected from the network.
	2267	*/
[93601]	2268	static DECLCALLBACK(void) elnkR3Detach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
[93560]	2269	{
[93601]	2270	PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
	2271	PELNKSTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PELNKSTATECC);
[93560]	2272	RT_NOREF(fFlags);
[93601]	2273	LogFlowFunc(("#%d:\n", pThis->iInstance));
[93560]	2274
	2275	AssertLogRelReturnVoid(iLUN == 0);
	2276
	2277	int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
	2278	PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->CritSect, rcLock);
	2279
	2280	/*
	2281	* Zero some important members.
	2282	*/
[93601]	2283	pThis->fDriverAttached = false;
	2284	pThisCC->pDrvBase = NULL;
	2285	pThisCC->pDrv = NULL;
[93560]	2286
	2287	PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
	2288	}
	2289
	2290
	2291	/**
	2292	* @interface_method_impl{PDMDEVREG,pfnAttach}
	2293	* One port on the network card has been connected to a network.
	2294	*/
[93601]	2295	static DECLCALLBACK(int) elnkR3Attach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
[93560]	2296	{
[93601]	2297	PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
	2298	PELNKSTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PELNKSTATECC);
[93560]	2299	RT_NOREF(fFlags);
[93601]	2300	LogFlowFunc(("#%d:\n", pThis->iInstance));
[93560]	2301
	2302	AssertLogRelReturn(iLUN == 0, VERR_PDM_NO_SUCH_LUN);
	2303
	2304	int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
	2305	PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->CritSect, rcLock);
	2306
	2307	/*
	2308	* Attach the driver.
	2309	*/
[93601]	2310	int rc = PDMDevHlpDriverAttach(pDevIns, 0, &pThisCC->IBase, &pThisCC->pDrvBase, "Network Port");
[93560]	2311	if (RT_SUCCESS(rc))
	2312	{
[93601]	2313	pThisCC->pDrv = PDMIBASE_QUERY_INTERFACE(pThisCC->pDrvBase, PDMINETWORKUP);
	2314	AssertMsgStmt(pThisCC->pDrv, ("Failed to obtain the PDMINETWORKUP interface!\n"),
[93560]	2315	rc = VERR_PDM_MISSING_INTERFACE_BELOW);
[93601]	2316	pThis->fDriverAttached = true;
[93560]	2317	}
	2318	else if ( rc == VERR_PDM_NO_ATTACHED_DRIVER
	2319	\|\| rc == VERR_PDM_CFG_MISSING_DRIVER_NAME)
	2320	{
	2321	/* This should never happen because this function is not called
	2322	* if there is no driver to attach! */
[93601]	2323	Log(("#%d: No attached driver!\n", pThis->iInstance));
[93560]	2324	}
	2325
	2326	/*
	2327	* Temporary set the link down if it was up so that the guest
	2328	* will know that we have change the configuration of the
	2329	* network card
	2330	*/
	2331	if (RT_SUCCESS(rc))
[93601]	2332	elnkTempLinkDown(pDevIns, pThis);
[93560]	2333
	2334	PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
	2335	return rc;
	2336	}
	2337
	2338
	2339	/**
	2340	* @interface_method_impl{PDMDEVREG,pfnSuspend}
	2341	*/
[93601]	2342	static DECLCALLBACK(void) elnkR3Suspend(PPDMDEVINS pDevIns)
[93560]	2343	{
	2344	/* Poke thread waiting for buffer space. */
	2345	elnkR3WakeupReceive(pDevIns);
	2346	}
	2347
	2348
	2349	/**
	2350	* @interface_method_impl{PDMDEVREG,pfnReset}
	2351	*/
[93601]	2352	static DECLCALLBACK(void) elnkR3Reset(PPDMDEVINS pDevIns)
[93560]	2353	{
[93601]	2354	PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
[93560]	2355	if (pThis->fLinkTempDown)
	2356	{
	2357	pThis->cLinkDownReported = 0x1000;
[93675]	2358	pThis->cLinkRestorePostponed = 0x1000;
[93560]	2359	PDMDevHlpTimerStop(pDevIns, pThis->hTimerRestore);
[93675]	2360	elnkR3TimerRestore(pDevIns, pThis->hTimerRestore, pThis);
[93560]	2361	}
	2362
	2363	/** @todo How to flush the queues? */
[93601]	2364	elnkR3HardReset(pDevIns, pThis);
[93560]	2365	}
	2366
	2367
	2368	/**
	2369	* @interface_method_impl{PDMDEVREG,pfnRelocate}
	2370	*/
[93601]	2371	static DECLCALLBACK(void) elnkR3Relocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta)
[93560]	2372	{
[93601]	2373	PELNKSTATERC pThisRC = PDMINS_2_DATA_RC(pDevIns, PELNKSTATERC);
	2374	pThisRC->pDrv += offDelta;
[93560]	2375	}
	2376
	2377
	2378	/**
	2379	* @interface_method_impl{PDMDEVREG,pfnDestruct}
	2380	*/
[93601]	2381	static DECLCALLBACK(int) elnkR3Destruct(PPDMDEVINS pDevIns)
[93560]	2382	{
	2383	PDMDEV_CHECK_VERSIONS_RETURN_QUIET(pDevIns);
[93601]	2384	PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
[93560]	2385
	2386	if (PDMDevHlpCritSectIsInitialized(pDevIns, &pThis->CritSect))
	2387	{
	2388	RTSemEventSignal(pThis->hEventOutOfRxSpace);
	2389	RTSemEventDestroy(pThis->hEventOutOfRxSpace);
	2390	pThis->hEventOutOfRxSpace = NIL_RTSEMEVENT;
	2391	PDMDevHlpCritSectDelete(pDevIns, &pThis->CritSect);
	2392	}
	2393	return VINF_SUCCESS;
	2394	}
	2395
	2396
	2397	/**
	2398	* @interface_method_impl{PDMDEVREG,pfnConstruct}
	2399	*/
[93601]	2400	static DECLCALLBACK(int) elnkR3Construct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfg)
[93560]	2401	{
	2402	PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
[93601]	2403	PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
	2404	PELNKSTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PELNKSTATECC);
	2405	PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
[93560]	2406	PPDMIBASE pBase;
	2407	char szTmp[128];
	2408	int rc;
	2409
	2410	/*
	2411	* Init what's required to make the destructor safe.
	2412	*/
	2413	pThis->iInstance = iInstance;
[93567]	2414	pThis->hEventOutOfRxSpace = NIL_RTSEMEVENT;
[93560]	2415	pThis->hIoPortsIsa = NIL_IOMIOPORTHANDLE;
[93601]	2416	pThisCC->pDevIns = pDevIns;
[93560]	2417
	2418	/*
	2419	* Validate configuration.
	2420	*/
	2421	PDMDEV_VALIDATE_CONFIG_RETURN(pDevIns, "MAC\|CableConnected\|Port\|IRQ\|DMA\|LinkUpDelay\|LineSpeed", "");
	2422
	2423	/*
	2424	* Read the configuration.
	2425	*/
	2426	rc = pHlp->pfnCFGMQueryBytes(pCfg, "MAC", &pThis->MacConfigured, sizeof(pThis->MacConfigured));
	2427	if (RT_FAILURE(rc))
	2428	return PDMDEV_SET_ERROR(pDevIns, rc,
	2429	N_("Configuration error: Failed to get the \"MAC\" value"));
	2430	rc = pHlp->pfnCFGMQueryBoolDef(pCfg, "CableConnected", &pThis->fLinkUp, true);
	2431	if (RT_FAILURE(rc))
	2432	return PDMDEV_SET_ERROR(pDevIns, rc,
	2433	N_("Configuration error: Failed to get the \"CableConnected\" value"));
	2434
	2435	/*
	2436	* Process ISA configuration options.
	2437	*/
	2438	rc = pHlp->pfnCFGMQueryPortDef(pCfg, "Port", &pThis->IOPortBase, 0x300);
	2439	if (RT_FAILURE(rc))
	2440	return PDMDEV_SET_ERROR(pDevIns, rc,
	2441	N_("Configuration error: Failed to get the \"Port\" value"));
	2442
	2443	rc = pHlp->pfnCFGMQueryU8Def(pCfg, "IRQ", &pThis->uIsaIrq, 3);
	2444	if (RT_FAILURE(rc))
	2445	return PDMDEV_SET_ERROR(pDevIns, rc,
	2446	N_("Configuration error: Failed to get the \"IRQ\" value"));
	2447
	2448	rc = pHlp->pfnCFGMQueryU8Def(pCfg, "DMA", &pThis->uIsaDma, 1);
	2449	if (RT_FAILURE(rc))
	2450	return PDMDEV_SET_ERROR(pDevIns, rc,
	2451	N_("Configuration error: Failed to get the \"DMA\" value"));
	2452
	2453	rc = pHlp->pfnCFGMQueryU32Def(pCfg, "LinkUpDelay", (uint32_t)&pThis->cMsLinkUpDelay, 5000); / ms */
	2454	if (RT_FAILURE(rc))
	2455	return PDMDEV_SET_ERROR(pDevIns, rc,
	2456	N_("Configuration error: Failed to get the value of 'LinkUpDelay'"));
	2457	Assert(pThis->cMsLinkUpDelay <= 300000); /* less than 5 minutes */
	2458	if (pThis->cMsLinkUpDelay > 5000 \|\| pThis->cMsLinkUpDelay < 100)
	2459	{
	2460	LogRel(("3C501#%d WARNING! Link up delay is set to %u seconds!\n",
	2461	iInstance, pThis->cMsLinkUpDelay / 1000));
	2462	}
	2463	Log(("#%d Link up delay is set to %u seconds\n",
	2464	iInstance, pThis->cMsLinkUpDelay / 1000));
	2465
	2466
	2467	/*
	2468	* Initialize data (most of it anyway).
	2469	*/
[93601]	2470	pThis->Led.u32Magic = PDMLED_MAGIC;
[93560]	2471	/* IBase */
[93601]	2472	pThisCC->IBase.pfnQueryInterface = elnkQueryInterface;
[93560]	2473	/* INetworkPort */
[93601]	2474	pThisCC->INetworkDown.pfnWaitReceiveAvail = elnkNet_WaitReceiveAvail;
	2475	pThisCC->INetworkDown.pfnReceive = elnkNet_Receive;
	2476	pThisCC->INetworkDown.pfnXmitPending = elnkNet_XmitPending;
[93560]	2477	/* INetworkConfig */
[93601]	2478	pThisCC->INetworkConfig.pfnGetMac = elnkGetMac;
	2479	pThisCC->INetworkConfig.pfnGetLinkState = elnkGetLinkState;
	2480	pThisCC->INetworkConfig.pfnSetLinkState = elnkSetLinkState;
[93560]	2481	/* ILeds */
[93601]	2482	pThisCC->ILeds.pfnQueryStatusLed = elnkQueryStatusLed;
[93560]	2483
	2484	/*
	2485	* We use our own critical section (historical reasons).
	2486	*/
	2487	rc = PDMDevHlpCritSectInit(pDevIns, &pThis->CritSect, RT_SRC_POS, "3C501#%u", iInstance);
	2488	AssertRCReturn(rc, rc);
	2489	rc = PDMDevHlpSetDeviceCritSect(pDevIns, &pThis->CritSect);
	2490	AssertRCReturn(rc, rc);
	2491
	2492	rc = RTSemEventCreate(&pThis->hEventOutOfRxSpace);
	2493	AssertRCReturn(rc, rc);
	2494
	2495	/*
	2496	* Register ISA I/O ranges for the EtherLink 3C501.
	2497	*/
	2498	rc = PDMDevHlpIoPortCreateAndMap(pDevIns, pThis->IOPortBase, 0x10 /cPorts/, elnkIOPortWrite, elnkIOPortRead,
	2499	"3C501", NULL /paExtDesc/, &pThis->hIoPortsIsa);
	2500	if (RT_FAILURE(rc))
	2501	return rc;
	2502
	2503	/*
	2504	* Register DMA channel.
	2505	*/
	2506	if (pThis->uIsaDma <= ELNK_MAX_VALID_DMA)
	2507	{
	2508	rc = PDMDevHlpDMARegister(pDevIns, pThis->uIsaDma, elnkR3DMAXferHandler, pThis);
	2509	if (RT_FAILURE(rc))
	2510	return rc;
	2511	LogRel(("3C501#%d: Enabling DMA channel %u\n", iInstance, pThis->uIsaDma));
	2512	}
	2513	else
	2514	LogRel(("3C501#%d: Disabling DMA\n", iInstance));
	2515
[93675]	2516	rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, elnkR3TimerRestore, NULL, TMTIMER_FLAGS_NO_CRIT_SECT \| TMTIMER_FLAGS_NO_RING0,
[93560]	2517	"3C501 Restore Timer", &pThis->hTimerRestore);
	2518	if (RT_FAILURE(rc))
	2519	return rc;
	2520
	2521	rc = PDMDevHlpSSMRegisterEx(pDevIns, ELNK_SAVEDSTATE_VERSION, sizeof(*pThis), NULL,
	2522	NULL, elnkLiveExec, NULL,
	2523	elnkSavePrep, elnkSaveExec, NULL,
	2524	elnkLoadPrep, elnkLoadExec, NULL);
	2525	if (RT_FAILURE(rc))
	2526	return rc;
	2527
	2528	/*
	2529	* Create the transmit queue.
	2530	*/
	2531	rc = PDMDevHlpTaskCreate(pDevIns, PDMTASK_F_RZ, "3C501-Xmit", elnkR3XmitTaskCallback, NULL /pvUser/, &pThis->hXmitTask);
	2532	if (RT_FAILURE(rc))
	2533	return rc;
	2534
	2535	/*
	2536	* Create the RX notifier signaller.
	2537	*/
	2538	rc = PDMDevHlpTaskCreate(pDevIns, PDMTASK_F_RZ, "3C501-Rcv", elnkR3CanRxTaskCallback, NULL /pvUser/, &pThis->hCanRxTask);
	2539	if (RT_FAILURE(rc))
	2540	return rc;
	2541
	2542	/*
	2543	* Register the info item.
	2544	*/
[93601]	2545	RTStrPrintf(szTmp, sizeof(szTmp), "elnk%d", pThis->iInstance);
[93675]	2546	PDMDevHlpDBGFInfoRegister(pDevIns, szTmp, "3C501 info", elnkR3Info);
[93560]	2547
	2548	/*
	2549	* Attach status driver (optional).
	2550	*/
[93601]	2551	rc = PDMDevHlpDriverAttach(pDevIns, PDM_STATUS_LUN, &pThisCC->IBase, &pBase, "Status Port");
[93560]	2552	if (RT_SUCCESS(rc))
	2553	pThis->pLedsConnector = PDMIBASE_QUERY_INTERFACE(pBase, PDMILEDCONNECTORS);
	2554	else if ( rc != VERR_PDM_NO_ATTACHED_DRIVER
	2555	&& rc != VERR_PDM_CFG_MISSING_DRIVER_NAME)
	2556	{
	2557	AssertMsgFailed(("Failed to attach to status driver. rc=%Rrc\n", rc));
	2558	return rc;
	2559	}
	2560
	2561	/*
	2562	* Attach driver.
	2563	*/
[93601]	2564	rc = PDMDevHlpDriverAttach(pDevIns, 0, &pThisCC->IBase, &pThisCC->pDrvBase, "Network Port");
[93560]	2565	if (RT_SUCCESS(rc))
	2566	{
[93601]	2567	pThisCC->pDrv = PDMIBASE_QUERY_INTERFACE(pThisCC->pDrvBase, PDMINETWORKUP);
	2568	AssertMsgReturn(pThisCC->pDrv, ("Failed to obtain the PDMINETWORKUP interface!\n"),
[93560]	2569	VERR_PDM_MISSING_INTERFACE_BELOW);
[93601]	2570	pThis->fDriverAttached = true;
[93560]	2571	}
	2572	else if ( rc == VERR_PDM_NO_ATTACHED_DRIVER
	2573	\|\| rc == VERR_PDM_CFG_MISSING_DRIVER_NAME)
	2574	{
	2575	/* No error! */
	2576	Log(("No attached driver!\n"));
	2577	}
	2578	else
	2579	return rc;
	2580
	2581	/*
	2582	* Reset the device state. (Do after attaching.)
	2583	*/
[93601]	2584	elnkR3HardReset(pDevIns, pThis);
[93560]	2585
	2586	/*
	2587	* Register statistics counters.
	2588	*/
	2589	PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatReceiveBytes, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES, "Amount of data received", "/Public/Net/EtherLink%u/BytesReceived", iInstance);
	2590	PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatTransmitBytes, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES, "Amount of data transmitted", "/Public/Net/EtherLink%u/BytesTransmitted", iInstance);
	2591
	2592	PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatReceiveBytes, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES, "Amount of data received", "/Devices/EtherLink%d/ReceiveBytes", iInstance);
	2593	PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatTransmitBytes, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES, "Amount of data transmitted", "/Devices/EtherLink%d/TransmitBytes", iInstance);
	2594
	2595	#ifdef VBOX_WITH_STATISTICS
	2596	PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatIOReadRZ, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling IO reads in RZ", "/Devices/EtherLink%d/IO/ReadRZ", iInstance);
	2597	PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatIOReadR3, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling IO reads in R3", "/Devices/EtherLink%d/IO/ReadR3", iInstance);
	2598	PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatIOWriteRZ, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling IO writes in RZ", "/Devices/EtherLink%d/IO/WriteRZ", iInstance);
	2599	PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatIOWriteR3, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling IO writes in R3", "/Devices/EtherLink%d/IO/WriteR3", iInstance);
	2600	PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatReceive, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling receive", "/Devices/EtherLink%d/Receive", iInstance);
	2601	PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatRxOverflow, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_OCCURENCE, "Profiling RX overflows", "/Devices/EtherLink%d/RxOverflow", iInstance);
	2602	PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatRxOverflowWakeup, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_OCCURENCE, "Nr of RX overflow wakeups", "/Devices/EtherLink%d/RxOverflowWakeup", iInstance);
	2603	PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatTransmitRZ, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling transmits in RZ", "/Devices/EtherLink%d/Transmit/TotalRZ", iInstance);
	2604	PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatTransmitR3, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling transmits in R3", "/Devices/EtherLink%d/Transmit/TotalR3", iInstance);
	2605	PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatTransmitSendRZ, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling send transmit in RZ", "/Devices/EtherLink%d/Transmit/SendRZ", iInstance);
	2606	PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatTransmitSendR3, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling send transmit in R3", "/Devices/EtherLink%d/Transmit/SendR3", iInstance);
	2607
	2608	PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatInterrupt, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling interrupt checks", "/Devices/EtherLink%d/UpdateIRQ", iInstance);
	2609
	2610	PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatResets, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES, "Number of soft resets", "/Devices/EtherLink%d/SoftResets", iInstance);
	2611	PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatDropPktAdrmDis, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES, "Dropped packet, disabled address match", "/Devices/EtherLink%d/DropPktAdrmDis", iInstance);
	2612	PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatDropPktZeroLen, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES, "Dropped zero length packet", "/Devices/EtherLink%d/DropPktZeroLen", iInstance);
	2613	PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatDropPktVMNotRunning,STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES, "Dropped packet, VM not running", "/Devices/EtherLink%d/DropPktVMNotRunning", iInstance);
	2614	PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatDropPktNoLink, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES, "Dropped packet, no link", "/Devices/EtherLink%d/DropPktNoLink", iInstance);
	2615	PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatDropPktStaleRcv, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES, "Dropped packet, status register unread", "/Devices/EtherLink%d/DropPktStaleRcv", iInstance);
	2616	#endif /* VBOX_WITH_STATISTICS */
	2617	PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatPktsLostReset, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES, "Number of packets lost due to resets", "/Devices/EtherLink%d/PktsLostByReset", iInstance);
	2618
	2619	return VINF_SUCCESS;
	2620	}
	2621
	2622	#else
	2623
	2624	/**
	2625	* @callback_method_impl{PDMDEVREGR0,pfnConstruct}
	2626	*/
	2627	static DECLCALLBACK(int) elnkRZConstruct(PPDMDEVINS pDevIns)
	2628	{
	2629	PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
	2630	PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE);
	2631
	2632	/* Critical section setup: */
	2633	int rc = PDMDevHlpSetDeviceCritSect(pDevIns, &pThis->CritSect);
	2634	AssertRCReturn(rc, rc);
	2635
	2636	/* ISA I/O ports: */
	2637	if (pThis->hIoPortsIsa != NIL_IOMIOPORTHANDLE)
	2638	{
	2639	rc = PDMDevHlpIoPortSetUpContext(pDevIns, pThis->hIoPortsIsa, elnkIOPortWrite, elnkIOPortRead, NULL /pvUser/);
	2640	AssertRCReturn(rc, rc);
	2641	}
	2642
	2643	return VINF_SUCCESS;
	2644	}
	2645
	2646	#endif /* IN_RING3 */
	2647
	2648	/**
	2649	* The device registration structure.
	2650	*/
	2651	const PDMDEVREG g_Device3C501 =
	2652	{
	2653	/* .u32Version = */ PDM_DEVREG_VERSION,
	2654	/* .uReserved0 = */ 0,
	2655	/* .szName = */ "3c501",
	2656	/* .fFlags = */ PDM_DEVREG_FLAGS_DEFAULT_BITS \| PDM_DEVREG_FLAGS_RZ \| PDM_DEVREG_FLAGS_NEW_STYLE,
	2657	/* .fClass = */ PDM_DEVREG_CLASS_NETWORK,
	2658	/* .cMaxInstances = */ ~0U,
	2659	/* .uSharedVersion = */ 42,
	2660	/* .cbInstanceShared = */ sizeof(ELNKSTATE),
[93601]	2661	/* .cbInstanceCC = */ sizeof(ELNKSTATECC),
	2662	/* .cbInstanceRC = */ sizeof(ELNKSTATERC),
[93560]	2663	/* .cMaxPciDevices = */ 0,
	2664	/* .cMaxMsixVectors = */ 0,
	2665	/* .pszDescription = */ "3Com EtherLink 3C501 adapter.\n",
	2666	#if defined(IN_RING3)
	2667	/* .pszRCMod = */ "VBoxDDRC.rc",
	2668	/* .pszR0Mod = */ "VBoxDDR0.r0",
[93601]	2669	/* .pfnConstruct = */ elnkR3Construct,
	2670	/* .pfnDestruct = */ elnkR3Destruct,
	2671	/* .pfnRelocate = */ elnkR3Relocate,
[93560]	2672	/* .pfnMemSetup = */ NULL,
	2673	/* .pfnPowerOn = */ NULL,
[93601]	2674	/* .pfnReset = */ elnkR3Reset,
	2675	/* .pfnSuspend = */ elnkR3Suspend,
[93560]	2676	/* .pfnResume = */ NULL,
[93601]	2677	/* .pfnAttach = */ elnkR3Attach,
	2678	/* .pfnDetach = */ elnkR3Detach,
[93560]	2679	/* .pfnQueryInterface = */ NULL,
	2680	/* .pfnInitComplete = */ NULL,
[93601]	2681	/* .pfnPowerOff = */ elnkR3PowerOff,
[93560]	2682	/* .pfnSoftReset = */ NULL,
	2683	/* .pfnReserved0 = */ NULL,
	2684	/* .pfnReserved1 = */ NULL,
	2685	/* .pfnReserved2 = */ NULL,
	2686	/* .pfnReserved3 = */ NULL,
	2687	/* .pfnReserved4 = */ NULL,
	2688	/* .pfnReserved5 = */ NULL,
	2689	/* .pfnReserved6 = */ NULL,
	2690	/* .pfnReserved7 = */ NULL,
	2691	#elif defined(IN_RING0)
	2692	/* .pfnEarlyConstruct = */ NULL,
	2693	/* .pfnConstruct = */ elnkRZConstruct,
	2694	/* .pfnDestruct = */ NULL,
	2695	/* .pfnFinalDestruct = */ NULL,
	2696	/* .pfnRequest = */ NULL,
	2697	/* .pfnReserved0 = */ NULL,
	2698	/* .pfnReserved1 = */ NULL,
	2699	/* .pfnReserved2 = */ NULL,
	2700	/* .pfnReserved3 = */ NULL,
	2701	/* .pfnReserved4 = */ NULL,
	2702	/* .pfnReserved5 = */ NULL,
	2703	/* .pfnReserved6 = */ NULL,
	2704	/* .pfnReserved7 = */ NULL,
	2705	#elif defined(IN_RC)
	2706	/* .pfnConstruct = */ NULL,
	2707	/* .pfnReserved0 = */ NULL,
	2708	/* .pfnReserved1 = */ NULL,
	2709	/* .pfnReserved2 = */ NULL,
	2710	/* .pfnReserved3 = */ NULL,
	2711	/* .pfnReserved4 = */ NULL,
	2712	/* .pfnReserved5 = */ NULL,
	2713	/* .pfnReserved6 = */ NULL,
	2714	/* .pfnReserved7 = */ NULL,
	2715	#else
	2716	# error "Not in IN_RING3, IN_RING0 or IN_RC!"
	2717	#endif
	2718	/* .u32VersionEnd = */ PDM_DEVREG_VERSION
	2719	};
	2720
	2721	#endif /* !VBOX_DEVICE_STRUCT_TESTCASE */

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Devices/Network/Dev3C501.cpp@ 96407

Download in other formats: