![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IOEthernetController.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Families / IONetworking|
Return to IOEthernetController.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Families / IONetworking |
1.1 root 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: * IOEthernetController.cpp
26: *
27: * Abstract Ethernet controller superclass.
28: *
29: * HISTORY
30: *
31: * Dec 3, 1998 jliu - C++ conversion.
32: */
33:
34: #include <IOKit/assert.h>
35: #include <IOKit/network/IOEthernetController.h>
36: #include <IOKit/network/IOEthernetInterface.h>
37:
38: //---------------------------------------------------------------------------
39:
40: #define super IONetworkController
41:
42: OSDefineMetaClass( IOEthernetController, IONetworkController )
43:
44: OSDefineAbstractStructors( IOEthernetController, IONetworkController )
45:
46: //-------------------------------------------------------------------------
47: // Macros
48:
49: #ifdef DEBUG
50: #define DLOG(fmt, args...) IOLog(fmt, ## args)
51: #else
52: #define DLOG
53: #endif
54:
55: // Define SYNC_REQ macro to simplify syncRequest() calls.
56: //
57: #define SYNC_REQ(sender, action, ret, args...) \
58: syncRequest(sender, this, (IONetworkAction) action, (UInt32 *) ret, \
59: ## args)
60:
61: #define DO_SYNC_REQ(action, args...) \
62: { \
63: IOReturn ret = kIOReturnNotReady; \
64: syncRequest(client, this, \
65: (RequestAction) &IOEthernetController:: ## action, \
66: (UInt32 *) &ret, ## args); \
67: return ret; \
68: }
69:
70: //---------------------------------------------------------------------------
71: // Initialize an IOEthernetController instance.
72:
73: bool IOEthernetController::init(OSDictionary * properties)
74: {
75: if (!super::init(properties))
76: {
77: DLOG("IOEthernetController: super::init() failed\n");
78: return false;
79: }
80:
81: _mcMode = kIOEnetMulticastModeOff;
82: _prMode = kIOEnetPromiscuousModeOff;
83:
84: return true;
85: }
86:
87: //---------------------------------------------------------------------------
88: // Frees the IOEthernetController instance.
89:
90: void IOEthernetController::free()
91: {
92: super::free();
93: }
94:
95: //---------------------------------------------------------------------------
96: // Publish Ethernet specific properties to the property
97: // table. For instance, getHardwareAddress() is called to fetch the
98: // hardware address. This method is called by the superclass and
99: // should never be called by drivers.
100: //
101: // Returns true if all capabilities were discovered and published
102: // successfully, false otherwise. Returning false will prevent client
103: // objects from attaching to the Ethernet controller since a property
104: // that a client depends on may be missing
105:
106: bool IOEthernetController::publishCapabilities()
107: {
108: bool ret = false;
109: enet_addr_t addr;
110:
111: if (!super::publishCapabilities())
112: return false;
113:
114: // Publish the controller's MAC address. The Ethernet interface
115: // object will also publish this attribute, but the idea is that
116: // the controller will always publish the initial address read
117: // from the hardware, and it will remain static. While the
118: // address recorded by the interface may change if for instance
119: // a setHardwareAddress() is accepted by the controller.
120:
121: if (getHardwareAddress(&addr) == kIOReturnSuccess)
122: ret = setProperty(kIOMACAddress, (void *) &addr, NUM_EN_ADDR_BYTES);
123:
124: return ret;
125: }
126:
127: //---------------------------------------------------------------------------
128: // Called when a client wishes to change the unicast address used
129: // by the controller's hardware filter. Implementation of this method is
130: // optional.
131: //
132: // addr: Pointer to an enet_addr_t containing the new Ethernet address.
133: //
134: // Returns kIOReturnUnsupported. Drivers that implement this method
135: // must return an appropriate return code.
136:
137: IOReturn IOEthernetController::setHardwareAddress(const enet_addr_t * /*addr*/)
138: {
139: return kIOReturnUnsupported;
140: }
141:
142: //---------------------------------------------------------------------------
143: // Called by enablePacketFilters() when the controller's multicast filter
144: // mode needs to be changed. See IOEnetMulticastMode for the list of defined
145: // modes.
146: //
147: // mode: The new multicast filter mode.
148: //
149: // Returns kIOReturnUnsupported. Drivers must return kIOReturnSuccess to
150: // indicate success, or an error otherwise.
151:
152: IOReturn IOEthernetController::setMulticastMode(IOEnetMulticastMode /*mode*/)
153: {
154: return kIOReturnUnsupported;
155: }
156:
157: //---------------------------------------------------------------------------
158: // Called by an interface client when its multicast group membership changes.
159: // Drivers that support multicasting should override this method and update
160: // the hardware filter using the address list provided.
161: //
162: // Perfect multicast filtering is preferred if supported by the hardware,
163: // in order to reduce the number of unwanted packets that are received.
164: // If the number of multicast addresses in the list exceed the limit
165: // set by the hardware, or if perfect filtering is not supported,
166: // then ideally the hardware should be programmed to perform imperfect
167: // filtering, perhaps through a hash table built by the driver.
168: //
169: // This method may be called only if getPacketFilters()
170: // reports that kIOPacketFilterMulticast is supported.
171: //
172: // addrs: Pointer to a list of multicast addresses. Not valid if
173: // the count argument is 0.
174: // count: The number of multicast addresses in the list. May be zero
175: // if the list is empty.
176: //
177: // Returns kIOReturnUnsupported. Drivers must return kIOReturnSuccess to
178: // indicate success, or an error otherwise.
179:
180: IOReturn IOEthernetController::setMulticastList(enet_addr_t * /*addrs*/,
181: UInt /*count*/)
182: {
183: return kIOReturnUnsupported;
184: }
185:
186: //---------------------------------------------------------------------------
187: // Called by enablePacketFilters() when the controller's promiscuous filter
188: // mode needs to be changed. See IOEnetPromiscuousMode for the list of defined
189: // modes.
190: //
191: // mode: The new promiscuous filter mode.
192: //
193: // Returns kIOReturnUnsupported. Drivers must return kIOReturnSuccess to
194: // indicate success, or an error otherwise.
195:
196: IOReturn IOEthernetController::setPromiscuousMode(IOEnetPromiscuousMode /*m*/)
197: {
198: return kIOReturnUnsupported;
199: }
200:
201: //---------------------------------------------------------------------------
202: // Report Ethernet family specific feature set.
203:
204: UInt32 IOEthernetController::getFamilyFeatureSet() const
205: {
206: return 0;
207: }
208:
209: //---------------------------------------------------------------------------
210: // Allocate and return a new IOEthernetInterface instance. The controller
211: // class from each network family must implement this method inherited from
212: // IONetworkController to return the corresponding interface object when
213: // attachInterface() is called. Subclasses of IOEthernetController
214: // (Ethernet drivers) have little reason to override this implementation.
215: //
216: // Returns the allocated and initialized IOEthernetInterface instance.
217:
218: IONetworkInterface * IOEthernetController::createInterface()
219: {
220: IOEthernetInterface * enetIf = new IOEthernetInterface;
221:
222: if (enetIf && !enetIf->init())
223: {
224: enetIf->release();
225: enetIf = 0;
226: }
227: return enetIf;
228: }
229:
230: //---------------------------------------------------------------------------
231: // Returns all the packet filters supported by the Ethernet controller.
232: // See IONetworkController for the list of packet filters.
233: // This method will perform a bitwise OR of:
234: //
235: // kIOPacketFilterUnicast
236: // kIOPacketFilterBroadcast
237: // kIOPacketFilterMulticast
238: // kIOPacketFilterPromiscuous
239: //
240: // and write the result to the integer pointed by 'filtersP'. Drivers that
241: // support a different set of filters should override this method.
242: //
243: // Returns kIOReturnSuccess. Drivers that override this method must return
244: // kIOReturnSuccess to indicate success, or an error otherwise.
245:
246: IOReturn IOEthernetController::getPacketFilters(UInt32 * filters)
247: {
248: *filters = (kIOPacketFilterUnicast |
249: kIOPacketFilterBroadcast |
250: kIOPacketFilterMulticast |
251: kIOPacketFilterPromiscuous);
252:
253: return kIOReturnSuccess;
254: }
255:
256: //---------------------------------------------------------------------------
257: // Called by an interface object to change the set of packet filters that
258: // are enabled by the controller. The implementation in IOEthernetController
259: // will trap any changes to multicast or promiscuous filters and translate
260: // the changes into a filter mode for setMulticastMode() and
261: // setPromiscuousMode() methods. This is done strictly as a convenience for
262: // drivers, which may choose to override this method to handle the filter
263: // changes directly. Unicast and Broadcast filters are assumed to be always
264: // enabled, no driver intervention is required.
265: //
266: // filters: Each bit set indicates a particular filter that should be
267: // enabled. Filter bits that are not turned on must be disabled.
268: // activeFiltersP: Updated by this method to reflect the real set
269: // of active filters. Ideally, it should be the same as
270: // the set specified by the first argument.
271: //
272: // Returns kIOReturnSuccess for success, otherwise an error code is returned.
273:
274: IOReturn IOEthernetController::enablePacketFilters(UInt32 filters,
275: UInt32 * activeFiltersP)
276: {
277: IOEnetMulticastMode mcMode;
278: IOEnetPromiscuousMode prMode;
279: IOReturn ret = kIOReturnSuccess;
280: IOReturn err;
281:
282: #define ACTIVATE_FILTERS(x) (*activeFiltersP |= (filters & (x)))
283:
284: *activeFiltersP = 0;
285:
286: // Assume Unicast and Broadcast filters are always active.
287: //
288: if (filters & (kIOPacketFilterUnicast | kIOPacketFilterBroadcast))
289: ACTIVATE_FILTERS(kIOPacketFilterUnicast | kIOPacketFilterBroadcast);
290:
291: // Update multicast mode. Avoid redundant mode transitions by
292: // caching the last successful multicast mode.
293: //
294: if (filters & kIOPacketFilterMulticastAll)
295: mcMode = kIOEnetMulticastModeAll;
296: else if (filters & kIOPacketFilterMulticast)
297: mcMode = kIOEnetMulticastModeFilter;
298: else
299: mcMode = kIOEnetMulticastModeOff;
300:
301: if (mcMode != _mcMode)
302: {
303: err = setMulticastMode(mcMode);
304: if (err == kIOReturnSuccess)
305: {
306: _mcMode = mcMode;
307: ACTIVATE_FILTERS(kIOPacketFilterMulticastAll |
308: kIOPacketFilterMulticast);
309: }
310: else {
311: _mcMode = kIOEnetMulticastModeOff;
312: ret = err;
313: }
314: }
315: else {
316: ACTIVATE_FILTERS(kIOPacketFilterMulticastAll |
317: kIOPacketFilterMulticast);
318: }
319:
320: // Update promiscuous mode. Avoid redundant mode transitions by
321: // caching the last successful promiscuous mode.
322: //
323: if (filters & kIOPacketFilterPromiscuousAll)
324: prMode = kIOEnetPromiscuousModeAll;
325: else if (filters & kIOPacketFilterPromiscuous)
326: prMode = kIOEnetPromiscuousModeOn;
327: else
328: prMode = kIOEnetPromiscuousModeOff;
329:
330: if (prMode != _prMode)
331: {
332: err = setPromiscuousMode(prMode);
333: if (err == kIOReturnSuccess)
334: {
335: _prMode = prMode;
336: ACTIVATE_FILTERS(kIOPacketFilterPromiscuousAll |
337: kIOPacketFilterPromiscuous);
338: }
339: else {
340: _prMode = kIOEnetPromiscuousModeOff;
341: ret = err;
342: }
343: }
344: else {
345: ACTIVATE_FILTERS(kIOPacketFilterPromiscuousAll |
346: kIOPacketFilterPromiscuous);
347: }
348:
349: return ret;
350: }
351:
352: //---------------------------------------------------------------------------
353: // Call getHardwareAddress() through syncRequest(). See getHardwareAddress().
354:
355: IOReturn
356: IOEthernetController::doGetHardwareAddress(IOService * client,
357: enet_addr_t * addr)
358: {
359: DO_SYNC_REQ(getHardwareAddress, (void *) addr)
360: }
361:
362: //---------------------------------------------------------------------------
363: // Call setHardwareAddress() through syncRequest(). See setHardwareAddress().
364:
365: IOReturn
366: IOEthernetController::doSetHardwareAddress(IOService * client,
367: const enet_addr_t * addr)
368: {
369: DO_SYNC_REQ(setHardwareAddress, (void *) addr)
370: }
371:
372: //---------------------------------------------------------------------------
373: // Call setMulticastList() through syncRequest(). See setMulticastList().
374:
375: IOReturn
376: IOEthernetController::doSetMulticastList(IOService * client,
377: enet_addr_t * addrs,
378: UInt count)
379: {
380: DO_SYNC_REQ(setMulticastList, (void *) addrs, (void *) count)
381: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.