![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IONetworkMedium.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 IONetworkMedium.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: * IONetworkMedium.cpp
26: *
27: * HISTORY
28: *
29: */
30:
31: #include <IOKit/assert.h>
32: #include <IOKit/IOLib.h>
33: #include <libkern/c++/OSObject.h>
34: #include <libkern/c++/OSData.h>
35: #include <libkern/c++/OSCollectionIterator.h>
36: #include <libkern/c++/OSDictionary.h>
37: #include <libkern/c++/OSSerialize.h>
38: #include <IOKit/network/IONetworkMedium.h>
39:
40: //---------------------------------------------------------------------------
41: // OSMetaClass macros.
42:
43: #define super OSObject
44: OSDefineMetaClassAndStructors( IONetworkMedium, OSObject )
45:
46: //---------------------------------------------------------------------------
47: // Initialize an IONetworkMedium instance.
48: //
49: // type: The medium type, the fields are encoded with bits defined in
50: // IONetworkMedium.h.
51: //
52: // speed: The maximum (or the only) link speed supported over this medium
53: // in units of bits per second.
54: //
55: // flags: An optional flag for the medium object.
56: // See IONetworkMedium.h for defined flags.
57: //
58: // index: An optional 32-bit index assigned by the caller. Drivers can use
59: // this to store an index or a pointer to a media table inside the
60: // driver, or it may map to a driver defined media type.
61: //
62: // name: An name to assign to this medium object. If 0, then a name
63: // will be created based on the medium type given using nameForType().
64: //
65: // Returns true on success, false otherwise.
66:
67: bool IONetworkMedium::init(IOMediumType type,
68: UInt64 speed,
69: UInt32 flags = 0,
70: UInt32 index = 0,
71: const char * name = 0)
72: {
73: if (!super::init())
74: return false;
75:
76: _desc = (IOMediumDescriptor *) IOMalloc(sizeof(*_desc));
77: if (!_desc)
78: return false;
79: bzero(_desc, sizeof(*_desc));
80:
81: _desc->type = type;
82: _desc->flags = flags;
83: _desc->speed = speed;
84: _desc->data = index;
85:
86: if (name)
87: _name = OSSymbol::withCString(name);
88: else
89: _name = IONetworkMedium::nameForType(type);
90:
91: if (!_name)
92: return false;
93:
94: return true;
95: }
96:
97: //---------------------------------------------------------------------------
98: // Factory method which performs allocation and initialization
99: // of an IONetworkMedium instance.
100: //
101: // Returns an IONetworkMedium instance on success, or 0 otherwise.
102:
103: IONetworkMedium * IONetworkMedium::medium(IOMediumType type,
104: UInt64 speed,
105: UInt32 flags = 0,
106: UInt32 index = 0,
107: const char * name = 0)
108: {
109: IONetworkMedium * medium = new IONetworkMedium;
110:
111: if (medium && !medium->init(type, speed, flags, index, name))
112: {
113: medium->release();
114: medium = 0;
115: }
116:
117: return medium;
118: }
119:
120: //---------------------------------------------------------------------------
121: // Free the IONetworkMedium instance.
122:
123: void IONetworkMedium::free()
124: {
125: if (_name)
126: _name->release();
127: if (_desc)
128: IOFree(_desc, sizeof(*_desc));
129:
130: super::free();
131: }
132:
133: //---------------------------------------------------------------------------
134: // Return the assigned medium type.
135:
136: IOMediumType IONetworkMedium::getType() const
137: {
138: return _desc->type;
139: }
140:
141: //---------------------------------------------------------------------------
142: // Return the medium flags.
143:
144: UInt32 IONetworkMedium::getFlags() const
145: {
146: return _desc->flags;
147: }
148:
149: //---------------------------------------------------------------------------
150: // Return the maximum medium speed.
151:
152: UInt64 IONetworkMedium::getSpeed() const
153: {
154: return _desc->speed;
155: }
156:
157: //---------------------------------------------------------------------------
158: // Return the assigned index.
159:
160: UInt32 IONetworkMedium::getIndex() const
161: {
162: return _desc->data;
163: }
164:
165: //---------------------------------------------------------------------------
166: // Return the name for this instance.
167:
168: const OSSymbol * IONetworkMedium::getName() const
169: {
170: return _name;
171: }
172:
173: //---------------------------------------------------------------------------
174: // descP: The IOMediumDescriptor structure associated with the
175: // instance is copied to a structure provided by the caller.
176:
177: void IONetworkMedium::getDescriptor(IOMediumDescriptor * descP) const
178: {
179: assert(descP);
180: bcopy(_desc, descP, sizeof(*descP));
181: }
182:
183: //===========================================================================
184: // The definitions and the routines were adapted from FreeBSD
185: // (net/if_media.c). Should try to reuse the similar function in BSD.
186: //===========================================================================
187: /*
188: * Copyright (c) 1997
189: * Jonathan Stone and Jason R. Thorpe. All rights reserved.
190: *
191: * This software is derived from information provided by Matt Thomas.
192: *
193: * Redistribution and use in source and binary forms, with or without
194: * modification, are permitted provided that the following conditions
195: * are met:
196: * 1. Redistributions of source code must retain the above copyright
197: * notice, this list of conditions and the following disclaimer.
198: * 2. Redistributions in binary form must reproduce the above copyright
199: * notice, this list of conditions and the following disclaimer in the
200: * documentation and/or other materials provided with the distribution.
201: * 3. All advertising materials mentioning features or use of this software
202: * must display the following acknowledgement:
203: * This product includes software developed by Jonathan Stone
204: * and Jason R. Thorpe for the NetBSD Project.
205: * 4. The names of the authors may not be used to endorse or promote products
206: * derived from this software without specific prior written permission.
207: *
208: * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
209: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
210: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
211: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
212: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
213: * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
214: * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
215: * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
216: * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
217: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
218: * SUCH DAMAGE.
219: */
220:
221: /*
222: * Append a C string to a buffer. A counter is updated with the remaining
223: * size of the buffer.
224: */
225: static void append_string(char ** buf,
226: int * remain,
227: const char * str)
228: {
229: char * buffer = *buf;
230: int needed_length;
231:
232: if (!str)
233: return;
234:
235: // The remaining size must be big enough for 'str',
236: // and a terminating null character.
237:
238: needed_length = strlen(str) + 1;
239:
240: if (*remain >= needed_length) { // buffer is large enough
241: bcopy(str, buffer, strlen(str));
242: buffer += strlen(str);
243: *buffer = '\0';
244:
245: // decrement the remaining count, not counting the null char.
246: //
247: *remain -= (needed_length - 1);
248: *buf = buffer;
249: }
250: }
251:
252: struct IOMediumTypesAndOptions {
253: struct IOMediumDescription * types;
254: struct IOMediumDescription * options;
255: };
256:
257: static struct IOMediumDescription familyDescriptions[] =
258: kIOMediumFamilyDescriptions;
259:
260: static struct IOMediumDescription ethernetDescriptions[] =
261: kIOMediumEthernetDescriptions;
262:
263: static struct IOMediumDescription ethernetOptionDescriptions[] =
264: kIOMediumEthernetOptionDescriptions;
265:
266: static struct IOMediumDescription commonDescriptions[] =
267: kIOMediumCommonDescriptions;
268:
269: static struct IOMediumDescription commonOptionDescriptions[] =
270: kIOMediumCommonOptionDescriptions;
271:
272: static struct IOMediumTypesAndOptions typesAndOptionsTable[] = {
273: {
274: ðernetDescriptions[0],
275: ðernetOptionDescriptions[0]
276: },
277: };
278:
279: #define IO_IFM_APPEND_OPTION(str) { \
280: if (seen_option == 0) \
281: append_string(&buf, &maxlen, " ("); \
282: append_string(&buf, &maxlen, seen_option++ ? "," : ""); \
283: append_string(&buf, &maxlen, str); \
284: }
285:
286: /*
287: * print a media word.
288: */
289: static int
290: ifmedia_printword(int ifmw, char * buf, int maxlen)
291: {
292: struct IOMediumDescription * desc;
293: struct IOMediumTypesAndOptions * ttos;
294: int seen_option = 0;
295:
296: /* Find the media family first */
297: for (desc = familyDescriptions, ttos = typesAndOptionsTable;
298: desc->string != NULL;
299: desc++, ttos++)
300: if (IOMediumGetFamily(ifmw) == desc->word)
301: break;
302:
303: if (desc->string == NULL)
304: return 0; // unknown family type.
305:
306: #if 0 // disable family printing (e.g. Ethernet).
307: append_string(&buf, &maxlen, desc->string);
308: #endif
309:
310: /*
311: * Print the family specific type description. If the description
312: * is not found, then look at the common type descriptions.
313: */
314: for (desc = ttos->types; desc->string != NULL; desc++)
315: if (IOMediumGetType(ifmw) == desc->word)
316: goto got_subtype;
317:
318: for (desc = commonDescriptions; desc->string != NULL; desc++)
319: if (IOMediumGetIndex(ifmw) == desc->word)
320: break;
321:
322: if (desc->string == NULL)
323: return 0; // unknown family specific type.
324:
325: got_subtype:
326: #if 0 // by disabling type printing, we don't need the space padding.
327: append_string(&buf, &maxlen, " ");
328: #endif
329: append_string(&buf, &maxlen, desc->string);
330:
331: /*
332: * Look for common options.
333: */
334: for (desc = commonOptionDescriptions; desc->string != NULL; desc++) {
335: if (ifmw & desc->word)
336: IO_IFM_APPEND_OPTION(desc->string);
337: }
338:
339: /*
340: * Look for family specific options.
341: */
342: for (desc = ttos->options; desc->string != NULL; desc++) {
343: if (ifmw & desc->word)
344: IO_IFM_APPEND_OPTION(desc->string);
345: }
346:
347: /*
348: * Print the instance number.
349: */
350: if (IOMediumGetInstance(ifmw)) {
351: char instanceString[16];
352: sprintf(instanceString, "%d", IOMediumGetInstance(ifmw));
353: IO_IFM_APPEND_OPTION(instanceString);
354: }
355:
356: append_string(&buf, &maxlen, seen_option ? ")" : "");
357:
358: return 1;
359: }
360: //===========================================================================
361: // End of FreeBSD import.
362: //===========================================================================
363:
364: //---------------------------------------------------------------------------
365: // Given a 32-bit medium type, create an unique OSymbol name for the medium.
366: // The caller is responsible for releasing the OSSymbol object returned.
367: //
368: // type: A medium type. See IONetworkMedium.h for type encoding.
369: //
370: // Returns an OSSymbol created based on the type provided.
371:
372: const OSSymbol * IONetworkMedium::nameForType(IOMediumType type)
373: {
374: const UInt maxNameLen = 160;
375: char buffer[maxNameLen];
376:
377: if (ifmedia_printword(type, buffer, maxNameLen) == 0)
378: return 0; // error, cannot create name.
379:
380: // Caller must remember to free the OSSymbol!
381: //
382: return OSSymbol::withCString(buffer);
383: }
384:
385: //---------------------------------------------------------------------------
386: // Test for equality between two IONetworkMedium objects.
387: // Two IONetworkMedium objects are considered equal if
388: // they have similar properties assigned to them during initialization.
389: //
390: // medium: An IONetworkMedium to test against the IONetworkMedium
391: // object being called.
392: //
393: // Returns true if equal, false otherwise.
394:
395: bool IONetworkMedium::isEqualTo(const IONetworkMedium * medium) const
396: {
397: return ((bcmp(medium->_desc, _desc, sizeof(*_desc)) == 0) &&
398: (medium->_name == _name));
399: }
400:
401: //---------------------------------------------------------------------------
402: // Test for equality between a IONetworkMedium object and an OSObject.
403: // The OSObject is considered equal to the IONetworkMedium object if the
404: // OSObject is an IONetworkMedium, and they have similar properties assigned
405: // to them during initialization.
406: //
407: // obj: An OSObject to test against the IONetworkMedium object being called.
408: //
409: // Returns true if equal, false otherwise.
410:
411: bool IONetworkMedium::isEqualTo(const OSObject * obj) const
412: {
413: IONetworkMedium * medium;
414: if ((medium = OSDynamicCast(IONetworkMedium, (OSObject *) obj)))
415: return isEqualTo(medium);
416: else
417: return false;
418: }
419:
420: //---------------------------------------------------------------------------
421: // Create an OSData containing an IOMediumDescriptor structure (not copied),
422: // and ask the OSData to serialize.
423: //
424: // s: An OSSerialize object to handle the serialization.
425: //
426: // Returns true on success, false otherwise.
427:
428: bool IONetworkMedium::serialize(OSSerialize * s) const
429: {
430: bool ret = false;
431: OSData * descriptorData;
432:
433: // Create an OSData that encapsulates our IOMediumDescriptor structure.
434: // Then instruct the OSData to serialize itself.
435: //
436: descriptorData = OSData::withBytesNoCopy((void *) _desc, sizeof(*_desc));
437: if (descriptorData) {
438: ret = descriptorData->serialize(s);
439: descriptorData->release();
440: }
441:
442: return ret;
443: }
444:
445: //---------------------------------------------------------------------------
446: // A helper function to add an IONetworkMedium object to a given dictionary.
447: // The name of the medium is used as the key for the new dictionary entry.
448: //
449: // dict: An OSDictionary object where the medium object should be added to.
450: // medium: The IONetworkMedium object to add to the dictionary.
451: //
452: // Returns true on success, false otherwise.
453:
454: bool IONetworkMedium::addMedium(OSDictionary * dict,
455: const IONetworkMedium * medium)
456: {
457: // Arguments type checking.
458: //
459: if (!OSDynamicCast(OSDictionary, dict) ||
460: !OSDynamicCast(IONetworkMedium, medium))
461: return false;
462:
463: return dict->setObject(medium->getName(), (OSObject *) medium);
464: }
465:
466: //---------------------------------------------------------------------------
467: // A helper function to remove an entry in a dictionary with a key that
468: // matches the name of the IONetworkMedium object provided.
469: //
470: // dict: An OSDictionary object where the medium object should be removed
471: // from.
472: // medium: The name of this medium object is used as the removal key.
473:
474: void IONetworkMedium::removeMedium(OSDictionary * dict,
475: const IONetworkMedium * medium)
476: {
477: // Arguments type checking.
478: //
479: if (!OSDynamicCast(OSDictionary, dict) ||
480: !OSDynamicCast(IONetworkMedium, medium))
481: return;
482:
483: dict->removeObject(medium->getName());
484: }
485:
486: //---------------------------------------------------------------------------
487: // Iterate through a dictionary and return an IONetworkMedium entry that
488: // satisfies the matching criteria. Returns 0 if there is no match.
489: // Also see getMediumWithType() and getMediumWithIndex() that
490: // are specialized forms derived from this method.
491: //
492: // dict: The dictionary to look for a match.
493: // match: An IOMediumDescriptor structure containing the matching fields.
494: // mask: An IOMediumDescriptor structure containing the matching mask.
495: // Bits set are used for matching, while cleared bits are don't
496: // care bits.
497: //
498: // The first matching IONetworkMedium entry found, or 0 if no match was found.
499:
500: IONetworkMedium * IONetworkMedium::getMedium(const OSDictionary * dict,
501: IOMediumDescriptor * match,
502: IOMediumDescriptor * mask)
503: {
504: OSCollectionIterator * iter;
505: OSSymbol * keyObject;
506: IONetworkMedium * medium;
507: IONetworkMedium * retMedium = 0;
508: IOMediumDescriptor * desc;
509: UInt i;
510:
511: assert(match && mask);
512:
513: if (!dict) return 0;
514:
515: // Shouldn't withCollection take an (const OSDictionary *) argument?
516:
517: iter = OSCollectionIterator::withCollection((OSDictionary *) dict);
518: if (!iter)
519: return 0;
520:
521: while ( (keyObject = (OSSymbol *) iter->getNextObject()) )
522: {
523: medium = OSDynamicCast(IONetworkMedium, dict->getObject(keyObject));
524: if (!medium)
525: continue;
526:
527: desc = medium->_desc;
528:
529: // Perform bytewise matching.
530: //
531: for (i = 0; i < sizeof(IOMediumDescriptor); i++) {
532: if ( (((UInt8 *) desc)[i] ^ ((UInt8 *) match)[i]) &
533: ((UInt8 *) mask)[i] )
534: break;
535: }
536: if (i == sizeof(IOMediumDescriptor)) { // match found.
537: retMedium = medium;
538: break;
539: }
540: }
541:
542: iter->release();
543:
544: return retMedium;
545: }
546:
547: //---------------------------------------------------------------------------
548: // getMedium___ macro.
549: //
550: // Returns a IONetworkMedium entry that has a IOMediumDescriptor
551: // with a 'field' which matches the given 'value'.
552: //
553: // name - function name.
554: // vartype - data type of the IOMediumDescriptor field.
555: // field - field in IOMediumDescriptor to perform search.
556: // mask - don't care bits.
557:
558: #define GET_MEDIUM_FUNC(name, vartype, field) \
559: IONetworkMedium * \
560: IONetworkMedium::getMediumWith ## name(const OSDictionary * dict, \
561: vartype value, \
562: vartype mask = 0) \
563: { \
564: IOMediumDescriptor match[2]; \
565: \
566: bzero(&match[0], sizeof(match)); \
567: \
568: match[0]. ## field = value; \
569: match[1]. ## field = ~mask; \
570: \
571: return IONetworkMedium::getMedium(dict, &match[0], &match[1]); \
572: }
573:
574: GET_MEDIUM_FUNC(Type, IOMediumType, type) // getMediumWithType()
575: GET_MEDIUM_FUNC(Index, UInt32, data) // getMediumWithIndex()
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.