]> git.saurik.com Git - apple/xnu.git/blame - iokit/Families/IONetworking/IOEthernetInterface.cpp
xnu-124.13.tar.gz
[apple/xnu.git] / iokit / Families / IONetworking / IOEthernetInterface.cpp
CommitLineData
1c79356b
A
1/*
2 * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
3 *
4 * @APPLE_LICENSE_HEADER_START@
5 *
6 * The contents of this file constitute Original Code as defined in and
7 * are subject to the Apple Public Source License Version 1.1 (the
8 * "License"). You may not use this file except in compliance with the
9 * License. Please obtain a copy of the License at
10 * http://www.apple.com/publicsource and read it before using this file.
11 *
12 * This Original Code and all software distributed under the License are
13 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17 * License for the specific language governing rights and limitations
18 * under the License.
19 *
20 * @APPLE_LICENSE_HEADER_END@
21 */
22/*
23 * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
24 *
25 * IOEthernetInterface.cpp
26 *
27 * HISTORY
28 * 8-Jan-1999 Joe Liu (jliu) created.
29 *
30 */
31
32#include <IOKit/assert.h>
33#include <IOKit/IOLib.h>
34#include <libkern/c++/OSData.h>
35#include <IOKit/network/IOEthernetInterface.h>
36#include <IOKit/network/IOEthernetController.h>
37#include <IOKit/network/IONetworkUserClient.h>
38
39extern "C" {
40#include <sys/param.h>
41#include <sys/errno.h>
42#include <sys/socket.h>
43#include <net/if.h>
44#include <net/etherdefs.h>
45#include <net/if_dl.h>
46#include <net/if_types.h>
47#include <sys/sockio.h>
48#include <netinet/in_var.h>
49#include <sys/malloc.h>
50void arpwhohas(struct arpcom * ac, struct in_addr * addr);
51}
52
53//---------------------------------------------------------------------------
54
55#define super IONetworkInterface
56
57OSDefineMetaClassAndStructors( IOEthernetInterface, IONetworkInterface )
58OSMetaClassDefineReservedUnused( IOEthernetInterface, 0);
59OSMetaClassDefineReservedUnused( IOEthernetInterface, 1);
60OSMetaClassDefineReservedUnused( IOEthernetInterface, 2);
61OSMetaClassDefineReservedUnused( IOEthernetInterface, 3);
62OSMetaClassDefineReservedUnused( IOEthernetInterface, 4);
63OSMetaClassDefineReservedUnused( IOEthernetInterface, 5);
64OSMetaClassDefineReservedUnused( IOEthernetInterface, 6);
65OSMetaClassDefineReservedUnused( IOEthernetInterface, 7);
66OSMetaClassDefineReservedUnused( IOEthernetInterface, 8);
67OSMetaClassDefineReservedUnused( IOEthernetInterface, 9);
68OSMetaClassDefineReservedUnused( IOEthernetInterface, 10);
69OSMetaClassDefineReservedUnused( IOEthernetInterface, 11);
70OSMetaClassDefineReservedUnused( IOEthernetInterface, 12);
71OSMetaClassDefineReservedUnused( IOEthernetInterface, 13);
72OSMetaClassDefineReservedUnused( IOEthernetInterface, 14);
73OSMetaClassDefineReservedUnused( IOEthernetInterface, 15);
74
75// The name prefix for all BSD Ethernet interfaces.
76//
77#define kIOEthernetInterfaceNamePrefix "en"
78
79//---------------------------------------------------------------------------
80// Macros
81
82#ifdef DEBUG
83#define DLOG(fmt, args...) IOLog(fmt, ## args)
84#else
85#define DLOG(fmt, args...)
86#endif
87
88UInt32 IOEthernetInterface::getFilters(const OSDictionary * dict,
89 const OSSymbol * group)
90{
91 OSNumber * num;
92 UInt32 filters = 0;
93
94 assert( dict && group );
95
96 if (( num = (OSNumber *) dict->getObject(group) ))
97 {
98 filters = num->unsigned32BitValue();
99 }
100 return filters;
101}
102
103bool IOEthernetInterface::setFilters(OSDictionary * dict,
104 const OSSymbol * group,
105 UInt32 filters)
106{
107 OSNumber * num;
108 bool ret = false;
109
110 assert( dict && group );
111
112 num = (OSNumber *) dict->getObject(group);
113 if ( num == 0 )
114 {
115 if (( num = OSNumber::withNumber(filters, 32) ))
116 {
117 ret = dict->setObject(group, num);
118 num->release();
119 }
120 }
121 else
122 {
123 num->setValue(filters);
124 ret = true;
125 }
126 return ret;
127}
128
129#define GET_REQUIRED_FILTERS(g) getFilters(_requiredFilters, (g))
130#define GET_ACTIVE_FILTERS(g) getFilters(_activeFilters, (g))
131#define GET_SUPPORTED_FILTERS(g) getFilters(_supportedFilters, (g))
132
133#define SET_REQUIRED_FILTERS(g, v) setFilters(_requiredFilters, (g), (v))
134#define SET_ACTIVE_FILTERS(g, v) setFilters(_activeFilters, (g), (v))
135
136//---------------------------------------------------------------------------
137// Initialize an IOEthernetInterface instance. Instance variables are
138// initialized, and an arpcom structure is allocated.
139
140bool IOEthernetInterface::init(IONetworkController * controller)
141{
142 // Allocate an arpcom structure, then call super::init().
143 // We expect our superclass to call getIfnet() during its init()
144 // method, so arpcom must be allocated before calling super::init().
145
146 if ( (_arpcom = (struct arpcom *) IOMalloc(sizeof(*_arpcom))) == 0 )
147 {
148 DLOG("IOEthernetInterface: arpcom allocation failed\n");
149 return false;
150 }
151
152 // Pass the init() call to our superclass.
153
154 if ( super::init(controller) == false )
155 return false;
156
157 // Add an IONetworkData with room to hold an IOEthernetStats structure.
158 // This class does not reference the data object created, and no harm
159 // is done if the data object is released or replaced.
160
161 IONetworkData * data = IONetworkData::withInternalBuffer(
162 kIOEthernetStatsKey,
163 sizeof(IOEthernetStats));
164 if (data)
165 {
166 addNetworkData(data);
167 data->release();
168 }
169
170 // Create and initialize the filter dictionaries.
171
172 _requiredFilters = OSDictionary::withCapacity(4);
173 _activeFilters = OSDictionary::withCapacity(4);
174
175 if ( (_requiredFilters == 0) || (_activeFilters == 0) )
176 return false;
177
178 _supportedFilters = OSDynamicCast(OSDictionary,
179 controller->getProperty(kIOPacketFilters));
180 if ( _supportedFilters == 0 ) return false;
181 _supportedFilters->retain();
182
183 // Controller's Unicast (directed) and Broadcast filters should always
184 // be enabled. Those bits should never be cleared.
185
186 if ( !SET_REQUIRED_FILTERS( gIONetworkFilterGroup,
187 kIOPacketFilterUnicast |
188 kIOPacketFilterBroadcast )
189 || !SET_REQUIRED_FILTERS( gIOEthernetWakeOnLANFilterGroup, 0 )
190 || !SET_ACTIVE_FILTERS( gIONetworkFilterGroup, 0 )
191 || !SET_ACTIVE_FILTERS( gIOEthernetWakeOnLANFilterGroup, 0 ) )
192 {
193 return false;
194 }
195
196 // Publish filter dictionaries to property table.
197
198 setProperty( kIORequiredPacketFilters, _requiredFilters );
199 setProperty( kIOActivePacketFilters, _activeFilters );
200
201 return true;
202}
203
204//---------------------------------------------------------------------------
205// Initialize the given ifnet structure. The argument specified is a pointer
206// to an ifnet structure obtained through getIfnet(). IOEthernetInterface
207// will initialize this structure in a manner that is appropriate for most
208// Ethernet interfaces, then call super::initIfnet() to allow the superclass
209// to perform generic interface initialization.
210//
211// ifp: Pointer to the ifnet structure to be initialized.
212//
213// Returns true on success, false otherwise.
214
215bool IOEthernetInterface::initIfnet(struct ifnet * ifp)
216{
217 struct arpcom * ac = (struct arpcom *) ifp;
218
219 assert(ac);
220
221 lock();
222
223 bzero(ac, sizeof(*ac));
224
225 // Set defaults suitable for Ethernet interfaces.
226
227 setInterfaceType( IFT_ETHER );
228 setMaxTransferUnit( ETHERMTU );
229 setMediaAddressLength( NUM_EN_ADDR_BYTES );
230 setMediaHeaderLength( ETHERHDRSIZE );
231 setFlags( IFF_BROADCAST | IFF_SIMPLEX | IFF_NOTRAILERS );
232
233 unlock();
234
235 return super::initIfnet(ifp);
236}
237
238//---------------------------------------------------------------------------
239// Free the IOEthernetInterface instance. The memory allocated
240// for the arpcom structure is released.
241
242void IOEthernetInterface::free()
243{
244 if ( _arpcom )
245 {
246 IOFree(_arpcom, sizeof(*_arpcom));
247 _arpcom = 0;
248 }
249
250 if ( _requiredFilters )
251 {
252 _requiredFilters->release();
253 _requiredFilters = 0;
254 }
255
256 if ( _activeFilters )
257 {
258 _activeFilters->release();
259 _activeFilters = 0;
260 }
261
262 if ( _supportedFilters )
263 {
264 _supportedFilters->release();
265 _supportedFilters = 0;
266 }
267
268 super::free();
269}
270
271//---------------------------------------------------------------------------
272// This method returns a pointer to an ifnet structure maintained
273// by the family specific interface object. IOEthernetInterface
274// allocates an arpcom structure in init(), and returns a pointer
275// to that structure when this method is called.
276//
277// Returns a pointer to an ifnet structure.
278
279struct ifnet * IOEthernetInterface::getIfnet() const
280{
281 return (&(_arpcom->ac_if));
282}
283
284//---------------------------------------------------------------------------
285// The name of the interface advertised to the network layer
286// is generated by concatenating the string returned by this method,
287// and an unit number.
288//
289// Returns a pointer to a constant string "en". Thus Ethernet interfaces
290// will be registered as en0, en1, etc.
291
292const char * IOEthernetInterface::getNamePrefix() const
293{
294 return kIOEthernetInterfaceNamePrefix;
295}
296
297//---------------------------------------------------------------------------
298// Prepare the 'Ethernet' controller after it has been opened. This is called
299// by IONetworkInterface after a controller has accepted an open from this
300// interface. IOEthernetInterface uses this method to inspect the controller,
301// and to cache certain controller properties, such as its hardware address.
302// This method is called with the arbitration lock held.
303//
304// controller: The controller object that was opened.
305//
306// Returns true on success, false otherwise
307// (which will cause the controller to be closed).
308
309bool IOEthernetInterface::controllerDidOpen(IONetworkController * ctr)
310{
311 bool ret = false;
312 OSData * addrData;
313 IOEthernetAddress * addr;
314
315 do {
316 // Call the controllerDidOpen() in superclass first.
317
318 if ( (ctr == 0) || (super::controllerDidOpen(ctr) == false) )
319 break;
320
321 // If the controller supports some form of multicast filtering,
322 // then set the ifnet IFF_MULTICAST flag.
323
324 if ( GET_SUPPORTED_FILTERS(gIONetworkFilterGroup) &
325 (kIOPacketFilterMulticast | kIOPacketFilterMulticastAll) )
326 {
327 setFlags(IFF_MULTICAST);
328 }
329
330 // Get the controller's MAC/Ethernet address.
331
332 addrData = OSDynamicCast(OSData, ctr->getProperty(kIOMACAddress));
333 if ( (addrData == 0) || (addrData->getLength() != NUM_EN_ADDR_BYTES) )
334 {
335 DLOG("%s: kIOMACAddress property access error (len %d)\n",
336 getName(), addrData ? addrData->getLength() : 0);
337 break;
338 }
339
340 addr = (IOEthernetAddress *) addrData->getBytesNoCopy();
341
342#if 1 // Print the address
343 IOLog("%s: Ethernet address %02x:%02x:%02x:%02x:%02x:%02x\n",
344 ctr->getName(),
345 addr->bytes[0],
346 addr->bytes[1],
347 addr->bytes[2],
348 addr->bytes[3],
349 addr->bytes[4],
350 addr->bytes[5]);
351#endif
352
353 // Copy the hardware address we obtained from the controller
354 // to the arpcom structure.
355
356 bcopy(addr, _arpcom->ac_enaddr, NUM_EN_ADDR_BYTES);
357
358 ret = true;
359 }
360 while (0);
361
362 return ret;
363}
364
365//---------------------------------------------------------------------------
366// When a close from our last client is received, the interface will
367// close the controller. But before the controller is closed, this method
368// will be called by our superclass to perform any final cleanup. This
369// method is called with the arbitration lock held.
370//
371// IOEthernetInterface will ensure that the controller is disabled.
372//
373// controller: The currently opened controller object.
374
375void IOEthernetInterface::controllerWillClose(IONetworkController * ctr)
376{
377 super::controllerWillClose(ctr);
378}
379
380//---------------------------------------------------------------------------
381// Handle ioctl commands originated from the network layer.
382// Commands not handled by this method are passed to our superclass.
383//
384// Argument convention is:
385//
386// arg0 - (struct ifnet *)
387// arg1 - (void *)
388//
389// The commands handled by IOEthernetInterface are:
390//
391// SIOCSIFADDR
392// SIOCSIFFLAGS
393// SIOCADDMULTI
394// SIOCDELMULTI
395//
396// Returns an error code defined in errno.h (BSD).
397
398SInt32 IOEthernetInterface::performCommand( IONetworkController * ctr,
399 UInt32 cmd,
400 void * arg0,
401 void * arg1 )
402{
403 SInt32 ret;
404
405 assert( arg0 == _arpcom );
406
407 if ( ctr == 0 ) return EINVAL;
408
409 switch ( cmd )
410 {
411 case SIOCSIFFLAGS:
412 case SIOCADDMULTI:
413 case SIOCDELMULTI:
414 case SIOCSIFADDR:
415
416 ret = (int) ctr->executeCommand(
417 this, /* client */
418 (IONetworkController::Action)
419 &IOEthernetInterface::performGatedCommand,
420 this, /* target */
421 ctr, /* param0 */
422 (void *) cmd, /* param1 */
423 arg0, /* param2 */
424 arg1 ); /* param3 */
425 break;
426
427 default:
428 // Unknown command, let our superclass deal with it.
429 ret = super::performCommand(ctr, cmd, arg0, arg1);
430 break;
431 }
432
433 return ret;
434}
435
436//---------------------------------------------------------------------------
437// Handle an ioctl command on the controller's workloop context.
438
439int IOEthernetInterface::performGatedCommand(void * target,
440 void * arg1_ctr,
441 void * arg2_cmd,
442 void * arg3_0,
443 void * arg4_1)
444{
445 IOEthernetInterface * self = (IOEthernetInterface *) target;
446 IONetworkController * ctr = (IONetworkController *) arg1_ctr;
447 SInt ret = EOPNOTSUPP;
448
449 // Refuse to perform controller I/O if the controller is in a
450 // low-power state that makes it "unusable".
451
452 if ( self->_controllerLostPower ) return EPWROFF;
453
454 self->lock();
455
456 switch ( (UInt32) arg2_cmd )
457 {
458 case SIOCSIFADDR:
459 ret = self->syncSIOCSIFADDR(ctr);
460 break;
461
462 case SIOCSIFFLAGS:
463 ret = self->syncSIOCSIFFLAGS(ctr);
464 break;
465
466 case SIOCADDMULTI:
467 ret = self->syncSIOCADDMULTI(ctr);
468 break;
469
470 case SIOCDELMULTI:
471 ret = self->syncSIOCDELMULTI(ctr);
472 break;
473 }
474
475 self->unlock();
476
477 return ret;
478}
479
480//---------------------------------------------------------------------------
481// enableController() is reponsible for calling the controller's enable()
482// method and restoring the state of the controller. We assume that
483// controllers can completely reset its state upon receiving a disable()
484// method call. And when it is brought back up, the interface should
485// assist in restoring the previous state of the Ethernet controller.
486
487IOReturn IOEthernetInterface::enableController(IONetworkController * ctr)
488{
489 IOReturn ret = kIOReturnSuccess;
490 bool enabled = false;
491 UInt32 filters;
492
493 assert(ctr);
494
495 do {
496 // Is controller already enabled? If so, exit and return success.
497
498 if ( _ctrEnabled )
499 break;
500
501 // Send the controller an enable command.
502
503 if ( (ret = ctr->enable((IOService *) this)) != kIOReturnSuccess )
504 break; // unable to enable the controller.
505
506 enabled = true;
507
508 // Disable all Wake-On-LAN filters.
509
510 filters = GET_ACTIVE_FILTERS(gIOEthernetWakeOnLANFilterGroup);
511
512 for (UInt i = 0; i < (sizeof(filters) * 8); i++)
513 {
514 if ((1 << i) & filters)
515 {
516 disableFilter(ctr, gIOEthernetWakeOnLANFilterGroup,
517 (1 << i));
518 }
519 }
520
521 // Restore current filter selection.
522
523 SET_ACTIVE_FILTERS(gIONetworkFilterGroup, 0);
524 filters = GET_REQUIRED_FILTERS(gIONetworkFilterGroup);
525
526 for (UInt i = 0; i < (sizeof(filters) * 8); i++)
527 {
528 if ((1 << i) & filters)
529 {
530 if ( (ret = enableFilter(ctr, gIONetworkFilterGroup,
531 (1 << i)))
532 != kIOReturnSuccess )
533 break;
534 }
535 }
536 if ( ret != kIOReturnSuccess )
537 break;
538
539 // Restore multicast filter settings.
540
541 syncSIOCADDMULTI(ctr);
542
543 _ctrEnabled = true;
544
545 } while (false);
546
547 // Disable the controller if a serious error has occurred after the
548 // controller has been enabled.
549
550 if ( enabled && (ret != kIOReturnSuccess) )
551 {
552 ctr->disable((IOService *) this);
553 }
554
555 return ret;
556}
557
558//---------------------------------------------------------------------------
559// Handles SIOCSIFFLAGS ioctl command for Ethernet interfaces. The network
560// stack has changed the if_flags field in ifnet. Our job is to go
561// through if_flags and see what has changed, and act accordingly.
562//
563// The fact that if_flags contains both generic and Ethernet specific bits
564// means that we cannot move some of the default flag processing to the
565// superclass.
566
567int IOEthernetInterface::syncSIOCSIFFLAGS(IONetworkController * ctr)
568{
569 UInt16 flags = getFlags();
570 IOReturn ret = kIOReturnSuccess;
571
572 if ( ( ((flags & IFF_UP) == 0) || _controllerLostPower ) &&
573 ( flags & IFF_RUNNING ) )
574 {
575 // If interface is marked down and it is currently running,
576 // then stop it.
577
578 ctr->disable((IOService *) this);
579 flags &= ~IFF_RUNNING;
580 _ctrEnabled = false;
581 }
582 else if ( ( flags & IFF_UP ) &&
583 ( _controllerLostPower == false ) &&
584 ((flags & IFF_RUNNING) == 0) )
585 {
586 // If interface is marked up and it is currently stopped,
587 // then start it.
588
589 if ( (ret = enableController(ctr)) == kIOReturnSuccess )
590 flags |= IFF_RUNNING;
591 }
592
593 if ( flags & IFF_RUNNING )
594 {
595 IOReturn rc;
596
597 // We don't expect multiple flags to be changed for a given
598 // SIOCSIFFLAGS call.
599
600 // Promiscuous mode
601
602 rc = (flags & IFF_PROMISC) ?
603 enableFilter(ctr, gIONetworkFilterGroup,
604 kIOPacketFilterPromiscuous) :
605 disableFilter(ctr, gIONetworkFilterGroup,
606 kIOPacketFilterPromiscuous);
607
608 if (ret == kIOReturnSuccess) ret = rc;
609
610 // Multicast-All mode
611
612 rc = (flags & IFF_ALLMULTI) ?
613 enableFilter(ctr, gIONetworkFilterGroup,
614 kIOPacketFilterMulticastAll) :
615 disableFilter(ctr, gIONetworkFilterGroup,
616 kIOPacketFilterMulticastAll);
617
618 if (ret == kIOReturnSuccess) ret = rc;
619 }
620
621 // Update the flags field to pick up any modifications. Also update the
622 // property table to reflect any flag changes.
623
624 setFlags(flags, ~flags);
625
626 return errnoFromReturn(ret);
627}
628
629//---------------------------------------------------------------------------
630// Handles SIOCSIFADDR ioctl.
631
632SInt IOEthernetInterface::syncSIOCSIFADDR(IONetworkController * ctr)
633{
634 IOReturn ret = kIOReturnSuccess;
635
636 // Interface is implicitly brought up by an SIOCSIFADDR ioctl.
637
638 setFlags(IFF_UP);
639
640 if ( (getFlags() & IFF_RUNNING) == 0 )
641 {
642 if ( (ret = enableController(ctr)) == kIOReturnSuccess )
643 setFlags(IFF_RUNNING);
644 }
645
646 return errnoFromReturn(ret);
647}
648
649//---------------------------------------------------------------------------
650// Handle SIOCADDMULTI ioctl command.
651
652SInt IOEthernetInterface::syncSIOCADDMULTI(IONetworkController * ctr)
653{
654 IOReturn ret;
655
656 // Make sure multicast filter is active.
657
658 ret = enableFilter(ctr, gIONetworkFilterGroup, kIOPacketFilterMulticast);
659
660 if ( ret == kIOReturnSuccess )
661 {
662 // Load multicast addresses only if the filter was activated.
663
664 ret = setupMulticastFilter(ctr);
665
666 // If the list is now empty, then deactivate the multicast filter.
667
668 if ( _mcAddrCount == 0 )
669 {
670 IOReturn dret = disableFilter(ctr, gIONetworkFilterGroup,
671 kIOPacketFilterMulticast);
672
673 if (ret == kIOReturnSuccess) ret = dret;
674 }
675 }
676
677 return errnoFromReturn(ret);
678}
679
680//---------------------------------------------------------------------------
681// Handle SIOCDELMULTI ioctl command.
682
683SInt IOEthernetInterface::syncSIOCDELMULTI(IONetworkController * ctr)
684{
685 return syncSIOCADDMULTI(ctr);
686}
687
688//---------------------------------------------------------------------------
689// Enable a packet filter.
690
691IOReturn
692IOEthernetInterface::enableFilter(IONetworkController * ctr,
693 const OSSymbol * group,
694 UInt32 filter,
695 IOOptionBits options = 0)
696{
697 IOReturn ret;
698 UInt32 reqFilters;
699 UInt32 actFilters;
700
701 // If the controller does not support the packet filter,
702 // there's no need to proceed.
703
704 if (( GET_SUPPORTED_FILTERS(group) & filter ) == 0)
705 return kIOReturnUnsupported;
706
707 do {
708 // Add specified filter to the set of required filters.
709
710 reqFilters = GET_REQUIRED_FILTERS(group) | filter;
711 SET_REQUIRED_FILTERS(group, reqFilters);
712
713 // Abort if no changes are needed.
714
715 ret = kIOReturnSuccess;
716
717 actFilters = GET_ACTIVE_FILTERS(group);
718
719 if ( (( actFilters ^ reqFilters ) & filter) == 0 )
720 break;
721
722 // Send a command to the controller driver.
723
724 ret = ctr->enablePacketFilter(group, filter, actFilters, options);
725
726 if ( ret == kIOReturnSuccess )
727 {
728 SET_ACTIVE_FILTERS(group, actFilters | filter);
729 }
730 }
731 while (false);
732
733 return ret;
734}
735
736//---------------------------------------------------------------------------
737// Disable a packet filter.
738
739IOReturn
740IOEthernetInterface::disableFilter(IONetworkController * ctr,
741 const OSSymbol * group,
742 UInt32 filter,
743 IOOptionBits options = 0)
744{
745 IOReturn ret;
746 UInt32 reqFilters;
747 UInt32 actFilters;
748
749 do {
750 // Remove specified filter from the set of required filters.
751
752 reqFilters = GET_REQUIRED_FILTERS(group) & ~filter;
753 SET_REQUIRED_FILTERS(group, reqFilters);
754
755 // Abort if no changes are needed.
756
757 ret = kIOReturnSuccess;
758
759 actFilters = GET_ACTIVE_FILTERS(group);
760
761 if ( (( actFilters ^ reqFilters ) & filter) == 0 )
762 break;
763
764 // Send a command to the controller driver.
765
766 ret = ctr->disablePacketFilter(group, filter, actFilters, options);
767
768 if ( ret == kIOReturnSuccess )
769 {
770 SET_ACTIVE_FILTERS(group, actFilters & ~filter);
771 }
772 }
773 while (false);
774
775 return ret;
776}
777
778//---------------------------------------------------------------------------
779// Cache the list of multicast addresses and send a command to the
780// controller to update the multicast list.
781
782IOReturn
783IOEthernetInterface::setupMulticastFilter(IONetworkController * ctr)
784{
785 void * multiAddrs = 0;
786 UInt mcount;
787 OSData * mcData = 0;
788 struct ifnet * ifp = (struct ifnet *) _arpcom;
789 struct ifmultiaddr * ifma;
790 IOReturn ret = kIOReturnSuccess;
791 bool ok;
792
793 assert(ifp);
794
795 // Update the multicast addresses count ivar.
796
797 mcount = 0;
798 for (ifma = ifp->if_multiaddrs.lh_first;
799 ifma != NULL;
800 ifma = ifma->ifma_link.le_next)
801 {
802 if ((ifma->ifma_addr->sa_family == AF_UNSPEC) ||
803 (ifma->ifma_addr->sa_family == AF_LINK))
804 mcount++;
805 }
806 _mcAddrCount = mcount;
807
808 if ( mcount )
809 {
810 char * addrp;
811
812 mcData = OSData::withCapacity(mcount * NUM_EN_ADDR_BYTES);
813 if (!mcData)
814 {
815 DLOG("%s: no memory for multicast address list\n", getName());
816 return kIOReturnNoMemory;
817 }
818
819 // Loop through the linked multicast structures and write the
820 // address to the OSData.
821
822 for (ifma = ifp->if_multiaddrs.lh_first;
823 ifma != NULL;
824 ifma = ifma->ifma_link.le_next)
825 {
826 if (ifma->ifma_addr->sa_family == AF_UNSPEC)
827 addrp = &ifma->ifma_addr->sa_data[0];
828 else
829 if (ifma->ifma_addr->sa_family == AF_LINK)
830 addrp = LLADDR((struct sockaddr_dl *) ifma->ifma_addr);
831 else
832 continue;
833
834 ok = mcData->appendBytes((const void *) addrp, NUM_EN_ADDR_BYTES);
835 assert(ok);
836 }
837
838 multiAddrs = (void *) mcData->getBytesNoCopy();
839 assert(multiAddrs);
840 }
841
842 // Issue a controller command to setup the multicast filter.
843
844 ret = ((IOEthernetController *)ctr)->setMulticastList(
845 (IOEthernetAddress *) multiAddrs,
846 mcount);
847 if (mcData)
848 {
849 if (ret == kIOReturnSuccess)
850 setProperty(kIOMulticastAddressList, mcData);
851
852 mcData->release();
853 }
854 else {
855 removeProperty(kIOMulticastAddressList);
856 }
857
858 return ret;
859}
860
861//---------------------------------------------------------------------------
862// Power management support.
863//
864// Handlers called, with the controller's gate closed, in response to a
865// controller power state change.
866
867IOReturn
868IOEthernetInterface::controllerWillChangePowerState(
869 IONetworkController * ctr,
870 IOPMPowerFlags flags,
871 UInt32 stateNumber,
872 IOService * policyMaker )
873{
874 if ( ( (flags & IOPMDeviceUsable ) == 0) &&
875 ( _controllerLostPower == false ) )
876 {
877 _controllerLostPower = true;
878
879 // Enable Magic Packet if supported.
880
881 if ( GET_SUPPORTED_FILTERS(gIOEthernetWakeOnLANFilterGroup) &
882 kIOEthernetWakeOnMagicPacket )
883 {
884 enableFilter(ctr, gIOEthernetWakeOnLANFilterGroup,
885 kIOEthernetWakeOnMagicPacket);
886 }
887
888 // Set _controllerLostPower, then call the SIOCSIFFLAGS handler to
889 // disable the controller, then mark the interface as Not Running.
890
891 syncSIOCSIFFLAGS(ctr);
892 }
893
894 return super::controllerWillChangePowerState( ctr, flags,
895 stateNumber,
896 policyMaker );
897}
898
899IOReturn
900IOEthernetInterface::controllerDidChangePowerState(
901 IONetworkController * ctr,
902 IOPMPowerFlags flags,
903 UInt32 stateNumber,
904 IOService * policyMaker )
905{
906 IOReturn ret = super::controllerDidChangePowerState( ctr, flags,
907 stateNumber,
908 policyMaker );
909
910 if ( ( flags & IOPMDeviceUsable ) && ( _controllerLostPower == true ) )
911 {
912 _controllerLostPower = false;
913
914 // Clear _controllerLostPower, then call the SIOCSIFFLAGS handler to
915 // perhaps enable the controller, restore all Ethernet controller
916 // state, then mark the interface as Running.
917
918 syncSIOCSIFFLAGS(ctr);
919 }
920
921 return ret;
922}