ViewVC Help

View File | Revision Log | Show Annotations | Revision Graph | Root Listing

root/cebix/SheepShaver/src/ether.cpp

Comparing SheepShaver/src/ether.cpp (file contents):
Revision 1.1.1.1 by cebix, 2002-02-04T16:58:13Z vs.
Revision 1.10 by gbeauche, 2008-01-01T09:47:38Z

#	Line 1 | Line 1
1		/*
2		*  ether.cpp - SheepShaver Ethernet Device Driver (DLPI)
3		*
4	<	*  SheepShaver (C) 1997-2002 Marc Hellwig and Christian Bauer
4	>	*  SheepShaver (C) 1997-2008 Marc Hellwig and 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
#	Line 27 | Line 27
27		#include <string.h>
28
29		#include "sysdeps.h"
30	+	#include "cpu_emulation.h"
31		#include "ether.h"
32		#include "ether_defs.h"
33		#include "macos_util.h"
33	–	#include "cpu_emulation.h"
34	–	#include "emul_op.h"
35	–	#include "main.h"
34
35		#define DEBUG 0
36		#include "debug.h"
37
40	–
38		// Packet types
39		enum {
40		kPktDIX                         = 0,
#	Line 58 | Line 55 | static const int kGSshift = 6;
55		static const int kGSmask = 0x1F;
56
57		struct multicast_node {
58	<	multicast_node *next;
58	>	nw_multicast_node_p next;
59		uint8 addr[kEnetPhysicalAddressLength];
60		};
61
#	Line 86 | Line 83 | struct DLPIStream {
83
84		void AddMulticast(uint8 *addr)
85		{
86	<	multicast_node *n = new multicast_node;
86	>	multicast_node *n = (multicast_node *)Mac2HostAddr(Mac_sysalloc(sizeof(multicast_node)));
87		memcpy(n->addr, addr, kEnetPhysicalAddressLength);
88		n->next = multicast_list;
89		multicast_list = n;
#	Line 106 | Line 103 | struct DLPIStream {
103		while (q) {
104		if (q->next == p) {
105		q->next = p->next;
106	<	delete p;
106	>	Mac_sysfree(Host2MacAddr((uint8 *)p));
107		return;
108		}
109		q = q->next;
#	Line 124 | Line 121 | struct DLPIStream {
121		return NULL;
122		}
123
124	<	uint32 minor_num;                                       // Minor device number of this stream
125	<	uint32 dlpi_state;                                      // DLPI state of this stream
126	<	uint32 flags;                                           // Flags
127	<	uint16 dlsap;                                           // SAP bound to this stream
128	<	bool framing_8022;                                      // Using 802.2 framing? This is only used to report the MAC type for DL_INFO_ACK and can be set with an ioctl() call
129	<	queue_t *rdq;                                           // Read queue for this stream
130	<	uint32 group_sap[kGroupSAPMapSize];     // Map of bound group SAPs
131	<	uint8 snap[k8022SNAPLength];            // SNAP bound to this stream
132	<	multicast_node *multicast_list;         // List of enabled multicast addresses
124	>	nw_uint32 minor_num;                                    // Minor device number of this stream
125	>	nw_uint32 dlpi_state;                                   // DLPI state of this stream
126	>	nw_uint32 flags;                                                // Flags
127	>	nw_uint16 dlsap;                                                // SAP bound to this stream
128	>	nw_bool framing_8022;                                   // Using 802.2 framing? This is only used to report the MAC type for DL_INFO_ACK and can be set with an ioctl() call
129	>	nw_queue_p rdq;                                                 // Read queue for this stream
130	>	nw_uint32 group_sap[kGroupSAPMapSize];  // Map of bound group SAPs
131	>	uint8 snap[k8022SNAPLength];                    // SNAP bound to this stream
132	>	nw_multicast_node_p multicast_list;             // List of enabled multicast addresses
133	>	};
134	>
135	>	// Hack to make DLPIStream list initialization early to NULL (do we really need this?)
136	>	struct DLPIStreamInit {
137	>	DLPIStreamInit(nw_DLPIStream_p *dlpi_stream_p) { *dlpi_stream_p = NULL; }
138		};
139
140		// Stream flags
#	Line 144 | Line 146 | enum {
146		};
147
148		// List of opened streams (used internally by OpenTransport)
149	<	static DLPIStream *dlpi_stream_list = NULL;
149	>	static nw_DLPIStream_p dlpi_stream_list;
150	>	static DLPIStreamInit dlpi_stream_init(&dlpi_stream_list);
151
152		// Are we open?
153		bool ether_driver_opened = false;
#	Line 174 | Line 177 | typedef mblk_t *(*allocb_ptr)(size_t siz
177		static uint32 allocb_tvect = 0;
178		mblk_t *allocb(size_t arg1, int arg2)
179		{
180	<	return (mblk_t *)CallMacOS2(allocb_ptr, allocb_tvect, arg1, arg2);
180	>	return (mblk_t *)Mac2HostAddr((uint32)CallMacOS2(allocb_ptr, allocb_tvect, arg1, arg2));
181		}
182		typedef void (*freeb_ptr)(mblk_t *);
183		static uint32 freeb_tvect = 0;
#	Line 192 | Line 195 | typedef mblk_t *(*copyb_ptr)(mblk_t *);
195		static uint32 copyb_tvect = 0;
196		static inline mblk_t *copyb(mblk_t *arg1)
197		{
198	<	return (mblk_t *)CallMacOS1(copyb_ptr, copyb_tvect, arg1);
198	>	return (mblk_t *)Mac2HostAddr((uint32)CallMacOS1(copyb_ptr, copyb_tvect, arg1));
199		}
200		typedef mblk_t *(*dupmsg_ptr)(mblk_t *);
201		static uint32 dupmsg_tvect = 0;
202		static inline mblk_t *dupmsg(mblk_t *arg1)
203		{
204	<	return (mblk_t *)CallMacOS1(dupmsg_ptr, dupmsg_tvect, arg1);
204	>	return (mblk_t *)Mac2HostAddr((uint32)CallMacOS1(dupmsg_ptr, dupmsg_tvect, arg1));
205		}
206		typedef mblk_t *(*getq_ptr)(queue_t *);
207		static uint32 getq_tvect = 0;
208		static inline mblk_t *getq(queue_t *arg1)
209		{
210	<	return (mblk_t *)CallMacOS1(getq_ptr, getq_tvect, arg1);
210	>	return (mblk_t *)Mac2HostAddr((uint32)CallMacOS1(getq_ptr, getq_tvect, arg1));
211		}
212		typedef int (*putq_ptr)(queue_t *, mblk_t *);
213		static uint32 putq_tvect = 0;
#	Line 276 | Line 279 | typedef DLPIStream *(*mi_next_ptr_ptr)(D
279		static uint32 mi_next_ptr_tvect = 0;
280		static inline DLPIStream *mi_next_ptr(DLPIStream *arg1)
281		{
282	<	return (DLPIStream *)CallMacOS1(mi_next_ptr_ptr, mi_next_ptr_tvect, arg1);
282	>	return (DLPIStream *)Mac2HostAddr((uint32)CallMacOS1(mi_next_ptr_ptr, mi_next_ptr_tvect, arg1));
283		}
284	<
284	>	#ifdef USE_ETHER_FULL_DRIVER
285	>	typedef void (*ether_dispatch_packet_ptr)(uint32 p, uint32 size);
286	>	static uint32 ether_dispatch_packet_tvect = 0;
287	>	#endif
288
289		// Prototypes
290		static void ether_ioctl(DLPIStream *the_stream, queue_t* q, mblk_t* mp);
#	Line 302 | Line 308 | static void DLPI_unit_data(DLPIStream *t
308		*  Initialize ethernet stream module
309		*/
310
311	<	uint8 InitStreamModule(void *theID)
311	>	static uint8 InitStreamModuleImpl(void *theID)
312		{
313		D(bug("InitStreamModule\n"));
314
#	Line 312 | Line 318 | uint8 InitStreamModule(void *theID)
318		ether_driver_opened = false;
319
320		// Import functions from OTKernelLib
321	<	allocb_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\006allocb");
321	>	allocb_tvect = FindLibSymbol("\013OTKernelLib", "\006allocb");
322		D(bug("allocb TVECT at %08lx\n", allocb_tvect));
323		if (allocb_tvect == 0)
324		return false;
325	<	freeb_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\005freeb");
325	>	freeb_tvect = FindLibSymbol("\013OTKernelLib", "\005freeb");
326		D(bug("freeb TVECT at %08lx\n", freeb_tvect));
327		if (freeb_tvect == 0)
328		return false;
329	<	freemsg_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\007freemsg");
329	>	freemsg_tvect = FindLibSymbol("\013OTKernelLib", "\007freemsg");
330		D(bug("freemsg TVECT at %08lx\n", freemsg_tvect));
331		if (freemsg_tvect == 0)
332		return false;
333	<	copyb_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\005copyb");
333	>	copyb_tvect = FindLibSymbol("\013OTKernelLib", "\005copyb");
334		D(bug("copyb TVECT at %08lx\n", copyb_tvect));
335		if (copyb_tvect == 0)
336		return false;
337	<	dupmsg_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\006dupmsg");
337	>	dupmsg_tvect = FindLibSymbol("\013OTKernelLib", "\006dupmsg");
338		D(bug("dupmsg TVECT at %08lx\n", dupmsg_tvect));
339		if (dupmsg_tvect == 0)
340		return false;
341	<	getq_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\004getq");
341	>	getq_tvect = FindLibSymbol("\013OTKernelLib", "\004getq");
342		D(bug("getq TVECT at %08lx\n", getq_tvect));
343		if (getq_tvect == 0)
344		return false;
345	<	putq_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\004putq");
345	>	putq_tvect = FindLibSymbol("\013OTKernelLib", "\004putq");
346		D(bug("putq TVECT at %08lx\n", putq_tvect));
347		if (putq_tvect == 0)
348		return false;
349	<	putnext_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\007putnext");
349	>	putnext_tvect = FindLibSymbol("\013OTKernelLib", "\007putnext");
350		D(bug("putnext TVECT at %08lx\n", putnext_tvect));
351		if (putnext_tvect == 0)
352		return false;
353	<	putnextctl1_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\013putnextctl1");
353	>	putnextctl1_tvect = FindLibSymbol("\013OTKernelLib", "\013putnextctl1");
354		D(bug("putnextctl1 TVECT at %08lx\n", putnextctl1_tvect));
355		if (putnextctl1_tvect == 0)
356		return false;
357	<	canputnext_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\012canputnext");
357	>	canputnext_tvect = FindLibSymbol("\013OTKernelLib", "\012canputnext");
358		D(bug("canputnext TVECT at %08lx\n", canputnext_tvect));
359		if (canputnext_tvect == 0)
360		return false;
361	<	qreply_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\006qreply");
361	>	qreply_tvect = FindLibSymbol("\013OTKernelLib", "\006qreply");
362		D(bug("qreply TVECT at %08lx\n", qreply_tvect));
363		if (qreply_tvect == 0)
364		return false;
365	<	flushq_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\006flushq");
365	>	flushq_tvect = FindLibSymbol("\013OTKernelLib", "\006flushq");
366		D(bug("flushq TVECT at %08lx\n", flushq_tvect));
367		if (flushq_tvect == 0)
368		return false;
369	<	msgdsize_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\010msgdsize");
369	>	msgdsize_tvect = FindLibSymbol("\013OTKernelLib", "\010msgdsize");
370		D(bug("msgdsize TVECT at %08lx\n", msgdsize_tvect));
371		if (msgdsize_tvect == 0)
372		return false;
373	<	otenterint_tvect = (uint32)FindLibSymbol("\017OTKernelUtilLib", "\020OTEnterInterrupt");
373	>	otenterint_tvect = FindLibSymbol("\017OTKernelUtilLib", "\020OTEnterInterrupt");
374		D(bug("OTEnterInterrupt TVECT at %08lx\n", otenterint_tvect));
375		if (otenterint_tvect == 0)
376		return false;
377	<	otleaveint_tvect = (uint32)FindLibSymbol("\017OTKernelUtilLib", "\020OTLeaveInterrupt");
377	>	otleaveint_tvect = FindLibSymbol("\017OTKernelUtilLib", "\020OTLeaveInterrupt");
378		D(bug("OTLeaveInterrupt TVECT at %08lx\n", otleaveint_tvect));
379		if (otleaveint_tvect == 0)
380		return false;
381	<	mi_open_comm_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\014mi_open_comm");
381	>	mi_open_comm_tvect = FindLibSymbol("\013OTKernelLib", "\014mi_open_comm");
382		D(bug("mi_open_comm TVECT at %08lx\n", mi_open_comm_tvect));
383		if (mi_open_comm_tvect == 0)
384		return false;
385	<	mi_close_comm_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\015mi_close_comm");
385	>	mi_close_comm_tvect = FindLibSymbol("\013OTKernelLib", "\015mi_close_comm");
386		D(bug("mi_close_comm TVECT at %08lx\n", mi_close_comm_tvect));
387		if (mi_close_comm_tvect == 0)
388		return false;
389	<	mi_next_ptr_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\013mi_next_ptr");
389	>	mi_next_ptr_tvect = FindLibSymbol("\013OTKernelLib", "\013mi_next_ptr");
390		D(bug("mi_next_ptr TVECT at %08lx\n", mi_next_ptr_tvect));
391		if (mi_next_ptr_tvect == 0)
392		return false;
393
394	+	#ifndef USE_ETHER_FULL_DRIVER
395		// Initialize stream list (which might be leftover)
396		dlpi_stream_list = NULL;
397
398		// Ask add-on for ethernet hardware address
399	<	AO_get_ethernet_address(hardware_address);
399	>	AO_get_ethernet_address(Host2MacAddr(hardware_address));
400	>	#endif
401
402		// Yes, we're open
403		ether_driver_opened = true;
404		return true;
405		}
406
407	+	uint8 InitStreamModule(void *theID)
408	+	{
409	+	// Common initialization code
410	+	bool net_open = InitStreamModuleImpl(theID);
411	+
412	+	// Call InitStreamModule() in native side
413	+	#ifdef BUILD_ETHER_FULL_DRIVER
414	+	extern bool NativeInitStreamModule(void *);
415	+	if (!NativeInitStreamModule((void *)ether_dispatch_packet))
416	+	net_open = false;
417	+	#endif
418	+
419	+	// Import functions from the Ethernet driver
420	+	#ifdef USE_ETHER_FULL_DRIVER
421	+	ether_dispatch_packet_tvect = (uintptr)theID;
422	+	D(bug("ether_dispatch_packet TVECT at %08lx\n", ether_dispatch_packet_tvect));
423	+	if (ether_dispatch_packet_tvect == 0)
424	+	net_open = false;
425	+	#endif
426	+
427	+	return net_open;
428	+	}
429	+
430
431		/*
432		*  Terminate ethernet stream module
433		*/
434
435	<	void TerminateStreamModule(void)
435	>	static void TerminateStreamModuleImpl(void)
436		{
437		D(bug("TerminateStreamModule\n"));
438
439	+	#ifndef USE_ETHER_FULL_DRIVER
440		// This happens sometimes. I don't know why.
441		if (dlpi_stream_list != NULL)
442		printf("FATAL: TerminateStreamModule() called, but streams still open\n");
443	+	#endif
444
445		// Sorry, we're closed
446		ether_driver_opened = false;
447		}
448
449	+	void TerminateStreamModule(void)
450	+	{
451	+	// Common termination code
452	+	TerminateStreamModuleImpl();
453	+
454	+	// Call TerminateStreamModule() in native side
455	+	#ifdef BUILD_ETHER_FULL_DRIVER
456	+	extern void NativeTerminateStreamModule(void);
457	+	NativeTerminateStreamModule();
458	+	#endif
459	+	}
460	+
461
462		/*
463		*  Open new stream
#	Line 433 | Line 478 | int ether_open(queue_t *rdq, void *dev,
478		return 0;
479
480		// Allocate DLPIStream structure
481	<	int err = mi_open_comm(&dlpi_stream_list, sizeof(DLPIStream), rdq, dev, flag, sflag, creds);
481	>	int err = mi_open_comm((DLPIStream **)&dlpi_stream_list, sizeof(DLPIStream), rdq, dev, flag, sflag, creds);
482		if (err)
483		return err;
484		DLPIStream *the_stream = (DLPIStream *)rdq->q_ptr;
#	Line 470 | Line 515 | int ether_close(queue_t *rdq, int flag,
515
516		// Disable all registered multicast addresses
517		while (the_stream->multicast_list) {
518	<	AO_disable_multicast(the_stream->multicast_list->addr);
518	>	AO_disable_multicast(Host2MacAddr(the_stream->multicast_list->addr));
519		the_stream->RemoveMulticast(the_stream->multicast_list->addr);
520		}
521		the_stream->multicast_list = NULL;
522
523		// Delete the DLPIStream
524	<	return mi_close_comm(&dlpi_stream_list, rdq);
524	>	return mi_close_comm((DLPIStream **)&dlpi_stream_list, rdq);
525		}
526
527
#	Line 499 | Line 544 | int ether_wput(queue_t *q, mblk_t *mp)
544		if (the_stream == NULL)
545		return MAC_ENXIO;
546
547	<	D(bug(" db_type %d\n", mp->b_datap->db_type));
547	>	D(bug(" db_type %d\n", (int)mp->b_datap->db_type));
548		switch (mp->b_datap->db_type) {
549
550		case M_DATA:
#	Line 511 | Line 556 | int ether_wput(queue_t *q, mblk_t *mp)
556
557		case M_PROTO:
558		case M_PCPROTO: {
559	<	union DL_primitives *dlp = (union DL_primitives *)mp->b_rptr;
559	>	union DL_primitives *dlp = (union DL_primitives *)(void *)mp->b_rptr;
560		uint32 prim = dlp->dl_primitive;
561		D(bug(" dl_primitive %d\n", prim));
562		switch (prim) {
#	Line 605 | Line 650 | int ether_rsrv(queue_t *q)
650
651		static void ether_ioctl(DLPIStream *the_stream, queue_t *q, mblk_t *mp)
652		{
653	<	struct iocblk *ioc = (struct iocblk *)mp->b_rptr;
654	<	D(bug(" ether_ioctl(%p,%p) cmd %d\n", q, mp, ioc->ioc_cmd));
653	>	struct iocblk *ioc = (struct iocblk *)(void *)mp->b_rptr;
654	>	D(bug(" ether_ioctl(%p,%p) cmd %d\n", q, mp, (int)ioc->ioc_cmd));
655
656		switch (ioc->ioc_cmd) {
657
#	Line 616 | Line 661 | static void ether_ioctl(DLPIStream *the_
661		ioc->ioc_error = MAC_EINVAL;
662		goto ioctl_error;
663		}
664	<	uint32 framing_type = *(uint32 *)info_mp->b_rptr;
664	>	uint32 framing_type = ntohl(*(uint32 *)(void *)info_mp->b_rptr);
665		D(bug("  I_OTSetFramingType type %d\n", framing_type));
666		if (framing_type != kOTGetFramingValue)
667		the_stream->framing_8022 = (framing_type == kOTFraming8022);
#	Line 663 | Line 708 | static void ether_ioctl(DLPIStream *the_
708		ioc->ioc_error = MAC_EINVAL;
709		goto ioctl_error;
710		}
711	<	dlrc = (dl_recv_control_t *)info_mp->b_rptr;
712	<	D(bug("  I_OTSetRawMode primitive %d\n", dlrc->dl_primitive));
711	>	dlrc = (dl_recv_control_t *)(void *)info_mp->b_rptr;
712	>	D(bug("  I_OTSetRawMode primitive %d\n", (int)dlrc->dl_primitive));
713		ioc->ioc_error = MAC_EINVAL;
714		goto ioctl_error;
715		}
#	Line 797 | Line 842 | static mblk_t *reuse_message_block(mblk_
842		static mblk_t *build_tx_packet_header(DLPIStream *the_stream, mblk_t *mp, bool fast_path)
843		{
844		// Only handle unit_data requests
845	<	dl_unitdata_req_t *req = (dl_unitdata_req_t *)mp->b_rptr;
845	>	dl_unitdata_req_t *req = (dl_unitdata_req_t *)(void *)mp->b_rptr;
846		if (req->dl_primitive != DL_UNITDATA_REQ) {
847		freemsg(mp);
848		return NULL;
#	Line 815 | Line 860 | static mblk_t *build_tx_packet_header(DL
860		dlsap = the_stream->dlsap;
861		break;
862		case kEnetAndSAPAddressLength:
863	<	dlsap = *(uint16 *)(destAddrOrig + kEnetPhysicalAddressLength);
863	>	dlsap = ntohs(*(uint16 *)(destAddrOrig + kEnetPhysicalAddressLength));
864		break;
865		case kEnetPhysicalAddressLength + k8022DLSAPLength + k8022SNAPLength:   // SNAP SAP
866	<	dlsap = *(uint16 *)(destAddrOrig + kEnetPhysicalAddressLength);
866	>	dlsap = ntohs(*(uint16 *)(destAddrOrig + kEnetPhysicalAddressLength));
867		break;
868		default:
869		dlsap = the_stream->dlsap;
#	Line 870 | Line 915 | static mblk_t *build_tx_packet_header(DL
915		// Resize header info in message block
916		if ((mp = reuse_message_block(mp, hdrsize)) == NULL)
917		return NULL;
918	<	struct T8022FullPacketHeader *packetHeader = (struct T8022FullPacketHeader *)mp->b_rptr;
918	>	struct T8022FullPacketHeader *packetHeader = (struct T8022FullPacketHeader *)(void *)mp->b_rptr;
919
920		// Set protocol type/size field
921		packetHeader->fEnetPart.fProto = proto;
#	Line 910 | Line 955 | static mblk_t *build_tx_packet_header(DL
955
956		static void transmit_packet(mblk_t *mp)
957		{
958	<	EnetPacketHeader *enetHeader = (EnetPacketHeader *)mp->b_rptr;
958	>	EnetPacketHeader *enetHeader = (EnetPacketHeader *)(void *)mp->b_rptr;
959
960		// Fill in length in 802.3 packets
961		if (enetHeader->fProto == 0)
#	Line 920 | Line 965 | static void transmit_packet(mblk_t *mp)
965		OTCopy48BitAddress(hardware_address, enetHeader->fSourceAddr);
966
967		// Tell add-on to transmit packet
968	<	AO_transmit_packet(mp);
968	>	AO_transmit_packet(Host2MacAddr((uint8 *)mp));
969		freemsg(mp);
970		}
971
#	Line 967 | Line 1012 | static void handle_received_packet(DLPIS
1012
1013		// Set message type
1014		nmp->b_datap->db_type = M_PROTO;
1015	<	dl_unitdata_ind_t *ind = (dl_unitdata_ind_t*)nmp->b_rptr;
1015	>	dl_unitdata_ind_t *ind = (dl_unitdata_ind_t*)(void *)nmp->b_rptr;
1016		ind->dl_primitive = DL_UNITDATA_IND;
1017		nmp->b_wptr += (sizeof(dl_unitdata_ind_t) + 2*addr_len);
1018
#	Line 984 | Line 1029 | static void handle_received_packet(DLPIS
1029		ind->dl_group_address = dest_addr_type;
1030
1031		// Set address fields
1032	<	T8022FullPacketHeader *packetHeader = (T8022FullPacketHeader *)mp->b_rptr;
1032	>	T8022FullPacketHeader *packetHeader = (T8022FullPacketHeader *)(void *)mp->b_rptr;
1033		T8022AddressStruct *destAddr = ((T8022AddressStruct*)(nmp->b_rptr + ind->dl_dest_addr_offset));
1034		T8022AddressStruct *srcAddr = ((T8022AddressStruct*)(nmp->b_rptr + ind->dl_src_addr_offset));
1035
#	Line 1016 | Line 1061 | static void handle_received_packet(DLPIS
1061		void ether_packet_received(mblk_t *mp)
1062		{
1063		// Extract address and types
1064	<	EnetPacketHeader *pkt = (EnetPacketHeader *)mp->b_rptr;
1064	>	EnetPacketHeader *pkt = (EnetPacketHeader *)(void *)mp->b_rptr;
1065		T8022FullPacketHeader *fullpkt = (T8022FullPacketHeader *)pkt;
1066		uint16 sourceSAP, destSAP;
1067		destSAP = fullpkt->fEnetPart.fProto;
#	Line 1092 | Line 1137 | type_found:
1137		}
1138		}
1139
1140	+	void ether_dispatch_packet(uint32 p, uint32 size)
1141	+	{
1142	+	#ifdef USE_ETHER_FULL_DRIVER
1143	+	// Call handler from the Ethernet driver
1144	+	D(bug("ether_dispatch_packet\n"));
1145	+	D(bug(" packet data at %p, %d bytes\n", p, size));
1146	+	CallMacOS2(ether_dispatch_packet_ptr, ether_dispatch_packet_tvect, p, size);
1147	+	#else
1148	+	// Wrap packet in message block
1149	+	num_rx_packets++;
1150	+	mblk_t *mp;
1151	+	if ((mp = allocb(size, 0)) != NULL) {
1152	+	D(bug(" packet data at %p\n", (void *)mp->b_rptr));
1153	+	Mac2Host_memcpy(mp->b_rptr, p, size);
1154	+	mp->b_wptr += size;
1155	+	ether_packet_received(mp);
1156	+	} else {
1157	+	D(bug("WARNING: Cannot allocate mblk for received packet\n"));
1158	+	num_rx_no_mem++;
1159	+	}
1160	+	#endif
1161	+	}
1162	+
1163
1164		/*
1165		*  Build and send an error acknowledge
#	Line 1108 | Line 1176 | static void DLPI_error_ack(DLPIStream *t
1176		return;
1177
1178		ack_mp->b_datap->db_type = M_PCPROTO;
1179	<	dl_error_ack_t *errp = (dl_error_ack_t *)ack_mp->b_wptr;
1179	>	dl_error_ack_t *errp = (dl_error_ack_t *)(void *)ack_mp->b_wptr;
1180		errp->dl_primitive = DL_ERROR_ACK;
1181		errp->dl_error_primitive = prim;
1182		errp->dl_errno = err;
#	Line 1138 | Line 1206 | static void DLPI_ok_ack(DLPIStream *the_
1206		}
1207
1208		ack_mp->b_datap->db_type = M_PCPROTO;
1209	<	dl_ok_ack_t *ackp = (dl_ok_ack_t *)ack_mp->b_rptr;
1209	>	dl_ok_ack_t *ackp = (dl_ok_ack_t *)(void *)ack_mp->b_rptr;
1210		ackp->dl_primitive = DL_OK_ACK;
1211		ackp->dl_correct_primitive = prim;
1212		ack_mp->b_wptr = ack_mp->b_rptr + sizeof(dl_ok_ack_t);
#	Line 1178 | Line 1246 | static void DLPI_info(DLPIStream *the_st
1246
1247		// Set up message type
1248		ack_mp->b_datap->db_type = M_PCPROTO;
1249	<	dl_info_ack_t *ackp = (dl_info_ack_t *)ack_mp->b_rptr;
1249	>	dl_info_ack_t *ackp = (dl_info_ack_t *)(void *)ack_mp->b_rptr;
1250		ackp->dl_primitive = DL_INFO_ACK;
1251
1252		// Info/version fields
#	Line 1230 | Line 1298 | static void DLPI_info(DLPIStream *the_st
1298		static void DLPI_phys_addr(DLPIStream *the_stream, queue_t *q, mblk_t *mp)
1299		{
1300		D(bug("  DLPI_phys_addr(%p,%p)\n", the_stream, mp));
1301	<	dl_phys_addr_req_t *req = (dl_phys_addr_req_t *)mp->b_rptr;
1301	>	dl_phys_addr_req_t *req = (dl_phys_addr_req_t *)(void *)mp->b_rptr;
1302
1303		// Allocate message block for reply
1304		mblk_t *ack_mp;
#	Line 1241 | Line 1309 | static void DLPI_phys_addr(DLPIStream *t
1309
1310		// Set up message type
1311		ack_mp->b_datap->db_type = M_PCPROTO;
1312	<	dl_phys_addr_ack_t *ackp = (dl_phys_addr_ack_t *)ack_mp->b_wptr;
1312	>	dl_phys_addr_ack_t *ackp = (dl_phys_addr_ack_t *)(void *)ack_mp->b_wptr;
1313		ackp->dl_primitive = DL_PHYS_ADDR_ACK;
1314
1315		// Fill in address
#	Line 1270 | Line 1338 | static void DLPI_phys_addr(DLPIStream *t
1338
1339		static void DLPI_bind(DLPIStream *the_stream, queue_t *q, mblk_t *mp)
1340		{
1341	<	dl_bind_req_t *req = (dl_bind_req_t *)mp->b_rptr;
1341	>	dl_bind_req_t *req = (dl_bind_req_t *)(void *)mp->b_rptr;
1342		uint32 sap = req->dl_sap;
1343		D(bug("  DLPI_bind(%p,%p) SAP %04x\n", the_stream, mp, sap));
1344
#	Line 1307 | Line 1375 | static void DLPI_bind(DLPIStream *the_st
1375
1376		// Set up message type
1377		ack_mp->b_datap->db_type = M_PCPROTO;
1378	<	dl_bind_ack_t *ackp = (dl_bind_ack_t *)ack_mp->b_rptr;
1378	>	dl_bind_ack_t *ackp = (dl_bind_ack_t *)(void *)ack_mp->b_rptr;
1379		ackp->dl_primitive = DL_BIND_ACK;
1380
1381		// Fill in other fields
#	Line 1380 | Line 1448 | static void DLPI_unbind(DLPIStream *the_
1448
1449		static void DLPI_subs_bind(DLPIStream *the_stream, queue_t *q, mblk_t *mp)
1450		{
1451	<	dl_subs_bind_req_t *req = (dl_subs_bind_req_t *)mp->b_rptr;
1451	>	dl_subs_bind_req_t *req = (dl_subs_bind_req_t *)(void *)mp->b_rptr;
1452		uint8 *sap = ((uint8 *)req) + req->dl_subs_sap_offset;
1453		int32 length = req->dl_subs_sap_length;
1454	<	uint16 theSap = *((uint16 *)sap);
1454	>	uint16 theSap = ntohs(*((uint16 *)sap));
1455		int32 error = 0;
1456		D(bug("  DLPI_subs_bind(%p,%p) SAP %02x%02x%02x%02x%02x\n", the_stream, mp, sap[0], sap[1], sap[2], sap[3], sap[4]));
1457
#	Line 1438 | Line 1506 | static void DLPI_subs_bind(DLPIStream *t
1506
1507		// Set up message type
1508		ack_mp->b_datap->db_type = M_PCPROTO;
1509	<	dl_subs_bind_ack_t *ackp = (dl_subs_bind_ack_t *)ack_mp->b_wptr;
1509	>	dl_subs_bind_ack_t *ackp = (dl_subs_bind_ack_t *)(void *)ack_mp->b_wptr;
1510		memset(ackp, 0, sizeof(dl_subs_bind_ack_t) + length);
1511		ackp->dl_primitive = DL_SUBS_BIND_ACK;
1512
#	Line 1465 | Line 1533 | static void DLPI_subs_bind(DLPIStream *t
1533
1534		static void DLPI_subs_unbind(DLPIStream *the_stream, queue_t *q, mblk_t *mp)
1535		{
1536	<	dl_subs_unbind_req_t *req = (dl_subs_unbind_req_t *)mp->b_rptr;
1536	>	dl_subs_unbind_req_t *req = (dl_subs_unbind_req_t *)(void *)mp->b_rptr;
1537		uint8 *sap = ((uint8 *)req) + req->dl_subs_sap_offset;
1538		int32 length = req->dl_subs_sap_length;
1539		int32 error = 0;
#	Line 1516 | Line 1584 | static void DLPI_subs_unbind(DLPIStream
1584
1585		static void DLPI_enable_multi(DLPIStream *the_stream, queue_t *q, mblk_t *mp)
1586		{
1587	<	dl_enabmulti_req_t*     req = (dl_enabmulti_req_t*)mp->b_rptr;
1587	>	dl_enabmulti_req_t*     req = (dl_enabmulti_req_t*)(void *)mp->b_rptr;
1588		uint8 *reqaddr = (uint8 *)(mp->b_rptr + req->dl_addr_offset);
1589		D(bug("  DLPI_enable_multi(%p,%p) addr %02x%02x%02x%02x%02x%02x\n", the_stream, mp, reqaddr[0], reqaddr[1], reqaddr[2], reqaddr[3], reqaddr[4], reqaddr[5]));
1590
#	Line 1533 | Line 1601 | static void DLPI_enable_multi(DLPIStream
1601		}
1602
1603		// Tell add-on to enable multicast address
1604	<	AO_enable_multicast(reqaddr);
1604	>	AO_enable_multicast(Host2MacAddr((uint8 *)reqaddr));
1605
1606		// Add new address to multicast list
1607	<	uint8 *addr = new uint8[kEnetPhysicalAddressLength];
1607	>	uint8 *addr = Mac2HostAddr(Mac_sysalloc(kEnetPhysicalAddressLength));
1608		OTCopy48BitAddress(reqaddr, addr);
1609		the_stream->AddMulticast(addr);
1610
#	Line 1555 | Line 1623 | static void DLPI_enable_multi(DLPIStream
1623
1624		static void DLPI_disable_multi(DLPIStream *the_stream, queue_t *q, mblk_t *mp)
1625		{
1626	<	dl_disabmulti_req_t *req = (dl_disabmulti_req_t*)mp->b_rptr;
1626	>	dl_disabmulti_req_t *req = (dl_disabmulti_req_t*)(void *)mp->b_rptr;
1627		uint8 *reqaddr = (uint8 *)(mp->b_rptr + req->dl_addr_offset);
1628		D(bug("  DLPI_disable_multi(%p,%p) addr %02x%02x%02x%02x%02x%02x\n", the_stream, mp, reqaddr[0], reqaddr[1], reqaddr[2], reqaddr[3], reqaddr[4], reqaddr[5]));
1629
#	Line 1574 | Line 1642 | static void DLPI_disable_multi(DLPIStrea
1642
1643		// Found, then remove
1644		the_stream->RemoveMulticast(addr);
1645	<	delete addr;
1645	>	Mac_sysfree(Host2MacAddr(addr));
1646
1647		// Tell add-on to disable multicast address
1648	<	AO_disable_multicast(reqaddr);
1648	>	AO_disable_multicast(Host2MacAddr((uint8 *)reqaddr));
1649
1650		// No longer check multicast packets if no multicast addresses are registered
1651		if (the_stream->multicast_list == NULL)
#	Line 1596 | Line 1664 | static void DLPI_disable_multi(DLPIStrea
1664		static void DLPI_unit_data(DLPIStream *the_stream, queue_t *q, mblk_t *mp)
1665		{
1666		D(bug("  DLPI_unit_data(%p,%p)\n", the_stream, mp));
1667	<	dl_unitdata_req_t *req = (dl_unitdata_req_t *)mp->b_rptr;
1667	>	dl_unitdata_req_t *req = (dl_unitdata_req_t *)(void *)mp->b_rptr;
1668
1669		// Stream must be idle
1670		if (the_stream->dlpi_state != DL_IDLE) {
#	Line 1611 | Line 1679 | static void DLPI_unit_data(DLPIStream *t
1679		return;
1680		}
1681		bp->b_datap->db_type = M_PROTO;
1682	<	errp = (dl_uderror_ind_t *)bp->b_wptr;
1682	>	errp = (dl_uderror_ind_t *)(void *)bp->b_wptr;
1683		errp->dl_primitive = DL_UDERROR_IND;
1684		errp->dl_errno = DL_OUTSTATE;
1685		errp->dl_unix_errno = 0;
#	Line 1630 | Line 1698 | static void DLPI_unit_data(DLPIStream *t
1698		if ((mp = build_tx_packet_header(the_stream, mp, false)) != NULL)
1699		transmit_packet(mp);
1700		}
1701	+
1702	+
1703	+	/*
1704	+	*  Ethernet packet allocator
1705	+	*/
1706	+
1707	+	#if SIZEOF_VOID_P != 4 || REAL_ADDRESSING == 0
1708	+	static uint32 ether_packet = 0;                 // Ethernet packet (cached allocation)
1709	+	static uint32 n_ether_packets = 0;              // Number of ethernet packets allocated so far (should be at most 1)
1710	+
1711	+	EthernetPacket::EthernetPacket()
1712	+	{
1713	+	++n_ether_packets;
1714	+	if (ether_packet && n_ether_packets == 1)
1715	+	packet = ether_packet;
1716	+	else {
1717	+	packet = Mac_sysalloc(1516);
1718	+	assert(packet != 0);
1719	+	Mac_memset(packet, 0, 1516);
1720	+	if (ether_packet == 0)
1721	+	ether_packet = packet;
1722	+	}
1723	+	}
1724	+
1725	+	EthernetPacket::~EthernetPacket()
1726	+	{
1727	+	--n_ether_packets;
1728	+	if (packet != ether_packet)
1729	+	Mac_sysfree(packet);
1730	+	if (n_ether_packets > 0) {
1731	+	bug("WARNING: Nested allocation of ethernet packets!\n");
1732	+	}
1733	+	}
1734	+	#endif

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines