On Fri, May 31 2019, <zeurk...@volny.cz> wrote: > [not subscribed, please Cc, thanks.]
Not to rain on your parade, but... > 6.5 update of the previous patch, w/ additional 'ne2000' flavour. > > 'dyncore': re-enable the dynamic core (possibly insecure) You don't mention a rationale for this. The only wxneeded report I know of mentions no performance change. https://marc.info/?l=openbsd-ports&m=149053625314161&w=2 So what's the point of lowering the security of an emulator possibly used to run untrusted images? > 'ne2000': add third-party ne(4) emulation I guess this is the easiest way to get networking support in dosbox. But is that a good thing? Running DOS applications on the modern internet looks dubious at best. Technically such a patch should probably be handled using PATCHFILES/SUPDISTFILES. > 'nosplash': disable spam piccy upon invocation Is that a serious proposal? The wording used for the ifdef doesn't seem appropriate. Regarding the intent, your diff contains the surrounding line: > + /* Please leave the Splash screen stuff in working order in DOSBox. We > spend a lot of time making DOSBox. */ That change doesn't look desirable in the ports tree IMO. > Tested only in the most limited of fashions (on 6.5), but expected to > work fine. As always, {bug,test} reports are very welcome. Obviously tests on -current would be better. If you're proposing this diff for inclusion in the ports tree, please make that clear. Your earlier proposal (with MAINTAINER in Cc) didn't make it clear either: https://marc.info/?l=openbsd-ports&m=154669079320603&w=2 FLAVORS should be seldom used, they add complexity and make tests/updates harder. s/WANT_LIB/WANTLIB/ below > Enjoy! > > --zeurkous. > > --- ports/emulators/dosbox/Makefile.orig Tue Jan 22 04:31:41 2019 > +++ ports/emulators/dosbox/Makefile Fri May 31 19:34:00 2019 > @@ -6,6 +6,7 @@ > > VERSION= 0.74-2 > DISTNAME= dosbox-${VERSION} > +REVISION= 0 > PKGNAME= dosbox-${VERSION:S/-/./} > CATEGORIES= games x11 emulators > MASTER_SITES= ${MASTER_SITE_SOURCEFORGE:=dosbox/} > @@ -37,8 +38,26 @@ > CONFIGURE_ENV+=LDFLAGS="-L${LOCALBASE}/lib -L${X11BASE}/lib" > CONFIGURE_ARGS+= --disable-alsatest > > +PATCH_LIST= patch-* > + > +FLAVORS= dyncore ne2000 nosplash > +FLAVOR?= > + > +.if ${FLAVOR:L:Mne2000} > +PATCH_LIST+= ne2000 > +WANT_LIB+=pcap > +.endif > + > +.if ${FLAVOR:L:Mnosplash} > +PATCH_LIST+= nosplash > +.endif > + > +.if ${FLAVOR:L:Mdyncore} > +PATCH_LIST+= wxneeded > +.else > # needs W+X memory > CONFIGURE_ARGS+= --disable-dynamic-core > +.endif > > pre-configure: > cp ${FILESDIR}/midi_sndio.h ${WRKSRC}/src/gui > > --- /dev/null Fri May 31 19:56:39 2019 > +++ ports/emulators/dosbox/patches/ne2000 Fri May 31 19:45:02 2019 > @@ -0,0 +1,2047 @@ > +--- visualc_net/dosbox.vcproj.orig Thu Jul 5 13:24:23 2018 > ++++ visualc_net/dosbox.vcproj Fri May 31 18:19:21 2019 > +@@ -480,6 +480,9 @@ > + <File > + > RelativePath="..\src\hardware\mixer.cpp"> > + </File> > ++ <File > ++ > RelativePath="..\src\hardware\ne2000.cpp"> > ++ </File> > + <File > + RelativePath="..\src\hardware\pic.cpp"> > + </File> > +@@ -827,6 +830,9 @@ > + </File> > + <File > + RelativePath="..\include\mouse.h"> > ++ </File> > ++ <File > ++ RelativePath="..\include\ne2000.h"> > + </File> > + <File > + RelativePath="..\include\paging.h"> > + > +--- src/platform/visualc/config.h.orig Mon Aug 27 14:55:55 2018 > ++++ src/platform/visualc/config.h Fri May 31 18:19:21 2019 > +@@ -12,6 +12,9 @@ > + /* Define to 1 to enable internal modem support, requires SDL_net */ > + #define C_MODEM 1 > + > ++/* Define to 1 to enable NE2000 ethernet passthrough, requires libpcap */ > ++#define C_NE2000 1 > ++ > + /* Define to 1 to enable IPX networking support, requires SDL_net */ > + #define C_IPX 1 > + > + > +--- src/hardware/ne2000.cpp.orig Fri May 31 18:19:21 2019 > ++++ src/hardware/ne2000.cpp Fri May 31 18:28:13 2019 > +@@ -0,0 +1,1660 @@ > ++#include "config.h" > ++ > ++#ifdef C_NE2000 > ++ > ++ > ++#include "dosbox.h" > ++#include <string.h> > ++#include <stdio.h> > ++#include "support.h" > ++#include "inout.h" > ++#include "setup.h" > ++#include "callback.h" > ++#include "timer.h" > ++#include "pic.h" > ++#include "cpu.h" > ++ > ++/* Couldn't find a real spec for the NE2000 out there, hence this is > adapted heavily from Bochs */ > ++ > ++ > ++///////////////////////////////////////////////////////////////////////// > ++// $Id: ne2k.cc,v 1.56.2.1 2004/02/02 22:37:22 cbothamy Exp $ > ++///////////////////////////////////////////////////////////////////////// > ++// > ++// Copyright (C) 2002 MandrakeSoft S.A. > ++// > ++// MandrakeSoft S.A. > ++// 43, rue d'Aboukir > ++// 75002 Paris - France > ++// http://www.linux-mandrake.com/ > ++// http://www.mandrakesoft.com/ > ++// > ++// This library is free software; you can redistribute it and/or > ++// modify it under the terms of the GNU Lesser General Public > ++// License as published by the Free Software Foundation; either > ++// version 2 of the License, or (at your option) any later version. > ++// > ++// This library is distributed in the hope that it will be useful, > ++// but WITHOUT ANY WARRANTY; without even the implied warranty of > ++// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU > ++// Lesser General Public License for more details. > ++// > ++// You should have received a copy of the GNU Lesser General Public > ++// License along with this library; if not, write to the Free Software > ++// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA > ++ > ++// Peter Grehan (gre...@iprg.nokia.com) coded all of this > ++// NE2000/ether stuff. > ++ > ++#include "ne2000.h" > ++ > ++#define HAVE_REMOTE > ++ > ++#include "pcap.h" > ++// Handle to WinPCap device > ++pcap_t *adhandle = 0; > ++static void NE2000_TX_Event(Bitu val); > ++ > ++#ifdef WIN32 > ++// DLL loading > ++#define pcap_sendpacket(A,B,C) PacketSendPacket(A,B,C) > ++#define pcap_close(A) PacketClose(A) > ++#define pcap_freealldevs(A) PacketFreealldevs(A) > ++#define pcap_open(A,B,C,D,E,F) PacketOpen(A,B,C,D,E,F) > ++#define pcap_next_ex(A,B,C) PacketNextEx(A,B,C) > ++#define pcap_findalldevs_ex(A,B,C,D) PacketFindALlDevsEx(A,B,C,D) > ++ > ++int (*PacketSendPacket)(pcap_t *, const u_char *, int) = 0; > ++void (*PacketClose)(pcap_t *) = 0; > ++void (*PacketFreealldevs)(pcap_if_t *) = 0; > ++pcap_t* (*PacketOpen)(char const *,int,int,int,struct pcap_rmtauth *,char > *) = 0; > ++int (*PacketNextEx)(pcap_t *, struct pcap_pkthdr **, const u_char **) = 0; > ++int (*PacketFindALlDevsEx)(char *, struct pcap_rmtauth *, pcap_if_t **, > char *) = 0; > ++ > ++#endif > ++ > ++//Never completely fill the ne2k ring so that we never > ++// hit the unclear completely full buffer condition. > ++#define BX_NE2K_NEVER_FULL_RING (1) > ++ > ++#define LOG_THIS theNE2kDevice-> > ++//#define BX_DEBUG > ++//#define BX_INFO > ++#define BX_NULL_TIMER_HANDLE 0 > ++#define BX_PANIC > ++#define BX_ERROR > ++#define BX_RESET_HARDWARE 0 > ++#define BX_RESET_SOFTWARE 1 > ++ > ++bx_ne2k_c* theNE2kDevice = NULL; > ++ > ++ > ++bx_ne2k_c::bx_ne2k_c(void) > ++{ > ++ s.tx_timer_index = BX_NULL_TIMER_HANDLE; > ++} > ++ > ++ > ++bx_ne2k_c::~bx_ne2k_c(void) > ++{ > ++ // nothing for now > ++} > ++ > ++// > ++// reset - restore state to power-up, cancelling all i/o > ++// > ++void > ++bx_ne2k_c::reset(unsigned type) > ++{ > ++ BX_DEBUG ("reset"); > ++ // Zero out registers and memory > ++ memset( & BX_NE2K_THIS s.CR, 0, sizeof(BX_NE2K_THIS s.CR) ); > ++ memset( & BX_NE2K_THIS s.ISR, 0, sizeof(BX_NE2K_THIS s.ISR)); > ++ memset( & BX_NE2K_THIS s.IMR, 0, sizeof(BX_NE2K_THIS s.IMR)); > ++ memset( & BX_NE2K_THIS s.DCR, 0, sizeof(BX_NE2K_THIS s.DCR)); > ++ memset( & BX_NE2K_THIS s.TCR, 0, sizeof(BX_NE2K_THIS s.TCR)); > ++ memset( & BX_NE2K_THIS s.TSR, 0, sizeof(BX_NE2K_THIS s.TSR)); > ++ //memset( & BX_NE2K_THIS s.RCR, 0, sizeof(BX_NE2K_THIS s.RCR)); > ++ memset( & BX_NE2K_THIS s.RSR, 0, sizeof(BX_NE2K_THIS s.RSR)); > ++ BX_NE2K_THIS s.tx_timer_active = 0; > ++ BX_NE2K_THIS s.local_dma = 0; > ++ BX_NE2K_THIS s.page_start = 0; > ++ BX_NE2K_THIS s.page_stop = 0; > ++ BX_NE2K_THIS s.bound_ptr = 0; > ++ BX_NE2K_THIS s.tx_page_start = 0; > ++ BX_NE2K_THIS s.num_coll = 0; > ++ BX_NE2K_THIS s.tx_bytes = 0; > ++ BX_NE2K_THIS s.fifo = 0; > ++ BX_NE2K_THIS s.remote_dma = 0; > ++ BX_NE2K_THIS s.remote_start = 0; > ++ BX_NE2K_THIS s.remote_bytes = 0; > ++ BX_NE2K_THIS s.tallycnt_0 = 0; > ++ BX_NE2K_THIS s.tallycnt_1 = 0; > ++ BX_NE2K_THIS s.tallycnt_2 = 0; > ++ > ++ //memset( & BX_NE2K_THIS s.physaddr, 0, sizeof(BX_NE2K_THIS s.physaddr)); > ++ //memset( & BX_NE2K_THIS s.mchash, 0, sizeof(BX_NE2K_THIS s.mchash)); > ++ BX_NE2K_THIS s.curr_page = 0; > ++ > ++ BX_NE2K_THIS s.rempkt_ptr = 0; > ++ BX_NE2K_THIS s.localpkt_ptr = 0; > ++ BX_NE2K_THIS s.address_cnt = 0; > ++ > ++ memset( & BX_NE2K_THIS s.mem, 0, sizeof(BX_NE2K_THIS s.mem)); > ++ > ++ // Set power-up conditions > ++ BX_NE2K_THIS s.CR.stop = 1; > ++ BX_NE2K_THIS s.CR.rdma_cmd = 4; > ++ BX_NE2K_THIS s.ISR.reset = 1; > ++ BX_NE2K_THIS s.DCR.longaddr = 1; > ++ PIC_DeActivateIRQ(s.base_irq); > ++ //DEV_pic_lower_irq(BX_NE2K_THIS s.base_irq); > ++} > ++ > ++// > ++// read_cr/write_cr - utility routines for handling reads/writes to > ++// the Command Register > ++// > ++Bit32u > ++bx_ne2k_c::read_cr(void) > ++{ > ++ Bit32u val = > ++ (((BX_NE2K_THIS s.CR.pgsel & 0x03) << 6) | > ++ ((BX_NE2K_THIS s.CR.rdma_cmd & 0x07) << 3) | > ++ (BX_NE2K_THIS s.CR.tx_packet << 2) | > ++ (BX_NE2K_THIS s.CR.start << 1) | > ++ (BX_NE2K_THIS s.CR.stop)); > ++ BX_DEBUG("read CR returns 0x%08x", val); > ++ return val; > ++} > ++ > ++void > ++bx_ne2k_c::write_cr(Bit32u value) > ++{ > ++ BX_DEBUG ("wrote 0x%02x to CR", value); > ++ > ++ // Validate remote-DMA > ++ if ((value & 0x38) == 0x00) { > ++ BX_DEBUG("CR write - invalid rDMA value 0"); > ++ value |= 0x20; /* dma_cmd == 4 is a safe default */ > ++ //value = 0x22; /* dma_cmd == 4 is a safe default */ > ++ } > ++ > ++ // Check for s/w reset > ++ if (value & 0x01) { > ++ BX_NE2K_THIS s.ISR.reset = 1; > ++ BX_NE2K_THIS s.CR.stop = 1; > ++ } else { > ++ BX_NE2K_THIS s.CR.stop = 0; > ++ } > ++ > ++ BX_NE2K_THIS s.CR.rdma_cmd = (value & 0x38) >> 3; > ++ > ++ // If start command issued, the RST bit in the ISR > ++ // must be cleared > ++ if ((value & 0x02) && !BX_NE2K_THIS s.CR.start) { > ++ BX_NE2K_THIS s.ISR.reset = 0; > ++ } > ++ > ++ BX_NE2K_THIS s.CR.start = ((value & 0x02) == 0x02); > ++ BX_NE2K_THIS s.CR.pgsel = (value & 0xc0) >> 6; > ++ > ++ // Check for send-packet command > ++ if (BX_NE2K_THIS s.CR.rdma_cmd == 3) { > ++ // Set up DMA read from receive ring > ++ BX_NE2K_THIS s.remote_start = BX_NE2K_THIS s.remote_dma = > ++ BX_NE2K_THIS s.bound_ptr * 256; > ++ BX_NE2K_THIS s.remote_bytes = *((Bit16u*) & > ++ BX_NE2K_THIS s.mem[BX_NE2K_THIS s.bound_ptr * 256 + 2 - > BX_NE2K_MEMSTART]); > ++ BX_INFO("Sending buffer #x%x length %d", > ++ BX_NE2K_THIS s.remote_start, > ++ BX_NE2K_THIS s.remote_bytes); > ++ } > ++ > ++ // Check for start-tx > ++ if ((value & 0x04) && BX_NE2K_THIS s.TCR.loop_cntl) { > ++ // loopback mode > ++ if (BX_NE2K_THIS s.TCR.loop_cntl != 1) { > ++ BX_INFO("Loop mode %d not supported.", BX_NE2K_THIS > s.TCR.loop_cntl); > ++ } else { > ++ rx_frame (& BX_NE2K_THIS s.mem[BX_NE2K_THIS > s.tx_page_start*256 - > ++ BX_NE2K_MEMSTART], > ++ BX_NE2K_THIS s.tx_bytes); > ++ > ++ // do a TX interrupt > ++ // Generate an interrupt if not masked and not one in > progress > ++ if (BX_NE2K_THIS s.IMR.tx_inte && !BX_NE2K_THIS > s.ISR.pkt_tx) { > ++ //LOG_MSG("tx complete interrupt"); > ++ PIC_ActivateIRQ(s.base_irq); > ++ } > ++ BX_NE2K_THIS s.ISR.pkt_tx = 1; > ++ } > ++ } else if (value & 0x04) { > ++ // start-tx and no loopback > ++ if (BX_NE2K_THIS s.CR.stop || !BX_NE2K_THIS s.CR.start) > ++ BX_PANIC(("CR write - tx start, dev in reset")); > ++ > ++ if (BX_NE2K_THIS s.tx_bytes == 0) > ++ BX_PANIC(("CR write - tx start, tx bytes == 0")); > ++ > ++#ifdef notdef > ++ // XXX debug stuff > ++ printf("packet tx (%d bytes):\t", BX_NE2K_THIS s.tx_bytes); > ++ for (int i = 0; i < BX_NE2K_THIS s.tx_bytes; i++) { > ++ printf("%02x ", BX_NE2K_THIS s.mem[BX_NE2K_THIS s.tx_page_start*256 - > ++ BX_NE2K_MEMSTART + i]); > ++ if (i && (((i+1) % 16) == 0)) > ++ printf("\t"); > ++ } > ++ printf(""); > ++#endif > ++ > ++ // Send the packet to the system driver > ++ /* TODO: Transmit packet */ > ++ //BX_NE2K_THIS ethdev->sendpkt(& BX_NE2K_THIS s.mem[BX_NE2K_THIS > s.tx_page_start*256 - BX_NE2K_MEMSTART], BX_NE2K_THIS s.tx_bytes); > ++ pcap_sendpacket(adhandle,&s.mem[s.tx_page_start*256 - > BX_NE2K_MEMSTART], s.tx_bytes); > ++ // some more debug > ++ if (BX_NE2K_THIS s.tx_timer_active) { > ++ BX_PANIC(("CR write, tx timer still active")); > ++ PIC_RemoveEvents(NE2000_TX_Event); > ++ } > ++ //LOG_MSG("send packet command"); > ++ //s.tx_timer_index = (64 + 96 + 4*8 + BX_NE2K_THIS s.tx_bytes*8)/10; > ++ s.tx_timer_active = 1; > ++ PIC_AddEvent(NE2000_TX_Event,(float)((64 + 96 + 4*8 + BX_NE2K_THIS > s.tx_bytes*8)/10000.0),0); > ++ // Schedule a timer to trigger a tx-complete interrupt > ++ // The number of microseconds is the bit-time / 10. > ++ // The bit-time is the preamble+sfd (64 bits), the > ++ // inter-frame gap (96 bits), the CRC (4 bytes), and the > ++ // the number of bits in the frame (s.tx_bytes * 8). > ++ // > ++ > ++ /* TODO: Code transmit timer */ > ++ /* > ++ bx_pc_system.activate_timer(BX_NE2K_THIS s.tx_timer_index, > ++ (64 + 96 + 4*8 + BX_NE2K_THIS s.tx_bytes*8)/10, > ++ 0); // not continuous > ++ */ > ++ } // end transmit-start branch > ++ > ++ // Linux probes for an interrupt by setting up a remote-DMA read > ++ // of 0 bytes with remote-DMA completion interrupts enabled. > ++ // Detect this here > ++ if (BX_NE2K_THIS s.CR.rdma_cmd == 0x01 && > ++ BX_NE2K_THIS s.CR.start && > ++ BX_NE2K_THIS s.remote_bytes == 0) { > ++ BX_NE2K_THIS s.ISR.rdma_done = 1; > ++ if (BX_NE2K_THIS s.IMR.rdma_inte) { > ++ PIC_ActivateIRQ(s.base_irq); > ++ //DEV_pic_raise_irq(BX_NE2K_THIS s.base_irq); > ++ } > ++ } > ++} > ++ > ++// > ++// chipmem_read/chipmem_write - access the 64K private RAM. > ++// The ne2000 memory is accessed through the data port of > ++// the asic (offset 0) after setting up a remote-DMA transfer. > ++// Both byte and word accesses are allowed. > ++// The first 16 bytes contains the MAC address at even locations, > ++// and there is 16K of buffer memory starting at 16K > ++// > ++Bit32u bx_ne2k_c::chipmem_read(Bit32u address, unsigned int io_len) > ++{ > ++ Bit32u retval = 0; > ++ > ++ if ((io_len == 2) && (address & 0x1)) > ++ BX_PANIC(("unaligned chipmem word read")); > ++ > ++ // ROM'd MAC address > ++ if ((address >=0) && (address <= 31)) { > ++ retval = BX_NE2K_THIS s.macaddr[address]; > ++ if ((io_len == 2) || (io_len == 4)) { > ++ retval |= (BX_NE2K_THIS s.macaddr[address + 1] << 8); > ++ if (io_len == 4) { > ++ retval |= (BX_NE2K_THIS s.macaddr[address + 2] << 16); > ++ retval |= (BX_NE2K_THIS s.macaddr[address + 3] << 24); > ++ } > ++ } > ++ return (retval); > ++ } > ++ > ++ if ((address >= BX_NE2K_MEMSTART) && (address < BX_NE2K_MEMEND)) { > ++ retval = BX_NE2K_THIS s.mem[address - BX_NE2K_MEMSTART]; > ++ if ((io_len == 2) || (io_len == 4)) { > ++ retval |= (BX_NE2K_THIS s.mem[address - BX_NE2K_MEMSTART + 1] << 8); > ++ } > ++ if (io_len == 4) { > ++ retval |= (BX_NE2K_THIS s.mem[address - BX_NE2K_MEMSTART + 2] << 16); > ++ retval |= (BX_NE2K_THIS s.mem[address - BX_NE2K_MEMSTART + 3] << 24); > ++ } > ++ return (retval); > ++ } > ++ > ++ BX_DEBUG("out-of-bounds chipmem read, %04X", address); > ++ > ++ return (0xff); > ++} > ++ > ++void > ++bx_ne2k_c::chipmem_write(Bit32u address, Bit32u value, unsigned io_len) > ++{ > ++ if ((io_len == 2) && (address & 0x1)) > ++ BX_PANIC(("unaligned chipmem word write")); > ++ > ++ if ((address >= BX_NE2K_MEMSTART) && (address < BX_NE2K_MEMEND)) { > ++ BX_NE2K_THIS s.mem[address - BX_NE2K_MEMSTART] = value & 0xff; > ++ if (io_len == 2) > ++ BX_NE2K_THIS s.mem[address - BX_NE2K_MEMSTART + 1] = value >> 8; > ++ } else > ++ BX_DEBUG("out-of-bounds chipmem write, %04X", address); > ++} > ++ > ++// > ++// asic_read/asic_write - This is the high 16 bytes of i/o space > ++// (the lower 16 bytes is for the DS8390). Only two locations > ++// are used: offset 0, which is used for data transfer, and > ++// offset 0xf, which is used to reset the device. > ++// The data transfer port is used to as 'external' DMA to the > ++// DS8390. The chip has to have the DMA registers set up, and > ++// after that, insw/outsw instructions can be used to move > ++// the appropriate number of bytes to/from the device. > ++// > ++Bit32u > ++bx_ne2k_c::asic_read(Bit32u offset, unsigned int io_len) > ++{ > ++ Bit32u retval = 0; > ++ > ++ switch (offset) { > ++ case 0x0: // Data register > ++ // > ++ // A read remote-DMA command must have been issued, > ++ // and the source-address and length registers must > ++ // have been initialised. > ++ // > ++ if (io_len > BX_NE2K_THIS s.remote_bytes) > ++ { > ++ BX_ERROR("ne2K: dma read underrun iolen=%d > remote_bytes=%d",io_len,BX_NE2K_THIS s.remote_bytes); > ++ //return 0; > ++ } > ++ > ++ //BX_INFO(("ne2k read DMA: addr=%4x remote_bytes=%d",BX_NE2K_THIS > s.remote_dma,BX_NE2K_THIS s.remote_bytes)); > ++ retval = chipmem_read(BX_NE2K_THIS s.remote_dma, io_len); > ++ // > ++ // The 8390 bumps the address and decreases the byte count > ++ // by the selected word size after every access, not by > ++ // the amount of data requested by the host (io_len). > ++ // > ++ BX_NE2K_THIS s.remote_dma += (BX_NE2K_THIS s.DCR.wdsize + 1); > ++ if (BX_NE2K_THIS s.remote_dma == BX_NE2K_THIS s.page_stop << 8) { > ++ BX_NE2K_THIS s.remote_dma = BX_NE2K_THIS s.page_start << 8; > ++ } > ++ // keep s.remote_bytes from underflowing > ++ if (BX_NE2K_THIS s.remote_bytes > 1) > ++ BX_NE2K_THIS s.remote_bytes -= (BX_NE2K_THIS s.DCR.wdsize + 1); > ++ else > ++ BX_NE2K_THIS s.remote_bytes = 0; > ++ > ++ // If all bytes have been written, signal remote-DMA complete > ++ if (BX_NE2K_THIS s.remote_bytes == 0) { > ++ BX_NE2K_THIS s.ISR.rdma_done = 1; > ++ if (BX_NE2K_THIS s.IMR.rdma_inte) { > ++ PIC_ActivateIRQ(s.base_irq); > ++ //DEV_pic_raise_irq(BX_NE2K_THIS s.base_irq); > ++ } > ++ } > ++ break; > ++ > ++ case 0xf: // Reset register > ++ theNE2kDevice->reset(BX_RESET_SOFTWARE); > ++ //retval=0x1; > ++ break; > ++ > ++ default: > ++ BX_INFO("asic read invalid address %04x", (unsigned) offset); > ++ break; > ++ } > ++ > ++ return (retval); > ++} > ++ > ++void > ++bx_ne2k_c::asic_write(Bit32u offset, Bit32u value, unsigned io_len) > ++{ > ++ BX_DEBUG("asic write addr=0x%02x, value=0x%04x", (unsigned) offset, > (unsigned) value); > ++ switch (offset) { > ++ case 0x0: // Data register - see asic_read for a description > ++ > ++ if ((io_len == 2) && (BX_NE2K_THIS s.DCR.wdsize == 0)) { > ++ BX_PANIC(("dma write length 2 on byte mode operation")); > ++ break; > ++ } > ++ > ++ if (BX_NE2K_THIS s.remote_bytes == 0) > ++ BX_PANIC(("ne2K: dma write, byte count 0")); > ++ > ++ chipmem_write(BX_NE2K_THIS s.remote_dma, value, io_len); > ++ // is this right ??? asic_read uses DCR.wordsize > ++ BX_NE2K_THIS s.remote_dma += io_len; > ++ if (BX_NE2K_THIS s.remote_dma == BX_NE2K_THIS s.page_stop << 8) { > ++ BX_NE2K_THIS s.remote_dma = BX_NE2K_THIS s.page_start << 8; > ++ } > ++ > ++ BX_NE2K_THIS s.remote_bytes -= io_len; > ++ if (BX_NE2K_THIS s.remote_bytes > BX_NE2K_MEMSIZ) > ++ BX_NE2K_THIS s.remote_bytes = 0; > ++ > ++ // If all bytes have been written, signal remote-DMA complete > ++ if (BX_NE2K_THIS s.remote_bytes == 0) { > ++ BX_NE2K_THIS s.ISR.rdma_done = 1; > ++ if (BX_NE2K_THIS s.IMR.rdma_inte) { > ++ PIC_ActivateIRQ(s.base_irq); > ++ //DEV_pic_raise_irq(BX_NE2K_THIS s.base_irq); > ++ } > ++ } > ++ break; > ++ > ++ case 0xf: // Reset register > ++ theNE2kDevice->reset(BX_RESET_SOFTWARE); > ++ break; > ++ > ++ default: // this is invalid, but happens under win95 device detection > ++ BX_INFO("asic write invalid address %04x, ignoring", (unsigned) offset); > ++ break ; > ++ } > ++} > ++ > ++// > ++// page0_read/page0_write - These routines handle reads/writes to > ++// the 'zeroth' page of the DS8390 register file > ++// > ++Bit32u > ++bx_ne2k_c::page0_read(Bit32u offset, unsigned int io_len) > ++{ > ++ BX_DEBUG("page 0 read from port %04x, len=%u", (unsigned) offset, > ++ (unsigned) io_len); > ++ if (io_len > 1) { > ++ BX_ERROR("bad length! page 0 read from port %04x, len=%u", (unsigned) > offset, > ++ (unsigned) io_len); /* encountered with win98 hardware probe */ > ++ return 0; > ++ } > ++ > ++ > ++ switch (offset) { > ++ case 0x1: // CLDA0 > ++ return (BX_NE2K_THIS s.local_dma & 0xff); > ++ break; > ++ > ++ case 0x2: // CLDA1 > ++ return (BX_NE2K_THIS s.local_dma >> 8); > ++ break; > ++ > ++ case 0x3: // BNRY > ++ return (BX_NE2K_THIS s.bound_ptr); > ++ break; > ++ > ++ case 0x4: // TSR > ++ return ((BX_NE2K_THIS s.TSR.ow_coll << 7) | > ++ (BX_NE2K_THIS s.TSR.cd_hbeat << 6) | > ++ (BX_NE2K_THIS s.TSR.fifo_ur << 5) | > ++ (BX_NE2K_THIS s.TSR.no_carrier << 4) | > ++ (BX_NE2K_THIS s.TSR.aborted << 3) | > ++ (BX_NE2K_THIS s.TSR.collided << 2) | > ++ (BX_NE2K_THIS s.TSR.tx_ok)); > ++ break; > ++ > ++ case 0x5: // NCR > ++ return (BX_NE2K_THIS s.num_coll); > ++ break; > ++ > ++ case 0x6: // FIFO > ++ // reading FIFO is only valid in loopback mode > ++ BX_ERROR(("reading FIFO not supported yet")); > ++ return (BX_NE2K_THIS s.fifo); > ++ break; > ++ > ++ case 0x7: // ISR > ++ return ((BX_NE2K_THIS s.ISR.reset << 7) | > ++ (BX_NE2K_THIS s.ISR.rdma_done << 6) | > ++ (BX_NE2K_THIS s.ISR.cnt_oflow << 5) | > ++ (BX_NE2K_THIS s.ISR.overwrite << 4) | > ++ (BX_NE2K_THIS s.ISR.tx_err << 3) | > ++ (BX_NE2K_THIS s.ISR.rx_err << 2) | > ++ (BX_NE2K_THIS s.ISR.pkt_tx << 1) | > ++ (BX_NE2K_THIS s.ISR.pkt_rx)); > ++ break; > ++ > ++ case 0x8: // CRDA0 > ++ return (BX_NE2K_THIS s.remote_dma & 0xff); > ++ break; > ++ > ++ case 0x9: // CRDA1 > ++ return (BX_NE2K_THIS s.remote_dma >> 8); > ++ break; > ++ > ++ case 0xa: // reserved > ++ BX_INFO(("reserved read - page 0, 0xa")); > ++ return (0xff); > ++ break; > ++ > ++ case 0xb: // reserved > ++ BX_INFO(("reserved read - page 0, 0xb")); > ++ return (0xff); > ++ break; > ++ > ++ case 0xc: // RSR > ++ return ((BX_NE2K_THIS s.RSR.deferred << 7) | > ++ (BX_NE2K_THIS s.RSR.rx_disabled << 6) | > ++ (BX_NE2K_THIS s.RSR.rx_mbit << 5) | > ++ (BX_NE2K_THIS s.RSR.rx_missed << 4) | > ++ (BX_NE2K_THIS s.RSR.fifo_or << 3) | > ++ (BX_NE2K_THIS s.RSR.bad_falign << 2) | > ++ (BX_NE2K_THIS s.RSR.bad_crc << 1) | > ++ (BX_NE2K_THIS s.RSR.rx_ok)); > ++ break; > ++ > ++ case 0xd: // CNTR0 > ++ return (BX_NE2K_THIS s.tallycnt_0); > ++ break; > ++ > ++ case 0xe: // CNTR1 > ++ return (BX_NE2K_THIS s.tallycnt_1); > ++ break; > ++ > ++ case 0xf: // CNTR2 > ++ return (BX_NE2K_THIS s.tallycnt_2); > ++ break; > ++ > ++ default: > ++ BX_PANIC("page 0 offset %04x out of range", (unsigned) offset); > ++ } > ++ > ++ return(0); > ++} > ++ > ++void > ++bx_ne2k_c::page0_write(Bit32u offset, Bit32u value, unsigned io_len) > ++{ > ++ BX_DEBUG("page 0 write to port %04x, len=%u", (unsigned) offset, > ++ (unsigned) io_len); > ++ > ++ // It appears to be a common practice to use outw on page0 regs... > ++ > ++ // break up outw into two outb's > ++ if (io_len == 2) { > ++ page0_write(offset, (value & 0xff), 1); > ++ page0_write(offset + 1, ((value >> 8) & 0xff), 1); > ++ return; > ++ } > ++ > ++ switch (offset) { > ++ case 0x1: // PSTART > ++ BX_NE2K_THIS s.page_start = value; > ++ break; > ++ > ++ case 0x2: // PSTOP > ++ // BX_INFO(("Writing to PSTOP: %02x", value)); > ++ BX_NE2K_THIS s.page_stop = value; > ++ break; > ++ > ++ case 0x3: // BNRY > ++ BX_NE2K_THIS s.bound_ptr = value; > ++ break; > ++ > ++ case 0x4: // TPSR > ++ BX_NE2K_THIS s.tx_page_start = value; > ++ break; > ++ > ++ case 0x5: // TBCR0 > ++ // Clear out low byte and re-insert > ++ BX_NE2K_THIS s.tx_bytes &= 0xff00; > ++ BX_NE2K_THIS s.tx_bytes |= (value & 0xff); > ++ break; > ++ > ++ case 0x6: // TBCR1 > ++ // Clear out high byte and re-insert > ++ BX_NE2K_THIS s.tx_bytes &= 0x00ff; > ++ BX_NE2K_THIS s.tx_bytes |= ((value & 0xff) << 8); > ++ break; > ++ > ++ case 0x7: // ISR > ++ value &= 0x7f; // clear RST bit - status-only bit > ++ // All other values are cleared iff the ISR bit is 1 > ++ BX_NE2K_THIS s.ISR.pkt_rx &= ~((bx_bool)((value & 0x01) == 0x01)); > ++ BX_NE2K_THIS s.ISR.pkt_tx &= ~((bx_bool)((value & 0x02) == 0x02)); > ++ BX_NE2K_THIS s.ISR.rx_err &= ~((bx_bool)((value & 0x04) == 0x04)); > ++ BX_NE2K_THIS s.ISR.tx_err &= ~((bx_bool)((value & 0x08) == 0x08)); > ++ BX_NE2K_THIS s.ISR.overwrite &= ~((bx_bool)((value & 0x10) == 0x10)); > ++ BX_NE2K_THIS s.ISR.cnt_oflow &= ~((bx_bool)((value & 0x20) == 0x20)); > ++ BX_NE2K_THIS s.ISR.rdma_done &= ~((bx_bool)((value & 0x40) == 0x40)); > ++ value = ((BX_NE2K_THIS s.ISR.rdma_done << 6) | > ++ (BX_NE2K_THIS s.ISR.cnt_oflow << 5) | > ++ (BX_NE2K_THIS s.ISR.overwrite << 4) | > ++ (BX_NE2K_THIS s.ISR.tx_err << 3) | > ++ (BX_NE2K_THIS s.ISR.rx_err << 2) | > ++ (BX_NE2K_THIS s.ISR.pkt_tx << 1) | > ++ (BX_NE2K_THIS s.ISR.pkt_rx)); > ++ value &= ((BX_NE2K_THIS s.IMR.rdma_inte << 6) | > ++ (BX_NE2K_THIS s.IMR.cofl_inte << 5) | > ++ (BX_NE2K_THIS s.IMR.overw_inte << 4) | > ++ (BX_NE2K_THIS s.IMR.txerr_inte << 3) | > ++ (BX_NE2K_THIS s.IMR.rxerr_inte << 2) | > ++ (BX_NE2K_THIS s.IMR.tx_inte << 1) | > ++ (BX_NE2K_THIS s.IMR.rx_inte)); > ++ if (value == 0) > ++ PIC_DeActivateIRQ(s.base_irq); > ++ //DEV_pic_lower_irq(BX_NE2K_THIS s.base_irq); > ++ break; > ++ > ++ case 0x8: // RSAR0 > ++ // Clear out low byte and re-insert > ++ BX_NE2K_THIS s.remote_start &= 0xff00; > ++ BX_NE2K_THIS s.remote_start |= (value & 0xff); > ++ BX_NE2K_THIS s.remote_dma = BX_NE2K_THIS s.remote_start; > ++ break; > ++ > ++ case 0x9: // RSAR1 > ++ // Clear out high byte and re-insert > ++ BX_NE2K_THIS s.remote_start &= 0x00ff; > ++ BX_NE2K_THIS s.remote_start |= ((value & 0xff) << 8); > ++ BX_NE2K_THIS s.remote_dma = BX_NE2K_THIS s.remote_start; > ++ break; > ++ > ++ case 0xa: // RBCR0 > ++ // Clear out low byte and re-insert > ++ BX_NE2K_THIS s.remote_bytes &= 0xff00; > ++ BX_NE2K_THIS s.remote_bytes |= (value & 0xff); > ++ break; > ++ > ++ case 0xb: // RBCR1 > ++ // Clear out high byte and re-insert > ++ BX_NE2K_THIS s.remote_bytes &= 0x00ff; > ++ BX_NE2K_THIS s.remote_bytes |= ((value & 0xff) << 8); > ++ break; > ++ > ++ case 0xc: // RCR > ++ // Check if the reserved bits are set > ++ if (value & 0xc0) > ++ BX_INFO(("RCR write, reserved bits set")); > ++ > ++ // Set all other bit-fields > ++ BX_NE2K_THIS s.RCR.errors_ok = ((value & 0x01) == 0x01); > ++ BX_NE2K_THIS s.RCR.runts_ok = ((value & 0x02) == 0x02); > ++ BX_NE2K_THIS s.RCR.broadcast = ((value & 0x04) == 0x04); > ++ BX_NE2K_THIS s.RCR.multicast = ((value & 0x08) == 0x08); > ++ BX_NE2K_THIS s.RCR.promisc = ((value & 0x10) == 0x10); > ++ BX_NE2K_THIS s.RCR.monitor = ((value & 0x20) == 0x20); > ++ > ++ // Monitor bit is a little suspicious... > ++ if (value & 0x20) > ++ BX_INFO(("RCR write, monitor bit set!")); > ++ break; > ++ > ++ case 0xd: // TCR > ++ // Check reserved bits > ++ if (value & 0xe0) > ++ BX_ERROR(("TCR write, reserved bits set")); > ++ > ++ // Test loop mode (not supported) > ++ if (value & 0x06) { > ++ BX_NE2K_THIS s.TCR.loop_cntl = (value & 0x6) >> 1; > ++ BX_INFO("TCR write, loop mode %d not supported", BX_NE2K_THIS > s.TCR.loop_cntl); > ++ } else { > ++ BX_NE2K_THIS s.TCR.loop_cntl = 0; > ++ } > ++ > ++ // Inhibit-CRC not supported. > ++ if (value & 0x01) > ++ BX_PANIC(("TCR write, inhibit-CRC not supported")); > ++ > ++ // Auto-transmit disable very suspicious > ++ if (value & 0x08) > ++ BX_PANIC(("TCR write, auto transmit disable not supported")); > ++ > ++ // Allow collision-offset to be set, although not used > ++ BX_NE2K_THIS s.TCR.coll_prio = ((value & 0x08) == 0x08); > ++ break; > ++ > ++ case 0xe: // DCR > ++ // the loopback mode is not suppported yet > ++ if (!(value & 0x08)) { > ++ BX_ERROR(("DCR write, loopback mode selected")); > ++ } > ++ // It is questionable to set longaddr and auto_rx, since they > ++ // aren't supported on the ne2000. Print a warning and continue > ++ if (value & 0x04) > ++ BX_INFO(("DCR write - LAS set ???")); > ++ if (value & 0x10) > ++ BX_INFO(("DCR write - AR set ???")); > ++ > ++ // Set other values. > ++ BX_NE2K_THIS s.DCR.wdsize = ((value & 0x01) == 0x01); > ++ BX_NE2K_THIS s.DCR.endian = ((value & 0x02) == 0x02); > ++ BX_NE2K_THIS s.DCR.longaddr = ((value & 0x04) == 0x04); // illegal ? > ++ BX_NE2K_THIS s.DCR.loop = ((value & 0x08) == 0x08); > ++ BX_NE2K_THIS s.DCR.auto_rx = ((value & 0x10) == 0x10); // also illegal > ? > ++ BX_NE2K_THIS s.DCR.fifo_size = (value & 0x50) >> 5; > ++ break; > ++ > ++ case 0xf: // IMR > ++ // Check for reserved bit > ++ if (value & 0x80) > ++ BX_PANIC(("IMR write, reserved bit set")); > ++ > ++ // Set other values > ++ BX_NE2K_THIS s.IMR.rx_inte = ((value & 0x01) == 0x01); > ++ BX_NE2K_THIS s.IMR.tx_inte = ((value & 0x02) == 0x02); > ++ BX_NE2K_THIS s.IMR.rxerr_inte = ((value & 0x04) == 0x04); > ++ BX_NE2K_THIS s.IMR.txerr_inte = ((value & 0x08) == 0x08); > ++ BX_NE2K_THIS s.IMR.overw_inte = ((value & 0x10) == 0x10); > ++ BX_NE2K_THIS s.IMR.cofl_inte = ((value & 0x20) == 0x20); > ++ BX_NE2K_THIS s.IMR.rdma_inte = ((value & 0x40) == 0x40); > ++ if(BX_NE2K_THIS s.ISR.pkt_tx && BX_NE2K_THIS s.IMR.tx_inte) { > ++ LOG_MSG("tx irq retrigger"); > ++ PIC_ActivateIRQ(s.base_irq); > ++ } > ++ break; > ++ default: > ++ BX_PANIC("page 0 write, bad offset %0x", offset); > ++ } > ++} > ++ > ++ > ++// > ++// page1_read/page1_write - These routines handle reads/writes to > ++// the first page of the DS8390 register file > ++// > ++Bit32u > ++bx_ne2k_c::page1_read(Bit32u offset, unsigned int io_len) > ++{ > ++ BX_DEBUG("page 1 read from port %04x, len=%u", (unsigned) offset, > ++ (unsigned) io_len); > ++ if (io_len > 1) > ++ BX_PANIC("bad length! page 1 read from port %04x, len=%u", (unsigned) > offset, > ++ (unsigned) io_len); > ++ > ++ switch (offset) { > ++ case 0x1: // PAR0-5 > ++ case 0x2: > ++ case 0x3: > ++ case 0x4: > ++ case 0x5: > ++ case 0x6: > ++ return (BX_NE2K_THIS s.physaddr[offset - 1]); > ++ break; > ++ > ++ case 0x7: // CURR > ++ BX_DEBUG("returning current page: %02x", (BX_NE2K_THIS s.curr_page)); > ++ return (BX_NE2K_THIS s.curr_page); > ++ > ++ case 0x8: // MAR0-7 > ++ case 0x9: > ++ case 0xa: > ++ case 0xb: > ++ case 0xc: > ++ case 0xd: > ++ case 0xe: > ++ case 0xf: > ++ return (BX_NE2K_THIS s.mchash[offset - 8]); > ++ break; > ++ > ++ default: > ++ BX_PANIC("page 1 r offset %04x out of range", (unsigned) offset); > ++ } > ++ > ++ return (0); > ++} > ++ > ++void > ++bx_ne2k_c::page1_write(Bit32u offset, Bit32u value, unsigned io_len) > ++{ > ++ BX_DEBUG("page 1 w offset %04x", (unsigned) offset); > ++ switch (offset) { > ++ case 0x1: // PAR0-5 > ++ case 0x2: > ++ case 0x3: > ++ case 0x4: > ++ case 0x5: > ++ case 0x6: > ++ BX_NE2K_THIS s.physaddr[offset - 1] = value; > ++ break; > ++ > ++ case 0x7: // CURR > ++ BX_NE2K_THIS s.curr_page = value; > ++ break; > ++ > ++ case 0x8: // MAR0-7 > ++ case 0x9: > ++ case 0xa: > ++ case 0xb: > ++ case 0xc: > ++ case 0xd: > ++ case 0xe: > ++ case 0xf: > ++ BX_NE2K_THIS s.mchash[offset - 8] = value; > ++ break; > ++ > ++ default: > ++ BX_PANIC("page 1 w offset %04x out of range", (unsigned) offset); > ++ } > ++} > ++ > ++ > ++// > ++// page2_read/page2_write - These routines handle reads/writes to > ++// the second page of the DS8390 register file > ++// > ++Bit32u > ++bx_ne2k_c::page2_read(Bit32u offset, unsigned int io_len) > ++{ > ++ BX_DEBUG("page 2 read from port %04x, len=%u", (unsigned) offset, > (unsigned) io_len); > ++ > ++ if (io_len > 1) > ++ BX_PANIC("bad length! page 2 read from port %04x, len=%u", (unsigned) > offset, (unsigned) io_len); > ++ > ++ switch (offset) { > ++ case 0x1: // PSTART > ++ return (BX_NE2K_THIS s.page_start); > ++ break; > ++ > ++ case 0x2: // PSTOP > ++ return (BX_NE2K_THIS s.page_stop); > ++ break; > ++ > ++ case 0x3: // Remote Next-packet pointer > ++ return (BX_NE2K_THIS s.rempkt_ptr); > ++ break; > ++ > ++ case 0x4: // TPSR > ++ return (BX_NE2K_THIS s.tx_page_start); > ++ break; > ++ > ++ case 0x5: // Local Next-packet pointer > ++ return (BX_NE2K_THIS s.localpkt_ptr); > ++ break; > ++ > ++ case 0x6: // Address counter (upper) > ++ return (BX_NE2K_THIS s.address_cnt >> 8); > ++ break; > ++ > ++ case 0x7: // Address counter (lower) > ++ return (BX_NE2K_THIS s.address_cnt & 0xff); > ++ break; > ++ > ++ case 0x8: // Reserved > ++ case 0x9: > ++ case 0xa: > ++ case 0xb: > ++ BX_ERROR("reserved read - page 2, 0x%02x", (unsigned) offset); > ++ return (0xff); > ++ break; > ++ > ++ case 0xc: // RCR > ++ return ((BX_NE2K_THIS s.RCR.monitor << 5) | > ++ (BX_NE2K_THIS s.RCR.promisc << 4) | > ++ (BX_NE2K_THIS s.RCR.multicast << 3) | > ++ (BX_NE2K_THIS s.RCR.broadcast << 2) | > ++ (BX_NE2K_THIS s.RCR.runts_ok << 1) | > ++ (BX_NE2K_THIS s.RCR.errors_ok)); > ++ break; > ++ > ++ case 0xd: // TCR > ++ return ((BX_NE2K_THIS s.TCR.coll_prio << 4) | > ++ (BX_NE2K_THIS s.TCR.ext_stoptx << 3) | > ++ ((BX_NE2K_THIS s.TCR.loop_cntl & 0x3) << 1) | > ++ (BX_NE2K_THIS s.TCR.crc_disable)); > ++ break; > ++ > ++ case 0xe: // DCR > ++ return (((BX_NE2K_THIS s.DCR.fifo_size & 0x3) << 5) | > ++ (BX_NE2K_THIS s.DCR.auto_rx << 4) | > ++ (BX_NE2K_THIS s.DCR.loop << 3) | > ++ (BX_NE2K_THIS s.DCR.longaddr << 2) | > ++ (BX_NE2K_THIS s.DCR.endian << 1) | > ++ (BX_NE2K_THIS s.DCR.wdsize)); > ++ break; > ++ > ++ case 0xf: // IMR > ++ return ((BX_NE2K_THIS s.IMR.rdma_inte << 6) | > ++ (BX_NE2K_THIS s.IMR.cofl_inte << 5) | > ++ (BX_NE2K_THIS s.IMR.overw_inte << 4) | > ++ (BX_NE2K_THIS s.IMR.txerr_inte << 3) | > ++ (BX_NE2K_THIS s.IMR.rxerr_inte << 2) | > ++ (BX_NE2K_THIS s.IMR.tx_inte << 1) | > ++ (BX_NE2K_THIS s.IMR.rx_inte)); > ++ break; > ++ > ++ default: > ++ BX_PANIC("page 2 offset %04x out of range", (unsigned) offset); > ++ } > ++ > ++ return (0); > ++}; > ++ > ++void > ++bx_ne2k_c::page2_write(Bit32u offset, Bit32u value, unsigned io_len) > ++{ > ++ // Maybe all writes here should be BX_PANIC()'d, since they > ++ // affect internal operation, but let them through for now > ++ // and print a warning. > ++ if (offset != 0) > ++ BX_ERROR(("page 2 write ?")); > ++ > ++ switch (offset) { > ++ case 0x1: // CLDA0 > ++ // Clear out low byte and re-insert > ++ BX_NE2K_THIS s.local_dma &= 0xff00; > ++ BX_NE2K_THIS s.local_dma |= (value & 0xff); > ++ break; > ++ > ++ case 0x2: // CLDA1 > ++ // Clear out high byte and re-insert > ++ BX_NE2K_THIS s.local_dma &= 0x00ff; > ++ BX_NE2K_THIS s.local_dma |= ((value & 0xff) << 8); > ++ break; > ++ > ++ case 0x3: // Remote Next-pkt pointer > ++ BX_NE2K_THIS s.rempkt_ptr = value; > ++ break; > ++ > ++ case 0x4: > ++ BX_PANIC(("page 2 write to reserved offset 4")); > ++ break; > ++ > ++ case 0x5: // Local Next-packet pointer > ++ BX_NE2K_THIS s.localpkt_ptr = value; > ++ break; > ++ > ++ case 0x6: // Address counter (upper) > ++ // Clear out high byte and re-insert > ++ BX_NE2K_THIS s.address_cnt &= 0x00ff; > ++ BX_NE2K_THIS s.address_cnt |= ((value & 0xff) << 8); > ++ break; > ++ > ++ case 0x7: // Address counter (lower) > ++ // Clear out low byte and re-insert > ++ BX_NE2K_THIS s.address_cnt &= 0xff00; > ++ BX_NE2K_THIS s.address_cnt |= (value & 0xff); > ++ break; > ++ > ++ case 0x8: > ++ case 0x9: > ++ case 0xa: > ++ case 0xb: > ++ case 0xc: > ++ case 0xd: > ++ case 0xe: > ++ case 0xf: > ++ BX_PANIC("page 2 write to reserved offset %0x", offset); > ++ break; > ++ > ++ default: > ++ BX_PANIC("page 2 write, illegal offset %0x", offset); > ++ break; > ++ } > ++} > ++ > ++// > ++// page3_read/page3_write - writes to this page are illegal > ++// > ++Bit32u > ++bx_ne2k_c::page3_read(Bit32u offset, unsigned int io_len) > ++{ > ++ BX_PANIC(("page 3 read attempted")); > ++ return (0); > ++} > ++ > ++void > ++bx_ne2k_c::page3_write(Bit32u offset, Bit32u value, unsigned io_len) > ++{ > ++ BX_PANIC(("page 3 write attempted")); > ++} > ++ > ++// > ++// tx_timer_handler/tx_timer > ++// > ++void > ++bx_ne2k_c::tx_timer_handler(void *this_ptr) > ++{ > ++ bx_ne2k_c *class_ptr = (bx_ne2k_c *) this_ptr; > ++ > ++ class_ptr->tx_timer(); > ++} > ++ > ++void > ++bx_ne2k_c::tx_timer(void) > ++{ > ++ BX_DEBUG(("tx_timer")); > ++ BX_NE2K_THIS s.TSR.tx_ok = 1; > ++ // Generate an interrupt if not masked and not one in progress > ++ if (BX_NE2K_THIS s.IMR.tx_inte && !BX_NE2K_THIS s.ISR.pkt_tx) { > ++ //LOG_MSG("tx complete interrupt"); > ++ PIC_ActivateIRQ(s.base_irq); > ++ //DEV_pic_raise_irq(BX_NE2K_THIS s.base_irq); > ++ } //else LOG_MSG("no tx complete interrupt"); > ++ BX_NE2K_THIS s.ISR.pkt_tx = 1; > ++ BX_NE2K_THIS s.tx_timer_active = 0; > ++} > ++ > ++ > ++// > ++// read_handler/read - i/o 'catcher' function called from BOCHS > ++// mainline when the CPU attempts a read in the i/o space registered > ++// by this ne2000 instance > ++// > ++Bit32u bx_ne2k_c::read_handler(void *this_ptr, Bit32u address, unsigned > io_len) > ++{ > ++#if !BX_USE_NE2K_SMF > ++ bx_ne2k_c *class_ptr = (bx_ne2k_c *) this_ptr; > ++ > ++ return( class_ptr->read(address, io_len) ); > ++} > ++ > ++Bit32u bx_ne2k_c::read(Bit32u address, unsigned io_len) > ++{ > ++#else > ++ UNUSED(this_ptr); > ++#endif // !BX_USE_NE2K_SMF > ++ BX_DEBUG("read addr %x, len %d", address, io_len); > ++ Bit32u retval = 0; > ++ int offset = address - BX_NE2K_THIS s.base_address; > ++ > ++ if (offset >= 0x10) { > ++ retval = asic_read(offset - 0x10, io_len); > ++ } else if (offset == 0x00) { > ++ retval = read_cr(); > ++ } else { > ++ switch (BX_NE2K_THIS s.CR.pgsel) { > ++ case 0x00: > ++ retval = page0_read(offset, io_len); > ++ break; > ++ > ++ case 0x01: > ++ retval = page1_read(offset, io_len); > ++ break; > ++ > ++ case 0x02: > ++ retval = page2_read(offset, io_len); > ++ break; > ++ > ++ case 0x03: > ++ retval = page3_read(offset, io_len); > ++ break; > ++ > ++ default: > ++ BX_PANIC("ne2K: unknown value of pgsel in read - %d", > ++ BX_NE2K_THIS s.CR.pgsel); > ++ } > ++ } > ++ > ++ return (retval); > ++} > ++ > ++// > ++// write_handler/write - i/o 'catcher' function called from BOCHS > ++// mainline when the CPU attempts a write in the i/o space registered > ++// by this ne2000 instance > ++// > ++void > ++bx_ne2k_c::write_handler(void *this_ptr, Bit32u address, Bit32u value, > ++ unsigned io_len) > ++{ > ++#if !BX_USE_NE2K_SMF > ++ bx_ne2k_c *class_ptr = (bx_ne2k_c *) this_ptr; > ++ > ++ class_ptr->write(address, value, io_len); > ++} > ++ > ++void > ++bx_ne2k_c::write(Bit32u address, Bit32u value, unsigned io_len) > ++{ > ++#else > ++ UNUSED(this_ptr); > ++#endif // !BX_USE_NE2K_SMF > ++ BX_DEBUG("write with length %d", io_len); > ++ int offset = address - BX_NE2K_THIS s.base_address; > ++ > ++ // > ++ // The high 16 bytes of i/o space are for the ne2000 asic - > ++ // the low 16 bytes are for the DS8390, with the current > ++ // page being selected by the PS0,PS1 registers in the > ++ // command register > ++ // > ++ if (offset >= 0x10) { > ++ asic_write(offset - 0x10, value, io_len); > ++ } else if (offset == 0x00) { > ++ write_cr(value); > ++ } else { > ++ switch (BX_NE2K_THIS s.CR.pgsel) { > ++ case 0x00: > ++ page0_write(offset, value, io_len); > ++ break; > ++ > ++ case 0x01: > ++ page1_write(offset, value, io_len); > ++ break; > ++ > ++ case 0x02: > ++ page2_write(offset, value, io_len); > ++ break; > ++ > ++ case 0x03: > ++ page3_write(offset, value, io_len); > ++ break; > ++ > ++ default: > ++ BX_PANIC("ne2K: unknown value of pgsel in write - %d", > ++ BX_NE2K_THIS s.CR.pgsel); > ++ } > ++ } > ++} > ++ > ++ > ++/* > ++ * mcast_index() - return the 6-bit index into the multicast > ++ * table. Stolen unashamedly from FreeBSD's if_ed.c > ++ */ > ++unsigned > ++bx_ne2k_c::mcast_index(const void *dst) > ++{ > ++#define POLYNOMIAL 0x04c11db6 > ++ Bit32u crc = 0xffffffffL; > ++ int carry, i, j; > ++ unsigned char b; > ++ unsigned char *ep = (unsigned char *) dst; > ++ > ++ for (i = 6; --i >= 0;) { > ++ b = *ep++; > ++ for (j = 8; --j >= 0;) { > ++ carry = ((crc & 0x80000000L) ? 1 : 0) ^ (b & 0x01); > ++ crc <<= 1; > ++ b >>= 1; > ++ if (carry) > ++ crc = ((crc ^ POLYNOMIAL) | carry); > ++ } > ++ } > ++ return (crc >> 26); > ++#undef POLYNOMIAL > ++} > ++ > ++/* > ++ * Callback from the eth system driver when a frame has arrived > ++ */ > ++/* > ++void > ++bx_ne2k_c::rx_handler(void *arg, const void *buf, unsigned len) > ++{ > ++ // BX_DEBUG(("rx_handler with length %d", len)); > ++ bx_ne2k_c *class_ptr = (bx_ne2k_c *) arg; > ++ if( > ++ class_ptr->rx_frame(buf, len); > ++} > ++*/ > ++/* > ++ * rx_frame() - called by the platform-specific code when an > ++ * ethernet frame has been received. The destination address > ++ * is tested to see if it should be accepted, and if the > ++ * rx ring has enough room, it is copied into it and > ++ * the receive process is updated > ++ */ > ++void > ++bx_ne2k_c::rx_frame(const void *buf, unsigned io_len) > ++{ > ++ int pages; > ++ int avail; > ++ unsigned idx; > ++ int wrapped; > ++ int nextpage; > ++ unsigned char pkthdr[4]; > ++ unsigned char *pktbuf = (unsigned char *) buf; > ++ unsigned char *startptr; > ++ static unsigned char bcast_addr[6] = {0xff,0xff,0xff,0xff,0xff,0xff}; > ++ > ++ if(io_len != 60) { > ++ BX_DEBUG("rx_frame with length %d", io_len); > ++ } > ++ > ++ //LOG_MSG("stop=%d, pagestart=%x, dcr_loop=%x, tcr_loopcntl=%x", > ++ // BX_NE2K_THIS s.CR.stop, BX_NE2K_THIS s.page_start, > ++ // BX_NE2K_THIS s.DCR.loop, BX_NE2K_THIS s.TCR.loop_cntl); > ++ if ((BX_NE2K_THIS s.CR.stop != 0) || > ++ (BX_NE2K_THIS s.page_start == 0) /*|| > ++ ((BX_NE2K_THIS s.DCR.loop == 0) && > ++ (BX_NE2K_THIS s.TCR.loop_cntl != 0))*/) { > ++ return; > ++ } > ++ > ++ // Add the pkt header + CRC to the length, and work > ++ // out how many 256-byte pages the frame would occupy > ++ pages = (io_len + 4 + 4 + 255)/256; > ++ > ++ if (BX_NE2K_THIS s.curr_page < BX_NE2K_THIS s.bound_ptr) { > ++ avail = BX_NE2K_THIS s.bound_ptr - BX_NE2K_THIS s.curr_page; > ++ } else { > ++ avail = (BX_NE2K_THIS s.page_stop - BX_NE2K_THIS s.page_start) - > ++ (BX_NE2K_THIS s.curr_page - BX_NE2K_THIS s.bound_ptr); > ++ wrapped = 1; > ++ } > ++ > ++ // Avoid getting into a buffer overflow condition by not attempting > ++ // to do partial receives. The emulation to handle this condition > ++ // seems particularly painful. > ++ if ((avail < pages) > ++#if BX_NE2K_NEVER_FULL_RING > ++ || (avail == pages) > ++#endif > ++ ) { > ++ BX_DEBUG("no space"); > ++ return; > ++ } > ++ > ++ if ((io_len < 40/*60*/) && !BX_NE2K_THIS s.RCR.runts_ok) { > ++ BX_DEBUG("rejected small packet, length %d", io_len); > ++ return; > ++ } > ++ // some computers don't care... > ++ if (io_len < 60) io_len=60; > ++ > ++ // Do address filtering if not in promiscuous mode > ++ if (! BX_NE2K_THIS s.RCR.promisc) { > ++ if (!memcmp(buf, bcast_addr, 6)) { > ++ if (!BX_NE2K_THIS s.RCR.broadcast) { > ++ return; > ++ } > ++ } else if (pktbuf[0] & 0x01) { > ++ if (! BX_NE2K_THIS s.RCR.multicast) { > ++ return; > ++ } > ++ idx = mcast_index(buf); > ++ if (!(BX_NE2K_THIS s.mchash[idx >> 3] & (1 << (idx & 0x7)))) { > ++ return; > ++ } > ++ } else if (0 != memcmp(buf, BX_NE2K_THIS s.physaddr, 6)) { > ++ return; > ++ } > ++ } else { > ++ BX_DEBUG(("rx_frame promiscuous receive")); > ++ } > ++ > ++ BX_INFO("rx_frame %d to %x:%x:%x:%x:%x:%x from %x:%x:%x:%x:%x:%x", > ++ io_len, > ++ pktbuf[0], pktbuf[1], pktbuf[2], pktbuf[3], pktbuf[4], pktbuf[5], > ++ pktbuf[6], pktbuf[7], pktbuf[8], pktbuf[9], pktbuf[10], pktbuf[11]); > ++ > ++ nextpage = BX_NE2K_THIS s.curr_page + pages; > ++ if (nextpage >= BX_NE2K_THIS s.page_stop) { > ++ nextpage -= BX_NE2K_THIS s.page_stop - BX_NE2K_THIS s.page_start; > ++ } > ++ > ++ // Setup packet header > ++ pkthdr[0] = 0; // rx status - old behavior > ++ pkthdr[0] = 1; // Probably better to set it all the time > ++ // rather than set it to 0, which is clearly wrong. > ++ if (pktbuf[0] & 0x01) { > ++ pkthdr[0] |= 0x20; // rx status += multicast packet > ++ } > ++ pkthdr[1] = nextpage; // ptr to next packet > ++ pkthdr[2] = (io_len + 4) & 0xff; // length-low > ++ pkthdr[3] = (io_len + 4) >> 8; // length-hi > ++ > ++ // copy into buffer, update curpage, and signal interrupt if config'd > ++ startptr = & BX_NE2K_THIS s.mem[BX_NE2K_THIS s.curr_page * 256 - > ++ BX_NE2K_MEMSTART]; > ++ if ((nextpage > BX_NE2K_THIS s.curr_page) || > ++ ((BX_NE2K_THIS s.curr_page + pages) == BX_NE2K_THIS s.page_stop)) { > ++ memcpy(startptr, pkthdr, 4); > ++ memcpy(startptr + 4, buf, io_len); > ++ BX_NE2K_THIS s.curr_page = nextpage; > ++ } else { > ++ int endbytes = (BX_NE2K_THIS s.page_stop - BX_NE2K_THIS s.curr_page) > ++ * 256; > ++ memcpy(startptr, pkthdr, 4); > ++ memcpy(startptr + 4, buf, endbytes - 4); > ++ startptr = & BX_NE2K_THIS s.mem[BX_NE2K_THIS s.page_start * 256 - > ++ BX_NE2K_MEMSTART]; > ++ memcpy(startptr, (void *)(pktbuf + endbytes - 4), > ++ io_len - endbytes + 8); > ++ BX_NE2K_THIS s.curr_page = nextpage; > ++ } > ++ > ++ BX_NE2K_THIS s.RSR.rx_ok = 1; > ++ if (pktbuf[0] & 0x80) { > ++ BX_NE2K_THIS s.RSR.rx_mbit = 1; > ++ } > ++ > ++ BX_NE2K_THIS s.ISR.pkt_rx = 1; > ++ > ++ if (BX_NE2K_THIS s.IMR.rx_inte) { > ++ //LOG_MSG("packet rx interrupt"); > ++ PIC_ActivateIRQ(s.base_irq); > ++ //DEV_pic_raise_irq(BX_NE2K_THIS s.base_irq); > ++ } //else LOG_MSG("no packet rx interrupt"); > ++ > ++} > ++ > ++//Bit8u macaddr[6] = { 0xAC, 0xDE, 0x48, 0x8E, 0x89, 0x19 }; > ++ > ++Bitu dosbox_read(Bitu port, Bitu len) { > ++ Bitu retval = theNE2kDevice->read(port,len); > ++ //LOG_MSG("ne2k rd port %x val %4x len %d page %d, CS:IP %8x:%8x", > ++ // port, retval, len, > theNE2kDevice->s.CR.pgsel,SegValue(cs),reg_eip); > ++ return retval; > ++} > ++void dosbox_write(Bitu port, Bitu val, Bitu len) { > ++ //LOG_MSG("ne2k wr port %x val %4x len %d page %d, CS:IP %8x:%8x", > ++ // port, val, len,theNE2kDevice->s.CR.pgsel,SegValue(cs),reg_eip); > ++ theNE2kDevice->write(port, val, len); > ++} > ++ > ++void bx_ne2k_c::init() > ++{ > ++ //BX_DEBUG(("Init $Id: ne2k.cc,v 1.56.2.1 2004/02/02 22:37:22 cbothamy > Exp $")); > ++ > ++ // Read in values from config file > ++ //BX_NE2K_THIS s.base_address = 0x300; > ++ //BX_NE2K_THIS s.base_irq = 3; > ++ /* > ++ if (BX_NE2K_THIS s.tx_timer_index == BX_NULL_TIMER_HANDLE) { > ++ BX_NE2K_THIS s.tx_timer_index = > ++ bx_pc_system.register_timer(this, tx_timer_handler, 0, > ++ 0,0, "ne2k"); // one-shot, inactive > ++ }*/ > ++ // Register the IRQ and i/o port addresses > ++ //DEV_register_irq(BX_NE2K_THIS s.base_irq, "NE2000 ethernet NIC"); > ++ > ++ //DEV_register_ioread_handler(this, read_handler, addr, "ne2000 NIC", 3); > ++ //DEV_register_iowrite_handler(this, write_handler, addr, "ne2000 NIC", > 3); > ++ > ++ > ++ BX_INFO("port 0x%x/32 irq %d mac %02x:%02x:%02x:%02x:%02x:%02x", > ++ BX_NE2K_THIS s.base_address, > ++ BX_NE2K_THIS s.base_irq, > ++ BX_NE2K_THIS s.physaddr[0], > ++ BX_NE2K_THIS s.physaddr[1], > ++ BX_NE2K_THIS s.physaddr[2], > ++ BX_NE2K_THIS s.physaddr[3], > ++ BX_NE2K_THIS s.physaddr[4], > ++ BX_NE2K_THIS s.physaddr[5]); > ++ > ++ // Initialise the mac address area by doubling the physical address > ++ BX_NE2K_THIS s.macaddr[0] = BX_NE2K_THIS s.physaddr[0]; > ++ BX_NE2K_THIS s.macaddr[1] = BX_NE2K_THIS s.physaddr[0]; > ++ BX_NE2K_THIS s.macaddr[2] = BX_NE2K_THIS s.physaddr[1]; > ++ BX_NE2K_THIS s.macaddr[3] = BX_NE2K_THIS s.physaddr[1]; > ++ BX_NE2K_THIS s.macaddr[4] = BX_NE2K_THIS s.physaddr[2]; > ++ BX_NE2K_THIS s.macaddr[5] = BX_NE2K_THIS s.physaddr[2]; > ++ BX_NE2K_THIS s.macaddr[6] = BX_NE2K_THIS s.physaddr[3]; > ++ BX_NE2K_THIS s.macaddr[7] = BX_NE2K_THIS s.physaddr[3]; > ++ BX_NE2K_THIS s.macaddr[8] = BX_NE2K_THIS s.physaddr[4]; > ++ BX_NE2K_THIS s.macaddr[9] = BX_NE2K_THIS s.physaddr[4]; > ++ BX_NE2K_THIS s.macaddr[10] = BX_NE2K_THIS s.physaddr[5]; > ++ BX_NE2K_THIS s.macaddr[11] = BX_NE2K_THIS s.physaddr[5]; > ++ > ++ // ne2k signature > ++ for (Bitu i = 12; i < 32; i++) > ++ BX_NE2K_THIS s.macaddr[i] = 0x57; > ++ > ++ // Bring the register state into power-up state > ++ reset(BX_RESET_HARDWARE); > ++} > ++ > ++static void NE2000_TX_Event(Bitu val) { > ++ theNE2kDevice->tx_timer(); > ++} > ++ > ++static void NE2000_Poller(void) { > ++ int res; > ++ struct pcap_pkthdr *header; > ++ u_char *pkt_data; > ++//#if 0 > ++ while((res = pcap_next_ex( adhandle, &header, (const u_char > **)&pkt_data)) > 0) { > ++ //LOG_MSG("NE2000: Received %d bytes", header->len); > ++ > ++ // don't receive in loopback modes > ++ if((theNE2kDevice->s.DCR.loop == 0) || > (theNE2kDevice->s.TCR.loop_cntl != 0)) > ++ return; > ++ theNE2kDevice->rx_frame(pkt_data, header->len); > ++ } > ++//#endif > ++} > ++#ifdef WIN32 > ++#include <windows.h> > ++#endif > ++ > ++class NE2K: public Module_base { > ++private: > ++ // Data > ++ IO_ReadHandleObject ReadHandler8[0x20]; > ++ IO_WriteHandleObject WriteHandler8[0x20]; > ++ IO_ReadHandleObject ReadHandler16[0x10]; > ++ IO_WriteHandleObject WriteHandler16[0x10]; > ++ > ++public: > ++ bool load_success; > ++ NE2K(Section* configuration):Module_base(configuration) { > ++ Section_prop * section=static_cast<Section_prop > *>(configuration); > ++ > ++ load_success = true; > ++ // enabled? > ++ > ++ if(!section->Get_bool("ne2000")) { > ++ load_success = false; > ++ return; > ++ } > ++ > ++#ifdef WIN32 > ++/* > ++ int (*PacketSendPacket)(pcap_t *, const u_char *, int); > ++ void (*PacketClose)(pcap_t *); > ++ void (*PacketFreealldevs)(pcap_if_t *); > ++ pcap_t* (*PacketOpen)(char const *,int,int,int,struct > pcap_rmtauth *,char *); > ++ int (*PacketNextEx)(pcap_t *, struct pcap_pkthdr **, const > u_char **); > ++ int (*PacketFindALlDevsEx)(char *, struct pcap_rmtauth *, > pcap_if_t **, char *); > ++*/ > ++ // init the library > ++ HINSTANCE pcapinst; > ++ pcapinst = LoadLibrary("WPCAP.DLL"); > ++ if(pcapinst==NULL) { > ++ LOG_MSG("WinPcap has to be installed for the NE2000 to > work."); > ++ load_success = false; > ++ return; > ++ } > ++ FARPROC psp; > ++ > ++ psp = GetProcAddress(pcapinst,"pcap_sendpacket"); > ++ if(!PacketSendPacket) PacketSendPacket = > ++ (int (__cdecl *)(pcap_t *,const u_char *,int))psp; > ++ > ++ psp = GetProcAddress(pcapinst,"pcap_close"); > ++ if(!PacketClose) PacketClose = > ++ (void (__cdecl *)(pcap_t *)) psp; > ++ > ++ psp = GetProcAddress(pcapinst,"pcap_freealldevs"); > ++ if(!PacketFreealldevs) PacketFreealldevs = > ++ (void (__cdecl *)(pcap_if_t *)) psp; > ++ > ++ psp = GetProcAddress(pcapinst,"pcap_open"); > ++ if(!PacketOpen) PacketOpen = > ++ (pcap_t* (__cdecl *)(char const *,int,int,int,struct > pcap_rmtauth *,char *)) psp; > ++ > ++ psp = GetProcAddress(pcapinst,"pcap_next_ex"); > ++ if(!PacketNextEx) PacketNextEx = > ++ (int (__cdecl *)(pcap_t *, struct pcap_pkthdr **, const > u_char **)) psp; > ++ > ++ psp = GetProcAddress(pcapinst,"pcap_findalldevs_ex"); > ++ if(!PacketFindALlDevsEx) PacketFindALlDevsEx = > ++ (int (__cdecl *)(char *, struct pcap_rmtauth *, > pcap_if_t **, char *)) psp; > ++ > ++ if(PacketFindALlDevsEx==0 || PacketNextEx==0 || PacketOpen==0 > || > ++ PacketFreealldevs==0 || PacketClose==0 || > PacketSendPacket==0) { > ++ LOG_MSG("Wrong WinPcap version or something"); > ++ load_success = false; > ++ return; > ++ } > ++ > ++#endif > ++ > ++ // get irq and base > ++ Bitu irq = section->Get_int("nicirq"); > ++ if(!(irq==3 || irq==4 || irq==5 || irq==6 ||irq==7 || > ++ irq==9 || irq==10 || irq==11 || irq==12 ||irq==14 > ||irq==15)) { > ++ irq=3; > ++ } > ++ Bitu base = section->Get_hex("nicbase"); > ++ > if(!(base==0x260||base==0x280||base==0x300||base==0x320||base==0x340||base==0x380)) > { > ++ base=0x300; > ++ } > ++ > ++ // mac address > ++ const char* macstring=section->Get_string("macaddr"); > ++ Bitu macint[6]; > ++ Bit8u mac[6]; > ++ if(sscanf(macstring,"%02x:%02x:%02x:%02x:%02x:%02x", > ++ > &macint[0],&macint[1],&macint[2],&macint[3],&macint[4],&macint[5]) != 6) { > ++ mac[0]=0xac;mac[1]=0xde;mac[2]=0x48; > ++ mac[3]=0x88;mac[4]=0xbb;mac[5]=0xaa; > ++ } else { > ++ mac[0]=macint[0]; mac[1]=macint[1]; > ++ mac[2]=macint[2]; mac[3]=macint[3]; > ++ mac[4]=macint[4]; mac[5]=macint[5]; > ++ } > ++ > ++ // find out which pcap device to use > ++ const char* realnicstring=section->Get_string("realnic"); > ++ pcap_if_t *alldevs; > ++ pcap_if_t *currentdev = NULL; > ++ char errbuf[PCAP_ERRBUF_SIZE]; > ++ Bitu userdev; > ++#ifdef WIN32 > ++ if (pcap_findalldevs_ex(PCAP_SRC_IF_STRING, NULL, &alldevs, > errbuf) == -1) > ++#else > ++ if (pcap_findalldevs(&alldevs, errbuf) == -1) > ++#endif > ++ { > ++ LOG_MSG("Cannot enumerate network interfaces: %s\n", > errbuf); > ++ load_success = false; > ++ return; > ++ } > ++ if (!strcasecmp(realnicstring,"list")) { > ++ // print list and quit > ++ Bitu i = 0; > ++ LOG_MSG("\nNetwork Interface List > \n-----------------------------------"); > ++ for(currentdev=alldevs; currentdev!=NULL; > currentdev=currentdev->next) { > ++ const char* desc = "no description"; > ++ if(currentdev->description) > desc=currentdev->description; > ++ i++; > ++ LOG_MSG("%2d. %s\n > (%s)\n",i,currentdev->name,desc); > ++ } > ++ pcap_freealldevs(alldevs); > ++ load_success = false; > ++ return; > ++ } else if(1==sscanf(realnicstring,"%u",&userdev)) { > ++ // user passed us a number > ++ Bitu i = 0; > ++ currentdev=alldevs; > ++ while(currentdev!=NULL) { > ++ i++; > ++ if(i==userdev) break; > ++ else currentdev=currentdev->next; > ++ } > ++ } else { > ++ // user might have passed a piece of name > ++ for(currentdev=alldevs; currentdev!=NULL; > currentdev=currentdev->next) { > ++ if(strstr(currentdev->name,realnicstring)) { > ++ break; > ++ }else if(currentdev->description!=NULL && > ++ > strstr(currentdev->description,realnicstring)) { > ++ break; > ++ } > ++ } > ++ } > ++ > ++ if(currentdev==NULL) { > ++ LOG_MSG("Unable to find network interface - check > realnic parameter\n"); > ++ load_success = false; > ++ pcap_freealldevs(alldevs); > ++ return; > ++ } > ++ // print out which interface we are going to use > ++ const char* desc = "no description"; > ++ if(currentdev->description) desc=currentdev->description; > ++ LOG_MSG("Using Network > interface:\n%s\n(%s)\n",currentdev->name,desc); > ++ > ++ // attempt to open it > ++#ifdef WIN32 > ++ if ( (adhandle= pcap_open( > ++ currentdev->name, // name of the device > ++ 65536, // portion of the packet to capture > ++ // 65536 = whole packet > ++ PCAP_OPENFLAG_PROMISCUOUS, // promiscuous mode > ++ -1, // read timeout > ++ NULL, // authentication on the remote machine > ++ errbuf // error buffer > ++ ) ) == NULL) > ++#else > ++ /*pcap_t *pcap_open_live(const char *device, int snaplen, > ++ int promisc, int to_ms, char *errbuf)*/ > ++ if ( (adhandle= pcap_open_live( > ++ currentdev->name, // name of the device > ++ 65536, // portion of the packet to capture > ++ // 65536 = whole packet > ++ true, // promiscuous mode > ++ -1, // read timeout > ++ errbuf // error buffer > ++ ) ) == NULL) > ++ > ++#endif > ++ { > ++ LOG_MSG("\nUnable to open the interface: %s.", > errbuf); > ++ pcap_freealldevs(alldevs); > ++ load_success = false; > ++ return; > ++ } > ++ pcap_freealldevs(alldevs); > ++#ifndef WIN32 > ++ pcap_setnonblock(adhandle,1,errbuf); > ++#endif > ++ // create the bochs NIC class > ++ theNE2kDevice = new bx_ne2k_c (); > ++ memcpy(theNE2kDevice->s.physaddr, mac, 6); > ++ theNE2kDevice->init(); > ++ > ++ theNE2kDevice->s.base_address=base; > ++ theNE2kDevice->s.base_irq=irq; > ++ > ++ // install I/O-handlers and timer > ++ for(Bitu i = 0; i < 0x20; i++) { > ++ > ReadHandler8[i].Install((i+theNE2kDevice->s.base_address), > ++ dosbox_read,IO_MB|IO_MW); > ++ > WriteHandler8[i].Install((i+theNE2kDevice->s.base_address), > ++ dosbox_write,IO_MB|IO_MW); > ++ } > ++ TIMER_AddTickHandler(NE2000_Poller); > ++ } > ++ > ++ ~NE2K() { > ++ if(adhandle) pcap_close(adhandle); > ++ adhandle=0; > ++ if(theNE2kDevice != 0) delete theNE2kDevice; > ++ theNE2kDevice=0; > ++ TIMER_DelTickHandler(NE2000_Poller); > ++ PIC_RemoveEvents(NE2000_TX_Event); > ++ } > ++}; > ++ > ++static NE2K* test; > ++void NE2K_ShutDown(Section* sec) { > ++ if(test) delete test; > ++ test=0; > ++} > ++ > ++void NE2K_Init(Section* sec) { > ++ test = new NE2K(sec); > ++ sec->AddDestroyFunction(&NE2K_ShutDown,true); > ++ if(!test->load_success) { > ++ delete test; > ++ test=0; > ++ } > ++} > ++ > ++#endif // C_NE2000 > + > +--- src/hardware/Makefile.am.orig Mon Aug 27 10:34:03 2018 > ++++ src/hardware/Makefile.am Fri May 31 18:19:22 2019 > +@@ -10,6 +10,6 @@ > + memory.cpp mixer.cpp pcspeaker.cpp pic.cpp > sblaster.cpp tandy_sound.cpp timer.cpp \ > + vga.cpp vga_attr.cpp vga_crtc.cpp vga_dac.cpp > vga_draw.cpp vga_gfx.cpp vga_other.cpp \ > + vga_memory.cpp vga_misc.cpp vga_seq.cpp vga_xga.cpp > vga_s3.cpp vga_tseng.cpp vga_paradise.cpp \ > +- cmos.cpp disney.cpp gus.cpp mpu401.cpp ipx.cpp > ipxserver.cpp dbopl.cpp > ++ cmos.cpp disney.cpp gus.cpp mpu401.cpp ipx.cpp > ipxserver.cpp dbopl.cpp ne2000.cpp > + > + > + > +--- src/dosbox.cpp.orig Mon Aug 27 16:41:22 2018 > ++++ src/dosbox.cpp Fri May 31 18:19:22 2019 > +@@ -43,6 +43,11 @@ > + #include "ints/int10.h" > + #include "render.h" > + > ++#ifdef C_NE2000 > ++//#include "ne2000.h" > ++void NE2K_Init(Section* sec); > ++#endif > ++ > + Config * control; > + MachineType machine; > + SVGACards svgaCard; > +@@ -751,6 +756,46 @@ > + Pbool = secprop->Add_bool("ipx",Property::Changeable::WhenIdle, false); > + Pbool->Set_help("Enable ipx over UDP/IP emulation."); > + #endif > ++ > ++#ifdef C_NE2000 > ++ secprop=control->AddSection_prop("ne2000",&NE2K_Init,true); > ++ MSG_Add("NE2000_CONFIGFILE_HELP", > ++ "macaddr -- The physical address the emulator will use on your > network.\n" > ++ " If you have multiple DOSBoxes running on your > network,\n" > ++ " this has to be changed. Modify the last three > number blocks.\n" > ++ " I.e. AC:DE:48:88:99:AB.\n" > ++ "realnic -- Specifies which of your network interfaces is > used.\n" > ++ " Write \'list\' here to see the list of devices in > the\n" > ++ " Status Window. Then make your choice and put either > the\n" > ++ " interface number (2 or something) or a part of your > adapters\n" > ++ " name, e.g. VIA here.\n" > ++ > ++ ); > ++ > ++ Pbool = secprop->Add_bool("ne2000", Property::Changeable::WhenIdle, > true); > ++ Pbool->Set_help("Enable Ethernet passthrough. Requires [Win]Pcap."); > ++ > ++ Phex = secprop->Add_hex("nicbase", Property::Changeable::WhenIdle, > 0x300); > ++ Phex->Set_help("The base address of the NE2000 board."); > ++ > ++ Pint = secprop->Add_int("nicirq", Property::Changeable::WhenIdle, 3); > ++ Pint->Set_help("The interrupt it uses. Note serial2 uses IRQ3 as > default."); > ++ > ++ Pstring = secprop->Add_string("macaddr", > Property::Changeable::WhenIdle,"AC:DE:48:88:99:AA"); > ++ Pstring->Set_help("The physical address the emulator will use on your > network.\n" > ++ "If you have multiple DOSBoxes running on your network,\n" > ++ "this has to be changed for each. AC:DE:48 is an address range > reserved for\n" > ++ "private use, so modify the last three number blocks.\n" > ++ "I.e. AC:DE:48:88:99:AB."); > ++ > ++ Pstring = secprop->Add_string("realnic", > Property::Changeable::WhenIdle,"list"); > ++ Pstring->Set_help("Specifies which of your network interfaces is > used.\n" > ++ "Write \'list\' here to see the list of devices in the\n" > ++ "Status Window. Then make your choice and put either the\n" > ++ "interface number (2 or something) or a part of your adapters\n" > ++ "name, e.g. VIA here."); > ++#endif // C_NE2000 > ++ > + // secprop->AddInitFunction(&CREDITS_Init); > + > + //TODO ? > + > +--- include/ne2000.h.orig Fri May 31 18:19:22 2019 > ++++ include/ne2000.h Fri May 31 18:19:22 2019 > +@@ -0,0 +1,251 @@ > ++///////////////////////////////////////////////////////////////////////// > ++// $Id: ne2k.h,v 1.11.2.3 2003/04/06 17:29:49 bdenney Exp $ > ++///////////////////////////////////////////////////////////////////////// > ++// > ++// Copyright (C) 2001 MandrakeSoft S.A. > ++// > ++// MandrakeSoft S.A. > ++// 43, rue d'Aboukir > ++// 75002 Paris - France > ++// http://www.linux-mandrake.com/ > ++// http://www.mandrakesoft.com/ > ++// > ++// This library is free software; you can redistribute it and/or > ++// modify it under the terms of the GNU Lesser General Public > ++// License as published by the Free Software Foundation; either > ++// version 2 of the License, or (at your option) any later version. > ++// > ++// This library is distributed in the hope that it will be useful, > ++// but WITHOUT ANY WARRANTY; without even the implied warranty of > ++// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU > ++// Lesser General Public License for more details. > ++// > ++// You should have received a copy of the GNU Lesser General Public > ++// License along with this library; if not, write to the Free Software > ++// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA > ++ > ++// Peter Grehan (gre...@iprg.nokia.com) coded all of this > ++// NE2000/ether stuff. > ++ > ++// > ++// An implementation of an ne2000 ISA ethernet adapter. This part uses > ++// a National Semiconductor DS-8390 ethernet MAC chip, with some h/w > ++// to provide a windowed memory region for the chip and a MAC address. > ++// > ++ > ++#include "dosbox.h" > ++ > ++#define bx_bool int > ++#define bx_param_c Bit8u > ++ > ++ > ++# define BX_NE2K_SMF > ++# define BX_NE2K_THIS_PTR > ++# define BX_NE2K_THIS > ++#define BX_INFO > ++//LOG_MSG > ++#define BX_DEBUG > ++//LOG_MSG > ++ > ++#define BX_NE2K_MEMSIZ (32*1024) > ++#define BX_NE2K_MEMSTART (16*1024) > ++#define BX_NE2K_MEMEND (BX_NE2K_MEMSTART + BX_NE2K_MEMSIZ) > ++ > ++typedef struct { > ++ // > ++ // ne2k register state > ++ > ++ // > ++ // Page 0 > ++ // > ++ // Command Register - 00h read/write > ++ struct CR_t { > ++ bx_bool stop; // STP - Software Reset command > ++ bx_bool start; // START - start the NIC > ++ bx_bool tx_packet; // TXP - initiate packet transmission > ++ Bit8u rdma_cmd; // RD0,RD1,RD2 - Remote DMA command > ++ Bit8u pgsel; // PS0,PS1 - Page select > ++ } CR; > ++ // Interrupt Status Register - 07h read/write > ++ struct ISR_t { > ++ bx_bool pkt_rx; // PRX - packet received with no errors > ++ bx_bool pkt_tx; // PTX - packet transmitted with no errors > ++ bx_bool rx_err; // RXE - packet received with 1 or more errors > ++ bx_bool tx_err; // TXE - packet tx'd " " " " " > ++ bx_bool overwrite; // OVW - rx buffer resources exhausted > ++ bx_bool cnt_oflow; // CNT - network tally counter MSB's set > ++ bx_bool rdma_done; // RDC - remote DMA complete > ++ bx_bool reset; // RST - reset status > ++ } ISR; > ++ // Interrupt Mask Register - 0fh write > ++ struct IMR_t { > ++ bx_bool rx_inte; // PRXE - packet rx interrupt enable > ++ bx_bool tx_inte; // PTXE - packet tx interrput enable > ++ bx_bool rxerr_inte; // RXEE - rx error interrupt enable > ++ bx_bool txerr_inte; // TXEE - tx error interrupt enable > ++ bx_bool overw_inte; // OVWE - overwrite warn int enable > ++ bx_bool cofl_inte; // CNTE - counter o'flow int enable > ++ bx_bool rdma_inte; // RDCE - remote DMA complete int enable > ++ bx_bool reserved; // D7 - reserved > ++ } IMR; > ++ // Data Configuration Register - 0eh write > ++ struct DCR_t { > ++ bx_bool wdsize; // WTS - 8/16-bit select > ++ bx_bool endian; // BOS - byte-order select > ++ bx_bool longaddr; // LAS - long-address select > ++ bx_bool loop; // LS - loopback select > ++ bx_bool auto_rx; // AR - auto-remove rx packets with remote DMA > ++ Bit8u fifo_size; // FT0,FT1 - fifo threshold > ++ } DCR; > ++ // Transmit Configuration Register - 0dh write > ++ struct TCR_t { > ++ bx_bool crc_disable; // CRC - inhibit tx CRC > ++ Bit8u loop_cntl; // LB0,LB1 - loopback control > ++ bx_bool ext_stoptx; // ATD - allow tx disable by external mcast > ++ bx_bool coll_prio; // OFST - backoff algorithm select > ++ Bit8u reserved; // D5,D6,D7 - reserved > ++ } TCR; > ++ // Transmit Status Register - 04h read > ++ struct TSR_t { > ++ bx_bool tx_ok; // PTX - tx complete without error > ++ bx_bool reserved; // D1 - reserved > ++ bx_bool collided; // COL - tx collided >= 1 times > ++ bx_bool aborted; // ABT - aborted due to excessive collisions > ++ bx_bool no_carrier; // CRS - carrier-sense lost > ++ bx_bool fifo_ur; // FU - FIFO underrun > ++ bx_bool cd_hbeat; // CDH - no tx cd-heartbeat from transceiver > ++ bx_bool ow_coll; // OWC - out-of-window collision > ++ } TSR; > ++ // Receive Configuration Register - 0ch write > ++ struct RCR_t { > ++ bx_bool errors_ok; // SEP - accept pkts with rx errors > ++ bx_bool runts_ok; // AR - accept < 64-byte runts > ++ bx_bool broadcast; // AB - accept eth broadcast address > ++ bx_bool multicast; // AM - check mcast hash array > ++ bx_bool promisc; // PRO - accept all packets > ++ bx_bool monitor; // MON - check pkts, but don't rx > ++ Bit8u reserved; // D6,D7 - reserved > ++ } RCR; > ++ // Receive Status Register - 0ch read > ++ struct RSR_t { > ++ bx_bool rx_ok; // PRX - rx complete without error > ++ bx_bool bad_crc; // CRC - Bad CRC detected > ++ bx_bool bad_falign; // FAE - frame alignment error > ++ bx_bool fifo_or; // FO - FIFO overrun > ++ bx_bool rx_missed; // MPA - missed packet error > ++ bx_bool rx_mbit; // PHY - unicast or mcast/bcast address match > ++ bx_bool rx_disabled; // DIS - set when in monitor mode > ++ bx_bool deferred; // DFR - collision active > ++ } RSR; > ++ > ++ Bit16u local_dma; // 01,02h read ; current local DMA addr > ++ Bit8u page_start; // 01h write ; page start register > ++ Bit8u page_stop; // 02h write ; page stop register > ++ Bit8u bound_ptr; // 03h read/write ; boundary pointer > ++ Bit8u tx_page_start; // 04h write ; transmit page start register > ++ Bit8u num_coll; // 05h read ; number-of-collisions register > ++ Bit16u tx_bytes; // 05,06h write ; transmit byte-count register > ++ Bit8u fifo; // 06h read ; FIFO > ++ Bit16u remote_dma; // 08,09h read ; current remote DMA addr > ++ Bit16u remote_start; // 08,09h write ; remote start address register > ++ Bit16u remote_bytes; // 0a,0bh write ; remote byte-count register > ++ Bit8u tallycnt_0; // 0dh read ; tally counter 0 (frame align errors) > ++ Bit8u tallycnt_1; // 0eh read ; tally counter 1 (CRC errors) > ++ Bit8u tallycnt_2; // 0fh read ; tally counter 2 (missed pkt errors) > ++ > ++ // > ++ // Page 1 > ++ // > ++ // Command Register 00h (repeated) > ++ // > ++ Bit8u physaddr[6]; // 01-06h read/write ; MAC address > ++ Bit8u curr_page; // 07h read/write ; current page register > ++ Bit8u mchash[8]; // 08-0fh read/write ; multicast hash array > ++ > ++ // > ++ // Page 2 - diagnostic use only > ++ // > ++ // Command Register 00h (repeated) > ++ // > ++ // Page Start Register 01h read (repeated) > ++ // Page Stop Register 02h read (repeated) > ++ // Current Local DMA Address 01,02h write (repeated) > ++ // Transmit Page start address 04h read (repeated) > ++ // Receive Configuration Register 0ch read (repeated) > ++ // Transmit Configuration Register 0dh read (repeated) > ++ // Data Configuration Register 0eh read (repeated) > ++ // Interrupt Mask Register 0fh read (repeated) > ++ // > ++ Bit8u rempkt_ptr; // 03h read/write ; remote next-packet pointer > ++ Bit8u localpkt_ptr; // 05h read/write ; local next-packet pointer > ++ Bit16u address_cnt; // 06,07h read/write ; address counter > ++ > ++ // > ++ // Page 3 - should never be modified. > ++ // > ++ > ++ // Novell ASIC state > ++ Bit8u macaddr[32]; // ASIC ROM'd MAC address, even bytes > ++ Bit8u mem[BX_NE2K_MEMSIZ]; // on-chip packet memory > ++ > ++ // ne2k internal state > ++ Bit32u base_address; > ++ int base_irq; > ++ int tx_timer_index; > ++ int tx_timer_active; > ++ > ++ void register_state(bx_param_c *list_p); > ++ > ++} bx_ne2k_t; > ++ > ++ > ++ > ++class bx_ne2k_c { > ++public: > ++ bx_ne2k_c(void); > ++ ~bx_ne2k_c(void); > ++ virtual void init(void); > ++ virtual void reset(unsigned type); > ++ > ++public: > ++ bx_ne2k_t s; > ++ > ++ /* TODO: Setup SDL */ > ++ //eth_pktmover_c *ethdev; > ++ > ++ BX_NE2K_SMF Bit32u read_cr(void); > ++ BX_NE2K_SMF void write_cr(Bit32u value); > ++ > ++ BX_NE2K_SMF Bit32u chipmem_read(Bit32u address, unsigned io_len); > ++ BX_NE2K_SMF Bit32u asic_read(Bit32u offset, unsigned io_len); > ++ BX_NE2K_SMF Bit32u page0_read(Bit32u offset, unsigned io_len); > ++ BX_NE2K_SMF Bit32u page1_read(Bit32u offset, unsigned io_len); > ++ BX_NE2K_SMF Bit32u page2_read(Bit32u offset, unsigned io_len); > ++ BX_NE2K_SMF Bit32u page3_read(Bit32u offset, unsigned io_len); > ++ > ++ BX_NE2K_SMF void chipmem_write(Bit32u address, Bit32u value, unsigned > io_len); > ++ BX_NE2K_SMF void asic_write(Bit32u address, Bit32u value, unsigned > io_len); > ++ BX_NE2K_SMF void page0_write(Bit32u address, Bit32u value, unsigned > io_len); > ++ BX_NE2K_SMF void page1_write(Bit32u address, Bit32u value, unsigned > io_len); > ++ BX_NE2K_SMF void page2_write(Bit32u address, Bit32u value, unsigned > io_len); > ++ BX_NE2K_SMF void page3_write(Bit32u address, Bit32u value, unsigned > io_len); > ++ > ++public: > ++ static void tx_timer_handler(void *); > ++ BX_NE2K_SMF void tx_timer(void); > ++ > ++ static void rx_handler(void *arg, const void *buf, unsigned len); > ++ BX_NE2K_SMF unsigned mcast_index(const void *dst); > ++ BX_NE2K_SMF void rx_frame(const void *buf, unsigned io_len); > ++ > ++ > ++ static Bit32u read_handler(void *this_ptr, Bit32u address, unsigned > io_len); > ++ static void write_handler(void *this_ptr, Bit32u address, Bit32u value, > unsigned io_len); > ++#if !BX_USE_NE2K_SMF > ++ Bit32u read(Bit32u address, unsigned io_len); > ++ void write(Bit32u address, Bit32u value, unsigned io_len); > ++#endif > ++ > ++ > ++}; > ++ > + > +--- configure.ac.orig Fri May 31 18:19:20 2019 > ++++ configure.ac Fri May 31 18:19:22 2019 > +@@ -413,6 +413,16 @@ > + AC_MSG_WARN([Can't find libpng, screenshot support disabled]) > + fi > + > ++AH_TEMPLATE(C_NE2000,[Define to 1 to enable NE2000 ethernet passthrough, > requires libpcap]) > ++AC_CHECK_HEADER(pcap.h,have_pcap_h=yes,) > ++AC_CHECK_LIB(pcap, pcap_open_live, have_pcap_lib=yes, ,-lz) > ++if test x$have_pcap_lib = xyes -a x$have_pcap_h = xyes ; then > ++ LIBS="$LIBS -lpcap"; > ++ AC_DEFINE(C_NE2000,1) > ++else > ++ AC_MSG_WARN([Can't find libpcap, NE2000 ethernet passthrough disabled]) > ++fi > ++ > + AH_TEMPLATE(C_MODEM,[Define to 1 to enable internal modem support, requires > SDL_net]) > + AH_TEMPLATE(C_IPX,[Define to 1 to enable IPX over Internet networking, > requires SDL_net]) > + AC_CHECK_HEADER(SDL_net.h,have_sdl_net_h=yes,) > > --- /dev/null Fri May 31 19:56:41 2019 > +++ ports/emulators/dosbox/patches/nosplash Fri May 31 19:33:47 2019 > @@ -0,0 +1,44 @@ > +--- src/gui/..ar/0/sdlmain.cpp Thu Aug 30 10:52:30 2018 > ++++ src/gui/sdlmain.cpp Fri May 31 19:33:29 2019 > +@@ -1077,7 +1077,9 @@ > + } > + } > + > ++#ifdef TOTAL_WANKER > + #include "dosbox_splash.h" > ++#endif > + > + //extern void UI_Run(bool); > + static void GUI_StartUp(Section * sec) { > +@@ -1279,6 +1281,7 @@ > + Bit32u bmask = 0x00ff0000; > + //#endif > + > ++#ifdef TOTAL_WANKER > + /* Please leave the Splash screen stuff in working order in DOSBox. We > spend a lot of time making DOSBox. */ > + SDL_Surface* splash_surf = SDL_CreateRGBSurface(SDL_SWSURFACE, 640, > 400, 32, rmask, gmask, bmask, 0); > + if (splash_surf) { > +@@ -1339,6 +1342,7 @@ > + delete [] tmpbufp; > + > + } > ++#endif > + > + /* Get some Event handlers */ > + MAPPER_AddHandler(KillSwitch,MK_f9,MMOD1,"shutdown","ShutDown"); > +@@ -1687,6 +1691,7 @@ > + Bit32u gmask = 0x0000ff00; > + Bit32u bmask = 0x00ff0000; > + #endif > ++#ifdef TOTAL_WANKER > + SDL_Surface* splash_surf = SDL_CreateRGBSurface(SDL_SWSURFACE, 640, > 400, 32, rmask, gmask, bmask, 0); > + if (!splash_surf) return; > + > +@@ -1707,6 +1712,7 @@ > + SDL_BlitSurface(splash_surf, NULL, sdl.surface, NULL); > + SDL_Flip(sdl.surface); > + SDL_Delay(12000); > ++#endif > + } > + > + static void launcheditor() { > > --- /dev/null Fri May 31 19:56:41 2019 > +++ ports/emulators/dosbox/patches/wxneeded Fri May 31 19:13:07 2019 > @@ -0,0 +1,10 @@ > +--- src/..ar/0/Makefile.am Fri May 31 19:12:02 2019 > ++++ src/Makefile.am Fri May 31 19:12:31 2019 > +@@ -15,6 +15,7 @@ > + dosbox_LDADD = cpu/libcpu.a debug/libdebug.a dos/libdos.a fpu/libfpu.a > hardware/libhardware.a gui/libgui.a \ > + ints/libints.a misc/libmisc.a shell/libshell.a > hardware/mame/libmame.a \ > + hardware/serialport/libserial.a libs/gui_tk/libgui_tk.a > ++dosbox_LDFLAGS = -z notext -z wxneeded > + > + EXTRA_DIST = winres.rc dosbox.ico > + <#secure method=pgpmime mode=sign> -- jca | PGP : 0x1524E7EE / 5135 92C1 AD36 5293 2BDF DDCC 0DFA 74AE 1524 E7EE
