Unix/Linux/ether_linux.cpp

/*
 *  ether_unix.cpp - Ethernet device driver, Unix specific stuff
 *
 *  Basilisk II (C) 1997-1999 Christian Bauer
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program 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 General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "sysdeps.h"

#include <sys/ioctl.h>
#include <sys/poll.h>
#include <semaphore.h>
#include <errno.h>
#include <stdio.h>

#include "cpu_emulation.h"
#include "main.h"
#include "macos_util.h"
#include "prefs.h"
#include "user_strings.h"
#include "ether.h"
#include "ether_defs.h"

#define DEBUG 0
#include "debug.h"

#define MONITOR 0


// List of attached protocols
struct NetProtocol {
        NetProtocol *next;
        uint16 type;
        uint32 handler;
};

static NetProtocol *prot_list = NULL;


// Global variables
static int fd = -1;                                                     // fd of sheep_net device
static pthread_t ether_thread;                          // Packet reception thread
static pthread_attr_t ether_thread_attr;        // Packet reception thread attributes
static bool thread_active = false;                      // Flag: Packet reception thread installed
static sem_t int_ack;                                           // Interrupt acknowledge semaphore
static bool is_ethertap;                                        // Flag: Ethernet device is ethertap

// Prototypes
static void *receive_func(void *arg);


/*
 *  Find protocol in list
 */

static NetProtocol *find_protocol(uint16 type)
{
        // All 802.2 types are the same
        if (type <= 1500)
                type = 0;

        // Search list (we could use hashing here but there are usually only three
        // handlers installed: 0x0000 for AppleTalk and 0x0800/0x0806 for TCP/IP)
        NetProtocol *p = prot_list;
        while (p) {
                if (p->type == type)
                        return p;
                p = p->next;
        }
        return NULL;
}


/*
 *  Initialization
 */

void EtherInit(void)
{
        int nonblock = 1;
        char str[256];

        // Do nothing if no Ethernet device specified
        const char *name = PrefsFindString("ether");
        if (name == NULL)
                return;

        // Is it Ethertap?
        is_ethertap = (strncmp(name, "tap", 3) == 0);

        // Open sheep_net or ethertap device
        char dev_name[16];
        if (is_ethertap)
                sprintf(dev_name, "/dev/%s", name);
        else
                strcpy(dev_name, "/dev/sheep_net");
        fd = open(dev_name, O_RDWR);
        if (fd < 0) {
                sprintf(str, GetString(STR_NO_SHEEP_NET_DRIVER_WARN), dev_name, strerror(errno));
                WarningAlert(str);
                goto open_error;
        }

        // Attach sheep_net to selected Ethernet card
        if (!is_ethertap && ioctl(fd, SIOCSIFLINK, name) < 0) {
                sprintf(str, GetString(STR_SHEEP_NET_ATTACH_WARN), strerror(errno));
                WarningAlert(str);
                goto open_error;
        }

        // Set nonblocking I/O
        ioctl(fd, FIONBIO, &nonblock);

        // Get Ethernet address
        if (is_ethertap) {
                pid_t p = getpid();     // If configured for multicast, ethertap requires that the lower 32 bit of the Ethernet address are our PID
                ether_addr[0] = 0xfe;
                ether_addr[1] = 0xfd;
                ether_addr[2] = p >> 24;
                ether_addr[3] = p >> 16;
                ether_addr[4] = p >> 8;
                ether_addr[5] = p;
        } else
                ioctl(fd, SIOCGIFADDR, ether_addr);
        D(bug("Ethernet address %02x %02x %02x %02x %02x %02x\n", ether_addr[0], ether_addr[1], ether_addr[2], ether_addr[3], ether_addr[4], ether_addr[5]));

        // Start packet reception thread
        if (sem_init(&int_ack, 0, 0) < 0) {
                printf("WARNING: Cannot init semaphore");
                goto open_error;
        }
        pthread_attr_init(&ether_thread_attr);
#if defined(_POSIX_THREAD_PRIORITY_SCHEDULING)
        if (geteuid() == 0) {
                pthread_attr_setinheritsched(&ether_thread_attr, PTHREAD_EXPLICIT_SCHED);
                pthread_attr_setschedpolicy(&ether_thread_attr, SCHED_FIFO);
                struct sched_param fifo_param;
                fifo_param.sched_priority = (sched_get_priority_min(SCHED_FIFO) + sched_get_priority_max(SCHED_FIFO)) / 2 + 1;
                pthread_attr_setschedparam(&ether_thread_attr, &fifo_param);
        }
#endif
        thread_active = (pthread_create(&ether_thread, &ether_thread_attr, receive_func, NULL) == 0);
        if (!thread_active) {
                printf("WARNING: Cannot start Ethernet thread");
                goto open_error;
        }

        // Everything OK
        net_open = true;
        return;

open_error:
        if (thread_active) {
                pthread_cancel(ether_thread);
                pthread_join(ether_thread, NULL);
                sem_destroy(&int_ack);
                thread_active = false;
        }
        if (fd > 0) {
                close(fd);
                fd = -1;
        }
}


/*
 *  Deinitialization
 */

void EtherExit(void)
{
        // Stop reception thread
        if (thread_active) {
                pthread_cancel(ether_thread);
                pthread_join(ether_thread, NULL);
                sem_destroy(&int_ack);
                thread_active = false;
        }

        // Close sheep_net device
        if (fd > 0)
                close(fd);

        // Remove all protocols
        NetProtocol *p = prot_list;
        while (p) {
                NetProtocol *next = p->next;
                delete p;
                p = next;
        }
}


/*
 *  Reset
 */

void EtherReset(void)
{
        // Remove all protocols
        NetProtocol *p = prot_list;
        while (p) {
                NetProtocol *next = p->next;
                delete p;
                p = next;
        }
}


/*
 *  Add multicast address
 */

int16 ether_add_multicast(uint32 pb)
{
        if (ioctl(fd, SIOCADDMULTI, Mac2HostAddr(pb + eMultiAddr)) < 0) {
                D(bug("WARNING: Couldn't enable multicast address\n"));
                if (is_ethertap)
                        return noErr;
                else
                        return eMultiErr;
        } else
                return noErr;
}


/*
 *  Delete multicast address
 */

int16 ether_del_multicast(uint32 pb)
{
        if (ioctl(fd, SIOCDELMULTI, Mac2HostAddr(pb + eMultiAddr)) < 0) {
                D(bug("WARNING: Couldn't disable multicast address\n"));
                return eMultiErr;
        } else
                return noErr;
}


/*
 *  Attach protocol handler
 */

int16 ether_attach_ph(uint16 type, uint32 handler)
{
        // Already attached?
        NetProtocol *p = find_protocol(type);
        if (p != NULL)
                return lapProtErr;
        else {
                // No, create and attach
                p = new NetProtocol;
                p->next = prot_list;
                p->type = type;
                p->handler = handler;
                prot_list = p;
                return noErr;
        }
}


/*
 *  Detach protocol handler
 */

int16 ether_detach_ph(uint16 type)
{
        NetProtocol *p = find_protocol(type);
        if (p != NULL) {
                NetProtocol *q = prot_list;
                if (p == q) {
                        prot_list = NULL;
                        delete p;
                        return noErr;
                }
                while (q) {
                        if (q->next == p) {
                                q->next = p->next;
                                delete p;
                                return noErr;
                        }
                        q = q->next;
                }
                return lapProtErr;
        } else
                return lapProtErr;
}


/*
 *  Transmit raw ethernet packet
 */

int16 ether_write(uint32 wds)
{
        // Set source address
        uint32 hdr = ReadMacInt32(wds + 2);
        memcpy(Mac2HostAddr(hdr + 6), ether_addr, 6);

        // Copy packet to buffer
        uint8 packet[1516], *p = packet;
        int len = 0;
        if (is_ethertap) {
                *p++ = 0;       // Ethertap discards the first 2 bytes
                *p++ = 0;
                len += 2;
        }
        for (;;) {
                int w = ReadMacInt16(wds);
                if (w == 0)
                        break;
                memcpy(p, Mac2HostAddr(ReadMacInt32(wds + 2)), w);
                len += w;
                p += w;
                wds += 6;
        }

#if MONITOR
        bug("Sending Ethernet packet:\n");
        for (int i=0; i<len; i++) {
                bug("%02x ", packet[i]);
        }
        bug("\n");
#endif

        // Transmit packet
        if (write(fd, packet, len) < 0) {
                D(bug("WARNING: Couldn't transmit packet\n"));
                return excessCollsns;
        } else
                return noErr;
}


