ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/cebix/SheepShaver/src/ether.cpp
(Generate patch)

Comparing SheepShaver/src/ether.cpp (file contents):
Revision 1.1.1.1 by cebix, 2002-02-04T16:58:13Z vs.
Revision 1.7 by gbeauche, 2005-01-30T21:48:19Z

# 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-2005 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 37 | Line 37
37   #define DEBUG 0
38   #include "debug.h"
39  
40 + #if DIRECT_ADDRESSING
41 + #warning "This code is not direct addressing clean"
42 + #endif
43  
44   // Packet types
45   enum {
# Line 58 | Line 61 | static const int kGSshift = 6;
61   static const int kGSmask = 0x1F;
62  
63   struct multicast_node {
64 <        multicast_node *next;
64 >        nw_multicast_node_p next;
65          uint8 addr[kEnetPhysicalAddressLength];
66   };
67  
# Line 86 | Line 89 | struct DLPIStream {
89  
90          void AddMulticast(uint8 *addr)
91          {
92 <                multicast_node *n = new multicast_node;
92 >                multicast_node *n = (multicast_node *)Mac2HostAddr(Mac_sysalloc(sizeof(multicast_node)));
93                  memcpy(n->addr, addr, kEnetPhysicalAddressLength);
94                  n->next = multicast_list;
95                  multicast_list = n;
# Line 106 | Line 109 | struct DLPIStream {
109                  while (q) {
110                          if (q->next == p) {
111                                  q->next = p->next;
112 <                                delete p;
112 >                                Mac_sysfree(Host2MacAddr((uint8 *)p));
113                                  return;
114                          }
115                          q = q->next;
# Line 124 | Line 127 | struct DLPIStream {
127                  return NULL;
128          }
129  
130 <        uint32 minor_num;                                       // Minor device number of this stream
131 <        uint32 dlpi_state;                                      // DLPI state of this stream
132 <        uint32 flags;                                           // Flags
133 <        uint16 dlsap;                                           // SAP bound to this stream
134 <        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
135 <        queue_t *rdq;                                           // Read queue for this stream
136 <        uint32 group_sap[kGroupSAPMapSize];     // Map of bound group SAPs
137 <        uint8 snap[k8022SNAPLength];            // SNAP bound to this stream
138 <        multicast_node *multicast_list;         // List of enabled multicast addresses
130 >        nw_uint32 minor_num;                                    // Minor device number of this stream
131 >        nw_uint32 dlpi_state;                                   // DLPI state of this stream
132 >        nw_uint32 flags;                                                // Flags
133 >        nw_uint16 dlsap;                                                // SAP bound to this stream
134 >        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
135 >        nw_queue_p rdq;                                                 // Read queue for this stream
136 >        nw_uint32 group_sap[kGroupSAPMapSize];  // Map of bound group SAPs
137 >        uint8 snap[k8022SNAPLength];                    // SNAP bound to this stream
138 >        nw_multicast_node_p multicast_list;             // List of enabled multicast addresses
139 > };
140 >
141 > // Hack to make DLPIStream list initialization early to NULL (do we really need this?)
142 > struct DLPIStreamInit {
143 >        DLPIStreamInit(nw_DLPIStream_p *dlpi_stream_p) { *dlpi_stream_p = NULL; }
144   };
145  
146   // Stream flags
# Line 144 | Line 152 | enum {
152   };
153  
154   // List of opened streams (used internally by OpenTransport)
155 < static DLPIStream *dlpi_stream_list = NULL;
155 > static nw_DLPIStream_p dlpi_stream_list;
156 > static DLPIStreamInit dlpi_stream_init(&dlpi_stream_list);
157  
158   // Are we open?
159   bool ether_driver_opened = false;
# Line 174 | Line 183 | typedef mblk_t *(*allocb_ptr)(size_t siz
183   static uint32 allocb_tvect = 0;
184   mblk_t *allocb(size_t arg1, int arg2)
185   {
186 <        return (mblk_t *)CallMacOS2(allocb_ptr, allocb_tvect, arg1, arg2);
186 >        return (mblk_t *)Mac2HostAddr(CallMacOS2(allocb_ptr, allocb_tvect, arg1, arg2));
187   }
188   typedef void (*freeb_ptr)(mblk_t *);
189   static uint32 freeb_tvect = 0;
# Line 192 | Line 201 | typedef mblk_t *(*copyb_ptr)(mblk_t *);
201   static uint32 copyb_tvect = 0;
202   static inline mblk_t *copyb(mblk_t *arg1)
203   {
204 <        return (mblk_t *)CallMacOS1(copyb_ptr, copyb_tvect, arg1);
204 >        return (mblk_t *)Mac2HostAddr(CallMacOS1(copyb_ptr, copyb_tvect, arg1));
205   }
206   typedef mblk_t *(*dupmsg_ptr)(mblk_t *);
207   static uint32 dupmsg_tvect = 0;
208   static inline mblk_t *dupmsg(mblk_t *arg1)
209   {
210 <        return (mblk_t *)CallMacOS1(dupmsg_ptr, dupmsg_tvect, arg1);
210 >        return (mblk_t *)Mac2HostAddr(CallMacOS1(dupmsg_ptr, dupmsg_tvect, arg1));
211   }
212   typedef mblk_t *(*getq_ptr)(queue_t *);
213   static uint32 getq_tvect = 0;
214   static inline mblk_t *getq(queue_t *arg1)
215   {
216 <        return (mblk_t *)CallMacOS1(getq_ptr, getq_tvect, arg1);
216 >        return (mblk_t *)Mac2HostAddr(CallMacOS1(getq_ptr, getq_tvect, arg1));
217   }
218   typedef int (*putq_ptr)(queue_t *, mblk_t *);
219   static uint32 putq_tvect = 0;
# Line 276 | Line 285 | typedef DLPIStream *(*mi_next_ptr_ptr)(D
285   static uint32 mi_next_ptr_tvect = 0;
286   static inline DLPIStream *mi_next_ptr(DLPIStream *arg1)
287   {
288 <        return (DLPIStream *)CallMacOS1(mi_next_ptr_ptr, mi_next_ptr_tvect, arg1);
288 >        return (DLPIStream *)Mac2HostAddr(CallMacOS1(mi_next_ptr_ptr, mi_next_ptr_tvect, arg1));
289   }
290  
291  
# Line 312 | Line 321 | uint8 InitStreamModule(void *theID)
321          ether_driver_opened = false;
322  
323          // Import functions from OTKernelLib
324 <        allocb_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\006allocb");
324 >        allocb_tvect = FindLibSymbol("\013OTKernelLib", "\006allocb");
325          D(bug("allocb TVECT at %08lx\n", allocb_tvect));
326          if (allocb_tvect == 0)
327                  return false;
328 <        freeb_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\005freeb");
328 >        freeb_tvect = FindLibSymbol("\013OTKernelLib", "\005freeb");
329          D(bug("freeb TVECT at %08lx\n", freeb_tvect));
330          if (freeb_tvect == 0)
331                  return false;
332 <        freemsg_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\007freemsg");
332 >        freemsg_tvect = FindLibSymbol("\013OTKernelLib", "\007freemsg");
333          D(bug("freemsg TVECT at %08lx\n", freemsg_tvect));
334          if (freemsg_tvect == 0)
335                  return false;
336 <        copyb_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\005copyb");
336 >        copyb_tvect = FindLibSymbol("\013OTKernelLib", "\005copyb");
337          D(bug("copyb TVECT at %08lx\n", copyb_tvect));
338          if (copyb_tvect == 0)
339                  return false;
340 <        dupmsg_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\006dupmsg");
340 >        dupmsg_tvect = FindLibSymbol("\013OTKernelLib", "\006dupmsg");
341          D(bug("dupmsg TVECT at %08lx\n", dupmsg_tvect));
342          if (dupmsg_tvect == 0)
343                  return false;
344 <        getq_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\004getq");
344 >        getq_tvect = FindLibSymbol("\013OTKernelLib", "\004getq");
345          D(bug("getq TVECT at %08lx\n", getq_tvect));
346          if (getq_tvect == 0)
347                  return false;
348 <        putq_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\004putq");
348 >        putq_tvect = FindLibSymbol("\013OTKernelLib", "\004putq");
349          D(bug("putq TVECT at %08lx\n", putq_tvect));
350          if (putq_tvect == 0)
351                  return false;
352 <        putnext_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\007putnext");
352 >        putnext_tvect = FindLibSymbol("\013OTKernelLib", "\007putnext");
353          D(bug("putnext TVECT at %08lx\n", putnext_tvect));
354          if (putnext_tvect == 0)
355                  return false;
356 <        putnextctl1_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\013putnextctl1");
356 >        putnextctl1_tvect = FindLibSymbol("\013OTKernelLib", "\013putnextctl1");
357          D(bug("putnextctl1 TVECT at %08lx\n", putnextctl1_tvect));
358          if (putnextctl1_tvect == 0)
359                  return false;
360 <        canputnext_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\012canputnext");
360 >        canputnext_tvect = FindLibSymbol("\013OTKernelLib", "\012canputnext");
361          D(bug("canputnext TVECT at %08lx\n", canputnext_tvect));
362          if (canputnext_tvect == 0)
363                  return false;
364 <        qreply_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\006qreply");
364 >        qreply_tvect = FindLibSymbol("\013OTKernelLib", "\006qreply");
365          D(bug("qreply TVECT at %08lx\n", qreply_tvect));
366          if (qreply_tvect == 0)
367                  return false;
368 <        flushq_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\006flushq");
368 >        flushq_tvect = FindLibSymbol("\013OTKernelLib", "\006flushq");
369          D(bug("flushq TVECT at %08lx\n", flushq_tvect));
370          if (flushq_tvect == 0)
371                  return false;
372 <        msgdsize_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\010msgdsize");
372 >        msgdsize_tvect = FindLibSymbol("\013OTKernelLib", "\010msgdsize");
373          D(bug("msgdsize TVECT at %08lx\n", msgdsize_tvect));
374          if (msgdsize_tvect == 0)
375                  return false;
376 <        otenterint_tvect = (uint32)FindLibSymbol("\017OTKernelUtilLib", "\020OTEnterInterrupt");
376 >        otenterint_tvect = FindLibSymbol("\017OTKernelUtilLib", "\020OTEnterInterrupt");
377          D(bug("OTEnterInterrupt TVECT at %08lx\n", otenterint_tvect));
378          if (otenterint_tvect == 0)
379                  return false;
380 <        otleaveint_tvect = (uint32)FindLibSymbol("\017OTKernelUtilLib", "\020OTLeaveInterrupt");
380 >        otleaveint_tvect = FindLibSymbol("\017OTKernelUtilLib", "\020OTLeaveInterrupt");
381          D(bug("OTLeaveInterrupt TVECT at %08lx\n", otleaveint_tvect));
382          if (otleaveint_tvect == 0)
383                  return false;
384 <        mi_open_comm_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\014mi_open_comm");
384 >        mi_open_comm_tvect = FindLibSymbol("\013OTKernelLib", "\014mi_open_comm");
385          D(bug("mi_open_comm TVECT at %08lx\n", mi_open_comm_tvect));
386          if (mi_open_comm_tvect == 0)
387                  return false;
388 <        mi_close_comm_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\015mi_close_comm");
388 >        mi_close_comm_tvect = FindLibSymbol("\013OTKernelLib", "\015mi_close_comm");
389          D(bug("mi_close_comm TVECT at %08lx\n", mi_close_comm_tvect));
390          if (mi_close_comm_tvect == 0)
391                  return false;
392 <        mi_next_ptr_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\013mi_next_ptr");
392 >        mi_next_ptr_tvect = FindLibSymbol("\013OTKernelLib", "\013mi_next_ptr");
393          D(bug("mi_next_ptr TVECT at %08lx\n", mi_next_ptr_tvect));
394          if (mi_next_ptr_tvect == 0)
395                  return false;
# Line 433 | Line 442 | int ether_open(queue_t *rdq, void *dev,
442                  return 0;
443  
444          // Allocate DLPIStream structure
445 <        int err = mi_open_comm(&dlpi_stream_list, sizeof(DLPIStream), rdq, dev, flag, sflag, creds);
445 >        int err = mi_open_comm((DLPIStream **)&dlpi_stream_list, sizeof(DLPIStream), rdq, dev, flag, sflag, creds);
446          if (err)
447                  return err;
448          DLPIStream *the_stream = (DLPIStream *)rdq->q_ptr;
# Line 476 | Line 485 | int ether_close(queue_t *rdq, int flag,
485          the_stream->multicast_list = NULL;
486  
487          // Delete the DLPIStream
488 <        return mi_close_comm(&dlpi_stream_list, rdq);
488 >        return mi_close_comm((DLPIStream **)&dlpi_stream_list, rdq);
489   }
490  
491  
# Line 499 | Line 508 | int ether_wput(queue_t *q, mblk_t *mp)
508          if (the_stream == NULL)
509                  return MAC_ENXIO;
510  
511 <        D(bug(" db_type %d\n", mp->b_datap->db_type));
511 >        D(bug(" db_type %d\n", (int)mp->b_datap->db_type));
512          switch (mp->b_datap->db_type) {
513  
514                  case M_DATA:
# Line 511 | Line 520 | int ether_wput(queue_t *q, mblk_t *mp)
520  
521                  case M_PROTO:
522                  case M_PCPROTO: {
523 <                        union DL_primitives *dlp = (union DL_primitives *)mp->b_rptr;
523 >                        union DL_primitives *dlp = (union DL_primitives *)(void *)mp->b_rptr;
524                          uint32 prim = dlp->dl_primitive;
525                          D(bug(" dl_primitive %d\n", prim));
526                          switch (prim) {
# Line 605 | Line 614 | int ether_rsrv(queue_t *q)
614  
615   static void ether_ioctl(DLPIStream *the_stream, queue_t *q, mblk_t *mp)
616   {
617 <        struct iocblk *ioc = (struct iocblk *)mp->b_rptr;
618 <        D(bug(" ether_ioctl(%p,%p) cmd %d\n", q, mp, ioc->ioc_cmd));
617 >        struct iocblk *ioc = (struct iocblk *)(void *)mp->b_rptr;
618 >        D(bug(" ether_ioctl(%p,%p) cmd %d\n", q, mp, (int)ioc->ioc_cmd));
619  
620          switch (ioc->ioc_cmd) {
621  
# Line 616 | Line 625 | static void ether_ioctl(DLPIStream *the_
625                                  ioc->ioc_error = MAC_EINVAL;
626                                  goto ioctl_error;
627                          }
628 <                        uint32 framing_type = *(uint32 *)info_mp->b_rptr;
628 >                        uint32 framing_type = ntohl(*(uint32 *)(void *)info_mp->b_rptr);
629                          D(bug("  I_OTSetFramingType type %d\n", framing_type));
630                          if (framing_type != kOTGetFramingValue)
631                                  the_stream->framing_8022 = (framing_type == kOTFraming8022);
# Line 663 | Line 672 | static void ether_ioctl(DLPIStream *the_
672                                  ioc->ioc_error = MAC_EINVAL;
673                                  goto ioctl_error;
674                          }
675 <                        dlrc = (dl_recv_control_t *)info_mp->b_rptr;
676 <                        D(bug("  I_OTSetRawMode primitive %d\n", dlrc->dl_primitive));
675 >                        dlrc = (dl_recv_control_t *)(void *)info_mp->b_rptr;
676 >                        D(bug("  I_OTSetRawMode primitive %d\n", (int)dlrc->dl_primitive));
677                          ioc->ioc_error = MAC_EINVAL;
678                          goto ioctl_error;
679                  }
# Line 797 | Line 806 | static mblk_t *reuse_message_block(mblk_
806   static mblk_t *build_tx_packet_header(DLPIStream *the_stream, mblk_t *mp, bool fast_path)
807   {
808          // Only handle unit_data requests
809 <        dl_unitdata_req_t *req = (dl_unitdata_req_t *)mp->b_rptr;
809 >        dl_unitdata_req_t *req = (dl_unitdata_req_t *)(void *)mp->b_rptr;
810          if (req->dl_primitive != DL_UNITDATA_REQ) {
811                  freemsg(mp);
812                  return NULL;
# Line 815 | Line 824 | static mblk_t *build_tx_packet_header(DL
824                          dlsap = the_stream->dlsap;
825                          break;
826                  case kEnetAndSAPAddressLength:  
827 <                        dlsap = *(uint16 *)(destAddrOrig + kEnetPhysicalAddressLength);
827 >                        dlsap = ntohs(*(uint16 *)(destAddrOrig + kEnetPhysicalAddressLength));
828                          break;
829                  case kEnetPhysicalAddressLength + k8022DLSAPLength + k8022SNAPLength:   // SNAP SAP
830 <                        dlsap = *(uint16 *)(destAddrOrig + kEnetPhysicalAddressLength);
830 >                        dlsap = ntohs(*(uint16 *)(destAddrOrig + kEnetPhysicalAddressLength));
831                          break;
832                  default:
833                          dlsap = the_stream->dlsap;
# Line 870 | Line 879 | static mblk_t *build_tx_packet_header(DL
879          // Resize header info in message block
880          if ((mp = reuse_message_block(mp, hdrsize)) == NULL)
881                  return NULL;
882 <        struct T8022FullPacketHeader *packetHeader = (struct T8022FullPacketHeader *)mp->b_rptr;
882 >        struct T8022FullPacketHeader *packetHeader = (struct T8022FullPacketHeader *)(void *)mp->b_rptr;
883  
884          // Set protocol type/size field
885          packetHeader->fEnetPart.fProto = proto;
# Line 910 | Line 919 | static mblk_t *build_tx_packet_header(DL
919  
920   static void transmit_packet(mblk_t *mp)
921   {
922 <        EnetPacketHeader *enetHeader = (EnetPacketHeader *)mp->b_rptr;
922 >        EnetPacketHeader *enetHeader = (EnetPacketHeader *)(void *)mp->b_rptr;
923  
924          // Fill in length in 802.3 packets
925          if (enetHeader->fProto == 0)
# Line 967 | Line 976 | static void handle_received_packet(DLPIS
976  
977          // Set message type
978          nmp->b_datap->db_type = M_PROTO;
979 <        dl_unitdata_ind_t *ind = (dl_unitdata_ind_t*)nmp->b_rptr;
979 >        dl_unitdata_ind_t *ind = (dl_unitdata_ind_t*)(void *)nmp->b_rptr;
980          ind->dl_primitive = DL_UNITDATA_IND;
981          nmp->b_wptr += (sizeof(dl_unitdata_ind_t) + 2*addr_len);
982  
# Line 984 | Line 993 | static void handle_received_packet(DLPIS
993          ind->dl_group_address = dest_addr_type;
994  
995          // Set address fields
996 <        T8022FullPacketHeader *packetHeader = (T8022FullPacketHeader *)mp->b_rptr;
996 >        T8022FullPacketHeader *packetHeader = (T8022FullPacketHeader *)(void *)mp->b_rptr;
997          T8022AddressStruct *destAddr = ((T8022AddressStruct*)(nmp->b_rptr + ind->dl_dest_addr_offset));
998          T8022AddressStruct *srcAddr = ((T8022AddressStruct*)(nmp->b_rptr + ind->dl_src_addr_offset));
999  
# Line 1016 | Line 1025 | static void handle_received_packet(DLPIS
1025   void ether_packet_received(mblk_t *mp)
1026   {
1027          // Extract address and types
1028 <        EnetPacketHeader *pkt = (EnetPacketHeader *)mp->b_rptr;
1028 >        EnetPacketHeader *pkt = (EnetPacketHeader *)(void *)mp->b_rptr;
1029          T8022FullPacketHeader *fullpkt = (T8022FullPacketHeader *)pkt;
1030          uint16 sourceSAP, destSAP;
1031          destSAP = fullpkt->fEnetPart.fProto;
# Line 1108 | Line 1117 | static void DLPI_error_ack(DLPIStream *t
1117                  return;
1118  
1119          ack_mp->b_datap->db_type = M_PCPROTO;
1120 <        dl_error_ack_t *errp = (dl_error_ack_t *)ack_mp->b_wptr;
1120 >        dl_error_ack_t *errp = (dl_error_ack_t *)(void *)ack_mp->b_wptr;
1121          errp->dl_primitive = DL_ERROR_ACK;
1122          errp->dl_error_primitive = prim;
1123          errp->dl_errno = err;
# Line 1138 | Line 1147 | static void DLPI_ok_ack(DLPIStream *the_
1147          }
1148  
1149          ack_mp->b_datap->db_type = M_PCPROTO;
1150 <        dl_ok_ack_t *ackp = (dl_ok_ack_t *)ack_mp->b_rptr;
1150 >        dl_ok_ack_t *ackp = (dl_ok_ack_t *)(void *)ack_mp->b_rptr;
1151          ackp->dl_primitive = DL_OK_ACK;
1152          ackp->dl_correct_primitive = prim;
1153          ack_mp->b_wptr = ack_mp->b_rptr + sizeof(dl_ok_ack_t);
# Line 1178 | Line 1187 | static void DLPI_info(DLPIStream *the_st
1187  
1188          // Set up message type
1189          ack_mp->b_datap->db_type = M_PCPROTO;
1190 <        dl_info_ack_t *ackp = (dl_info_ack_t *)ack_mp->b_rptr;
1190 >        dl_info_ack_t *ackp = (dl_info_ack_t *)(void *)ack_mp->b_rptr;
1191          ackp->dl_primitive = DL_INFO_ACK;
1192  
1193          // Info/version fields
# Line 1230 | Line 1239 | static void DLPI_info(DLPIStream *the_st
1239   static void DLPI_phys_addr(DLPIStream *the_stream, queue_t *q, mblk_t *mp)
1240   {
1241          D(bug("  DLPI_phys_addr(%p,%p)\n", the_stream, mp));
1242 <        dl_phys_addr_req_t *req = (dl_phys_addr_req_t *)mp->b_rptr;
1242 >        dl_phys_addr_req_t *req = (dl_phys_addr_req_t *)(void *)mp->b_rptr;
1243  
1244          // Allocate message block for reply
1245          mblk_t *ack_mp;
# Line 1241 | Line 1250 | static void DLPI_phys_addr(DLPIStream *t
1250  
1251          // Set up message type
1252          ack_mp->b_datap->db_type = M_PCPROTO;
1253 <        dl_phys_addr_ack_t *ackp = (dl_phys_addr_ack_t *)ack_mp->b_wptr;
1253 >        dl_phys_addr_ack_t *ackp = (dl_phys_addr_ack_t *)(void *)ack_mp->b_wptr;
1254          ackp->dl_primitive = DL_PHYS_ADDR_ACK;
1255  
1256          // Fill in address
# Line 1270 | Line 1279 | static void DLPI_phys_addr(DLPIStream *t
1279  
1280   static void DLPI_bind(DLPIStream *the_stream, queue_t *q, mblk_t *mp)
1281   {
1282 <        dl_bind_req_t *req = (dl_bind_req_t *)mp->b_rptr;
1282 >        dl_bind_req_t *req = (dl_bind_req_t *)(void *)mp->b_rptr;
1283          uint32 sap = req->dl_sap;
1284          D(bug("  DLPI_bind(%p,%p) SAP %04x\n", the_stream, mp, sap));
1285  
# Line 1307 | Line 1316 | static void DLPI_bind(DLPIStream *the_st
1316  
1317          // Set up message type
1318          ack_mp->b_datap->db_type = M_PCPROTO;
1319 <        dl_bind_ack_t *ackp = (dl_bind_ack_t *)ack_mp->b_rptr;
1319 >        dl_bind_ack_t *ackp = (dl_bind_ack_t *)(void *)ack_mp->b_rptr;
1320          ackp->dl_primitive = DL_BIND_ACK;
1321  
1322          // Fill in other fields
# Line 1380 | Line 1389 | static void DLPI_unbind(DLPIStream *the_
1389  
1390   static void DLPI_subs_bind(DLPIStream *the_stream, queue_t *q, mblk_t *mp)
1391   {
1392 <        dl_subs_bind_req_t *req = (dl_subs_bind_req_t *)mp->b_rptr;
1392 >        dl_subs_bind_req_t *req = (dl_subs_bind_req_t *)(void *)mp->b_rptr;
1393          uint8 *sap = ((uint8 *)req) + req->dl_subs_sap_offset;
1394          int32 length = req->dl_subs_sap_length;
1395 <        uint16 theSap = *((uint16 *)sap);
1395 >        uint16 theSap = ntohs(*((uint16 *)sap));
1396          int32 error = 0;
1397          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]));
1398  
# Line 1438 | Line 1447 | static void DLPI_subs_bind(DLPIStream *t
1447  
1448          // Set up message type
1449          ack_mp->b_datap->db_type = M_PCPROTO;
1450 <        dl_subs_bind_ack_t *ackp = (dl_subs_bind_ack_t *)ack_mp->b_wptr;
1450 >        dl_subs_bind_ack_t *ackp = (dl_subs_bind_ack_t *)(void *)ack_mp->b_wptr;
1451          memset(ackp, 0, sizeof(dl_subs_bind_ack_t) + length);
1452          ackp->dl_primitive = DL_SUBS_BIND_ACK;
1453  
# Line 1465 | Line 1474 | static void DLPI_subs_bind(DLPIStream *t
1474  
1475   static void DLPI_subs_unbind(DLPIStream *the_stream, queue_t *q, mblk_t *mp)
1476   {
1477 <        dl_subs_unbind_req_t *req = (dl_subs_unbind_req_t *)mp->b_rptr;
1477 >        dl_subs_unbind_req_t *req = (dl_subs_unbind_req_t *)(void *)mp->b_rptr;
1478          uint8 *sap = ((uint8 *)req) + req->dl_subs_sap_offset;
1479          int32 length = req->dl_subs_sap_length;
1480          int32 error = 0;
# Line 1516 | Line 1525 | static void DLPI_subs_unbind(DLPIStream
1525  
1526   static void DLPI_enable_multi(DLPIStream *the_stream, queue_t *q, mblk_t *mp)
1527   {
1528 <        dl_enabmulti_req_t*     req = (dl_enabmulti_req_t*)mp->b_rptr;
1528 >        dl_enabmulti_req_t*     req = (dl_enabmulti_req_t*)(void *)mp->b_rptr;
1529          uint8 *reqaddr = (uint8 *)(mp->b_rptr + req->dl_addr_offset);
1530          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]));
1531  
# Line 1536 | Line 1545 | static void DLPI_enable_multi(DLPIStream
1545          AO_enable_multicast(reqaddr);
1546  
1547          // Add new address to multicast list
1548 <        uint8 *addr = new uint8[kEnetPhysicalAddressLength];
1548 >        uint8 *addr = Mac2HostAddr(Mac_sysalloc(kEnetPhysicalAddressLength));
1549          OTCopy48BitAddress(reqaddr, addr);
1550          the_stream->AddMulticast(addr);
1551  
# Line 1555 | Line 1564 | static void DLPI_enable_multi(DLPIStream
1564  
1565   static void DLPI_disable_multi(DLPIStream *the_stream, queue_t *q, mblk_t *mp)
1566   {
1567 <        dl_disabmulti_req_t *req = (dl_disabmulti_req_t*)mp->b_rptr;
1567 >        dl_disabmulti_req_t *req = (dl_disabmulti_req_t*)(void *)mp->b_rptr;
1568          uint8 *reqaddr = (uint8 *)(mp->b_rptr + req->dl_addr_offset);
1569          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]));
1570  
# Line 1574 | Line 1583 | static void DLPI_disable_multi(DLPIStrea
1583  
1584          // Found, then remove
1585          the_stream->RemoveMulticast(addr);
1586 <        delete addr;
1586 >        Mac_sysfree(Host2MacAddr(addr));
1587  
1588          // Tell add-on to disable multicast address
1589          AO_disable_multicast(reqaddr);
# Line 1596 | Line 1605 | static void DLPI_disable_multi(DLPIStrea
1605   static void DLPI_unit_data(DLPIStream *the_stream, queue_t *q, mblk_t *mp)
1606   {
1607          D(bug("  DLPI_unit_data(%p,%p)\n", the_stream, mp));
1608 <        dl_unitdata_req_t *req = (dl_unitdata_req_t *)mp->b_rptr;
1608 >        dl_unitdata_req_t *req = (dl_unitdata_req_t *)(void *)mp->b_rptr;
1609  
1610          // Stream must be idle
1611          if (the_stream->dlpi_state != DL_IDLE) {
# Line 1611 | Line 1620 | static void DLPI_unit_data(DLPIStream *t
1620                          return;
1621                  }
1622                  bp->b_datap->db_type = M_PROTO;
1623 <                errp = (dl_uderror_ind_t *)bp->b_wptr;
1623 >                errp = (dl_uderror_ind_t *)(void *)bp->b_wptr;
1624                  errp->dl_primitive = DL_UDERROR_IND;
1625                  errp->dl_errno = DL_OUTSTATE;
1626                  errp->dl_unix_errno = 0;

Diff Legend

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