/*
 *  Packet reception thread
 */

static void *receive_func(void *arg)
{
        for (;;) {

                // Wait for packets to arrive
                struct pollfd pf = {fd, POLLIN, 0};
                int res = poll(&pf, 1, -1);
                if (res <= 0)
                        break;

                // Trigger Ethernet interrupt
                D(bug(" packet received, triggering Ethernet interrupt\n"));
                SetInterruptFlag(INTFLAG_ETHER);
                TriggerInterrupt();

                // Wait for interrupt acknowledge by EtherInterrupt()
                sem_wait(&int_ack);
        }
        return NULL;
}


/*
 *  Ethernet interrupt - activate deferred tasks to call IODone or protocol handlers
 */

void EtherInterrupt(void)
{
        D(bug("EtherIRQ\n"));

        // Call protocol handler for received packets
        uint8 packet[1516];
        for (;;) {

                // Read packet from sheep_net device
                ssize_t length = read(fd, packet, is_ethertap ? 1516 : 1514);
                if (length < 14)
                        break;

#if MONITOR
                bug("Receiving Ethernet packet:\n");
                for (int i=0; i<length; i++) {
                        bug("%02x ", packet[i]);
                }
                bug("\n");
#endif

                // Pointer to packet data (Ethernet header)
                uint8 *p = packet;
                if (is_ethertap) {
                        p += 2;                 // Ethertap has two random bytes before the packet
                        length -= 2;
                }

                // Get packet type
                uint16 type = ntohs(*(uint16 *)(p + 12));

                // Look for protocol
                NetProtocol *prot = find_protocol(type);
                if (prot == NULL)
                        continue;

                // No default handler
                if (prot->handler == 0)
                        continue;

                // Copy header to RHA
                memcpy(Mac2HostAddr(ether_data + ed_RHA), p, 14);
                D(bug(" header %08lx%04lx %08lx%04lx %04lx\n", ReadMacInt32(ether_data + ed_RHA), ReadMacInt16(ether_data + ed_RHA + 4), ReadMacInt32(ether_data + ed_RHA + 6), ReadMacInt16(ether_data + ed_RHA + 10), ReadMacInt16(ether_data + ed_RHA + 12)));

                // Call protocol handler
                M68kRegisters r;
                r.d[0] = type;                                                                  // Packet type
                r.d[1] = length - 14;                                                   // Remaining packet length (without header, for ReadPacket)
                r.a[0] = (uint32)p + 14;                                                // Pointer to packet (host address, for ReadPacket)
                r.a[3] = ether_data + ed_RHA + 14;                              // Pointer behind header in RHA
                r.a[4] = ether_data + ed_ReadPacket;                    // Pointer to ReadPacket/ReadRest routines
                D(bug(" calling protocol handler %08lx, type %08lx, length %08lx, data %08lx, rha %08lx, read_packet %08lx\n", prot->handler, r.d[0], r.d[1], r.a[0], r.a[3], r.a[4]));
                Execute68k(prot->handler, &r);
        }

        // Acknowledge interrupt to reception thread
        D(bug(" EtherIRQ done\n"));
        sem_post(&int_ack);
}
Revision:	1.1.1.1 (vendor branch)
Committed:	1999-10-03T14:16:25Z (25 years, 1 month ago) by cebix
Branch:	cebix
CVS Tags:	start
Changes since 1.1:	+0 -0 lines
Log Message:	Imported sources
#	Content
1	/*
2	* ether_unix.cpp - Ethernet device driver, Unix specific stuff
3	*
4	* Basilisk II (C) 1997-1999 Christian Bauer
5	*
6	* This program is free software; you can redistribute it and/or modify
7	* it under the terms of the GNU General Public License as published by
8	* the Free Software Foundation; either version 2 of the License, or
9	* (at your option) any later version.
10	*
11	* This program is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	* GNU General Public License for more details.
15	*
16	* You should have received a copy of the GNU General Public License
17	* along with this program; if not, write to the Free Software
18	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19	*/
20
21	#include "sysdeps.h"
22
23	#include <sys/ioctl.h>
24	#include <sys/poll.h>
25	#include <semaphore.h>
26	#include <errno.h>
27	#include <stdio.h>
28
29	#include "cpu_emulation.h"
30	#include "main.h"
31	#include "macos_util.h"
32	#include "prefs.h"
33	#include "user_strings.h"
34	#include "ether.h"
35	#include "ether_defs.h"
36
37	#define DEBUG 0
38	#include "debug.h"
39
40	#define MONITOR 0
41
42
43	// List of attached protocols
44	struct NetProtocol {
45	NetProtocol *next;
46	uint16 type;
47	uint32 handler;
48	};
49
50	static NetProtocol *prot_list = NULL;
51
52
53	// Global variables
54	static int fd = -1; // fd of sheep_net device
55	static pthread_t ether_thread; // Packet reception thread
56	static pthread_attr_t ether_thread_attr; // Packet reception thread attributes
57	static bool thread_active = false; // Flag: Packet reception thread installed
58	static sem_t int_ack; // Interrupt acknowledge semaphore
59	static bool is_ethertap; // Flag: Ethernet device is ethertap
60
61	// Prototypes
62	static void receive_func(void arg);
63
64
65	/*
66	* Find protocol in list
67	*/
68
69	static NetProtocol *find_protocol(uint16 type)
70	{
71	// All 802.2 types are the same
72	if (type <= 1500)
73	type = 0;
74
75	// Search list (we could use hashing here but there are usually only three
76	// handlers installed: 0x0000 for AppleTalk and 0x0800/0x0806 for TCP/IP)
77	NetProtocol *p = prot_list;
78	while (p) {
79	if (p->type == type)
80	return p;
81	p = p->next;
82	}
83	return NULL;
84	}
85
86
87	/*
88	* Initialization
89	*/
90
91	void EtherInit(void)
92	{
93	int nonblock = 1;
94	char str[256];
95
96	// Do nothing if no Ethernet device specified
97	const char *name = PrefsFindString("ether");
98	if (name == NULL)
99	return;
100
101	// Is it Ethertap?
102	is_ethertap = (strncmp(name, "tap", 3) == 0);
103
104	// Open sheep_net or ethertap device
105	char dev_name[16];
106	if (is_ethertap)
107	sprintf(dev_name, "/dev/%s", name);
108	else
109	strcpy(dev_name, "/dev/sheep_net");
110	fd = open(dev_name, O_RDWR);
111	if (fd < 0) {
112	sprintf(str, GetString(STR_NO_SHEEP_NET_DRIVER_WARN), dev_name, strerror(errno));
113	WarningAlert(str);
114	goto open_error;
115	}
116
117	// Attach sheep_net to selected Ethernet card
118	if (!is_ethertap && ioctl(fd, SIOCSIFLINK, name) < 0) {
119	sprintf(str, GetString(STR_SHEEP_NET_ATTACH_WARN), strerror(errno));
120	WarningAlert(str);
121	goto open_error;
122	}
123
124	// Set nonblocking I/O
125	ioctl(fd, FIONBIO, &nonblock);
126
127	// Get Ethernet address
128	if (is_ethertap) {
129	pid_t p = getpid(); // If configured for multicast, ethertap requires that the lower 32 bit of the Ethernet address are our PID
130	ether_addr[0] = 0xfe;
131	ether_addr[1] = 0xfd;
132	ether_addr[2] = p >> 24;
133	ether_addr[3] = p >> 16;
134	ether_addr[4] = p >> 8;
135	ether_addr[5] = p;
136	} else
137	ioctl(fd, SIOCGIFADDR, ether_addr);
138	D(bug("Ethernet address %02x %02x %02x %02x %02x %02x\n", ether_addr[0], ether_addr[1], ether_addr[2], ether_addr[3], ether_addr[4], ether_addr[5]));
139
140	// Start packet reception thread
141	if (sem_init(&int_ack, 0, 0) < 0) {
142	printf("WARNING: Cannot init semaphore");
143	goto open_error;
144	}
145	pthread_attr_init(&ether_thread_attr);
146	#if defined(_POSIX_THREAD_PRIORITY_SCHEDULING)
147	if (geteuid() == 0) {
148	pthread_attr_setinheritsched(&ether_thread_attr, PTHREAD_EXPLICIT_SCHED);
149	pthread_attr_setschedpolicy(&ether_thread_attr, SCHED_FIFO);
150	struct sched_param fifo_param;
151	fifo_param.sched_priority = (sched_get_priority_min(SCHED_FIFO) + sched_get_priority_max(SCHED_FIFO)) / 2 + 1;
152	pthread_attr_setschedparam(&ether_thread_attr, &fifo_param);
153	}
154	#endif
155	thread_active = (pthread_create(&ether_thread, &ether_thread_attr, receive_func, NULL) == 0);
156	if (!thread_active) {
157	printf("WARNING: Cannot start Ethernet thread");
158	goto open_error;
159	}
160
161	// Everything OK
162	net_open = true;
163	return;
164
165	open_error:
166	if (thread_active) {
167	pthread_cancel(ether_thread);
168	pthread_join(ether_thread, NULL);
169	sem_destroy(&int_ack);
170	thread_active = false;
171	}
172	if (fd > 0) {
173	close(fd);
174	fd = -1;
175	}
176	}
177
178
179	/*
180	* Deinitialization
181	*/
182
183	void EtherExit(void)
184	{
185	// Stop reception thread
186	if (thread_active) {
187	pthread_cancel(ether_thread);
188	pthread_join(ether_thread, NULL);
189	sem_destroy(&int_ack);
190	thread_active = false;
191	}
192
193	// Close sheep_net device
194	if (fd > 0)
195	close(fd);
196
197	// Remove all protocols
198	NetProtocol *p = prot_list;
199	while (p) {
200	NetProtocol *next = p->next;
201	delete p;
202	p = next;
203	}
204	}
205
206
207	/*
208	* Reset
209	*/
210
211	void EtherReset(void)
212	{
213	// Remove all protocols
214	NetProtocol *p = prot_list;
215	while (p) {
216	NetProtocol *next = p->next;
217	delete p;
218	p = next;
219	}
220	}
221
222
223	/*
224	* Add multicast address
225	*/
226
227	int16 ether_add_multicast(uint32 pb)
228	{
229	if (ioctl(fd, SIOCADDMULTI, Mac2HostAddr(pb + eMultiAddr)) < 0) {
230	D(bug("WARNING: Couldn't enable multicast address\n"));
231	if (is_ethertap)
232	return noErr;
233	else
234	return eMultiErr;
235	} else
236	return noErr;
237	}
238
239
240	/*
241	* Delete multicast address
242	*/
243
244	int16 ether_del_multicast(uint32 pb)
245	{
246	if (ioctl(fd, SIOCDELMULTI, Mac2HostAddr(pb + eMultiAddr)) < 0) {
247	D(bug("WARNING: Couldn't disable multicast address\n"));
248	return eMultiErr;
249	} else
250	return noErr;
251	}
252
253
254	/*
255	* Attach protocol handler
256	*/
257
258	int16 ether_attach_ph(uint16 type, uint32 handler)
259	{
260	// Already attached?
261	NetProtocol *p = find_protocol(type);
262	if (p != NULL)
263	return lapProtErr;
264	else {
265	// No, create and attach
266	p = new NetProtocol;
267	p->next = prot_list;
268	p->type = type;
269	p->handler = handler;
270	prot_list = p;
271	return noErr;
272	}
273	}
274
275
276	/*
277	* Detach protocol handler
278	*/
279
280	int16 ether_detach_ph(uint16 type)
281	{
282	NetProtocol *p = find_protocol(type);
283	if (p != NULL) {
284	NetProtocol *q = prot_list;
285	if (p == q) {
286	prot_list = NULL;
287	delete p;
288	return noErr;
289	}
290	while (q) {
291	if (q->next == p) {
292	q->next = p->next;
293	delete p;
294	return noErr;
295	}
296	q = q->next;
297	}
298	return lapProtErr;
299	} else
300	return lapProtErr;
301	}
302
303
304	/*
305	* Transmit raw ethernet packet
306	*/
307
308	int16 ether_write(uint32 wds)
309	{
310	// Set source address
311	uint32 hdr = ReadMacInt32(wds + 2);
312	memcpy(Mac2HostAddr(hdr + 6), ether_addr, 6);
313
314	// Copy packet to buffer
315	uint8 packet[1516], *p = packet;
316	int len = 0;
317	if (is_ethertap) {
318	*p++ = 0; // Ethertap discards the first 2 bytes
319	*p++ = 0;
320	len += 2;
321	}
322	for (;;) {
323	int w = ReadMacInt16(wds);
324	if (w == 0)
325	break;
326	memcpy(p, Mac2HostAddr(ReadMacInt32(wds + 2)), w);
327	len += w;
328	p += w;
329	wds += 6;
330	}
331
332	#if MONITOR
333	bug("Sending Ethernet packet:\n");
334	for (int i=0; i<len; i++) {
335	bug("%02x ", packet[i]);
336	}
337	bug("\n");
338	#endif
339
340	// Transmit packet
341	if (write(fd, packet, len) < 0) {
342	D(bug("WARNING: Couldn't transmit packet\n"));
343	return excessCollsns;
344	} else
345	return noErr;
346	}
347
348
349	/*
350	* Packet reception thread
351	*/
352
353	static void receive_func(void arg)
354	{
355	for (;;) {
356
357	// Wait for packets to arrive
358	struct pollfd pf = {fd, POLLIN, 0};
359	int res = poll(&pf, 1, -1);
360	if (res <= 0)
361	break;
362
363	// Trigger Ethernet interrupt
364	D(bug(" packet received, triggering Ethernet interrupt\n"));
365	SetInterruptFlag(INTFLAG_ETHER);
366	TriggerInterrupt();
367
368	// Wait for interrupt acknowledge by EtherInterrupt()
369	sem_wait(&int_ack);
370	}
371	return NULL;
372	}
373
374
375	/*
376	* Ethernet interrupt - activate deferred tasks to call IODone or protocol handlers
377	*/
378
379	void EtherInterrupt(void)
380	{
381	D(bug("EtherIRQ\n"));
382
383	// Call protocol handler for received packets
384	uint8 packet[1516];
385	for (;;) {
386
387	// Read packet from sheep_net device
388	ssize_t length = read(fd, packet, is_ethertap ? 1516 : 1514);
389	if (length < 14)
390	break;
391
392	#if MONITOR
393	bug("Receiving Ethernet packet:\n");
394	for (int i=0; i<length; i++) {
395	bug("%02x ", packet[i]);
396	}
397	bug("\n");
398	#endif
399
400	// Pointer to packet data (Ethernet header)
401	uint8 *p = packet;
402	if (is_ethertap) {
403	p += 2; // Ethertap has two random bytes before the packet
404	length -= 2;
405	}
406
407	// Get packet type
408	uint16 type = ntohs((uint16 )(p + 12));
409
410	// Look for protocol
411	NetProtocol *prot = find_protocol(type);
412	if (prot == NULL)
413	continue;
414
415	// No default handler
416	if (prot->handler == 0)
417	continue;
418
419	// Copy header to RHA
420	memcpy(Mac2HostAddr(ether_data + ed_RHA), p, 14);
421	D(bug(" header %08lx%04lx %08lx%04lx %04lx\n", ReadMacInt32(ether_data + ed_RHA), ReadMacInt16(ether_data + ed_RHA + 4), ReadMacInt32(ether_data + ed_RHA + 6), ReadMacInt16(ether_data + ed_RHA + 10), ReadMacInt16(ether_data + ed_RHA + 12)));
422
423	// Call protocol handler
424	M68kRegisters r;
425	r.d[0] = type; // Packet type
426	r.d[1] = length - 14; // Remaining packet length (without header, for ReadPacket)
427	r.a[0] = (uint32)p + 14; // Pointer to packet (host address, for ReadPacket)
428	r.a[3] = ether_data + ed_RHA + 14; // Pointer behind header in RHA
429	r.a[4] = ether_data + ed_ReadPacket; // Pointer to ReadPacket/ReadRest routines
430	D(bug(" calling protocol handler %08lx, type %08lx, length %08lx, data %08lx, rha %08lx, read_packet %08lx\n", prot->handler, r.d[0], r.d[1], r.a[0], r.a[3], r.a[4]));
431	Execute68k(prot->handler, &r);
432	}
433
434	// Acknowledge interrupt to reception thread
435	D(bug(" EtherIRQ done\n"));
436	sem_post(&int_ack);
437	}