![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IONetworkController.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 IONetworkController.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: * IONetworkController.cpp ! 26: * ! 27: * HISTORY ! 28: * 9-Dec-1998 Joe Liu (jliu) created. ! 29: * ! 30: */ ! 31: ! 32: #include <IOKit/assert.h> ! 33: #include <IOKit/IOCommandGate.h> ! 34: #include <IOKit/network/IONetworkController.h> ! 35: #include <IOKit/network/IOOutputQueue.h> ! 36: #include <IOKit/network/IONetworkMedium.h> ! 37: ! 38: // IONetworkController needs to know about mbufs, but it shall have no ! 39: // other dependencies on BSD networking. ! 40: // ! 41: extern "C" { ! 42: #include <sys/param.h> // mbuf limits defined here. ! 43: #include <sys/mbuf.h> ! 44: // ! 45: // osfmk/kern/spl.h - Need splimp for mbuf macros. ! 46: // ! 47: typedef unsigned spl_t; ! 48: extern spl_t (splimp)(void); ! 49: } ! 50: ! 51: //------------------------------------------------------------------------- ! 52: // Macros. ! 53: ! 54: #define super IOService ! 55: ! 56: OSDefineMetaClass( IONetworkController, IOService ) ! 57: OSDefineAbstractStructors( IONetworkController, IOService ) ! 58: ! 59: // Define SYNC_REQ macro to simplify syncRequest() calls. ! 60: // ! 61: #define SYNC_REQ(sender, action, ret, args...) \ ! 62: syncRequest(sender, this, (IONetworkAction) action, (UInt32 *) ret, \ ! 63: ## args) ! 64: ! 65: #define DO_SYNC_REQ(action, args...) \ ! 66: { \ ! 67: IOReturn ret = kIOReturnNotReady; \ ! 68: syncRequest(client, this, \ ! 69: (RequestAction) &IONetworkController:: ## action, \ ! 70: (UInt32 *) &ret, ## args); \ ! 71: return ret; \ ! 72: } ! 73: ! 74: static bool isPowerOfTwo(UInt num) ! 75: { ! 76: return (num == (num & ~(num - 1))); ! 77: } ! 78: ! 79: #ifndef MAX ! 80: #define MAX(a, b) (((a)>(b))?(a):(b)) ! 81: #endif ! 82: ! 83: #define MEDIUM_LOCK IOTakeLock(_mediumLock); ! 84: #define MEDIUM_UNLOCK IOUnlock(_mediumLock); ! 85: ! 86: #ifdef DEBUG ! 87: #define DLOG(fmt, args...) IOLog(fmt, ## args) ! 88: #else ! 89: #define DLOG ! 90: #endif ! 91: ! 92: // OSSymbols for frequently used keys. ! 93: // ! 94: static const OSSymbol * gIOActiveMediumKey; ! 95: static const OSSymbol * gIOCurrentMediumKey; ! 96: ! 97: //--------------------------------------------------------------------------- ! 98: // Class initializer for IONetworkController. Create OSSymbol objects ! 99: // ahead of time that are used as keys. This method is called explicitly ! 100: // by a line in IOStartIOKit.cpp and not by the OSDefineMetaClassAndInit() ! 101: // mechanism, since the OSSymbol class is not guaranteed to be initialized ! 102: // first, thus its OSSymbol pool may not be setup. ! 103: ! 104: void IONetworkController::initialize() ! 105: { ! 106: gIOActiveMediumKey = OSSymbol::withCStringNoCopy(kIOActiveMedium); ! 107: gIOCurrentMediumKey = OSSymbol::withCStringNoCopy(kIOCurrentMedium); ! 108: ! 109: assert(gIOActiveMediumKey && gIOCurrentMediumKey); ! 110: ! 111: IONetworkData::initialize(); ! 112: } ! 113: ! 114: //--------------------------------------------------------------------------- ! 115: // Initialize the IONetworkController instance. Instance variables are ! 116: // initialized to their default values, and the init() method in superclass ! 117: // is called. ! 118: // ! 119: // properties: A property table. ! 120: // ! 121: // Returns true on success, false otherwise. ! 122: ! 123: bool IONetworkController::init(OSDictionary * properties) ! 124: { ! 125: // Initialize instance variables. ! 126: // ! 127: _workLoop = 0; ! 128: _cmdGate = 0; ! 129: _outputQueue = 0; ! 130: _clientSet = 0; ! 131: _reqClient = 0; ! 132: _requestEnabled = true; ! 133: _handleReady = true; ! 134: _mediumLock = 0; ! 135: _linkData = 0; ! 136: ! 137: if (!super::init(properties)) ! 138: { ! 139: DLOG("IONetworkController: super::init() failed\n"); ! 140: return false; ! 141: } ! 142: return true; ! 143: } ! 144: ! 145: //------------------------------------------------------------------------- ! 146: // Called when the controller was matched to a provider and ! 147: // has been selected to start running. IONetworkController will allocate ! 148: // resources and gather the controller's properties. No I/O will be ! 149: // triggered until the subclass attaches a client object from its own ! 150: // start method. Subclasses must override this method and call ! 151: // super::start() at the beginning of its implementation. They should ! 152: // also check the return value to make sure their superclass was ! 153: // started successfully. The resources allocated ! 154: // by IONetworkController are: ! 155: // ! 156: // - An IOWorkLoop object. ! 157: // - An IOCommandGate object to handle synchronous requests. ! 158: // - An OSSet to track our clients. ! 159: // - An optional IOOutputQueue object for output queueing. ! 160: // ! 161: // Tasks that are usually performed by a typical network driver in start ! 162: // include: ! 163: // ! 164: // - Resource allocation ! 165: // - Hardware initialization ! 166: // - Allocation of IOEventSources and attaching them to an IOWorkLoop object. ! 167: // - Publishing a medium dictionary. ! 168: // - And finally, attaching an interface object when the driver is ready ! 169: // to handle client requests. ! 170: // ! 171: // provider: The provider that the controller was matched ! 172: // (and attached) to. ! 173: // ! 174: // Returns true on success, false otherwise. ! 175: ! 176: bool IONetworkController::start(IOService * provider) ! 177: { ! 178: // Most drivers will probably want to wait for BSD due to their ! 179: // dependency on mbufs, which is not available until BSD is ! 180: // initialized. ! 181: // ! 182: if ((getFeatureSet() & kIONetworkFeatureNoBSDWait) == 0) ! 183: waitForService(resourceMatching( "IOBSD" )); ! 184: ! 185: // Start our superclass. ! 186: // ! 187: if (!super::start(provider)) ! 188: return false; ! 189: ! 190: // Create an OSSet to store our clients. ! 191: // ! 192: _clientSet = OSSet::withCapacity(2); ! 193: if (!_clientSet) ! 194: return false; ! 195: ! 196: // Initialize link status properties. ! 197: // ! 198: setMediumProperty(gIOActiveMediumKey, 0, &_activeMedium, true); ! 199: setMediumProperty(gIOCurrentMediumKey, 0, &_currentMedium, true); ! 200: setLink32Property(kIOLinkStatus, 0, &_linkStatus, true); ! 201: setLink64Property(kIOLinkSpeed, 0, &_linkSpeed, true); ! 202: ! 203: // Allocate a mutex lock to serialize access to the medium dictionary. ! 204: // ! 205: _mediumLock = IOLockAlloc(); ! 206: if (!_mediumLock) ! 207: return false; ! 208: IOLockInitWithState(_mediumLock, kIOLockStateUnlocked); ! 209: ! 210: // Allocate and initialize the default IOWorkLoop object. ! 211: // ! 212: _workLoop = IOWorkLoop::workLoop(); ! 213: if (!_workLoop) ! 214: { ! 215: DLOG("%s: IOWorkLoop allocation failed\n", getName()); ! 216: return false; ! 217: } ! 218: ! 219: // Create a 'private' IOCommandGate object and attach it to ! 220: // our workloop created above. This is used by the syncRequest() ! 221: // function. ! 222: // ! 223: _cmdGate = IOCommandGate::commandGate(this); ! 224: if (!_cmdGate || ! 225: (_workLoop->addEventSource(_cmdGate) != kIOReturnSuccess)) ! 226: { ! 227: DLOG("%s: IOCommandGate initialization failed\n", getName()); ! 228: return false; ! 229: } ! 230: ! 231: // Try to allocate an IOOutputQueue instance. This is optional and ! 232: // _outputQueue may be 0. ! 233: // ! 234: _outputQueue = createOutputQueue(); ! 235: ! 236: // Remove this when allocateOutputQueue is deleted. ! 237: if (!_outputQueue) ! 238: _outputQueue = allocateOutputQueue(); ! 239: ! 240: // Query the controller's mbuf buffer restrictions. ! 241: // ! 242: IOPacketBufferConstraints constraints; ! 243: getPacketBufferConstraints(&constraints); ! 244: if ((constraints.alignStart > kIOPacketBufferAlign32) || ! 245: (constraints.alignLength > kIOPacketBufferAlign32) || ! 246: !isPowerOfTwo(constraints.alignStart) || ! 247: !isPowerOfTwo(constraints.alignLength)) ! 248: { ! 249: IOLog("%s: Invalid alignment: start:%ld, length:%ld\n", ! 250: getName(), ! 251: constraints.alignStart, ! 252: constraints.alignLength); ! 253: return false; ! 254: } ! 255: ! 256: // Make it easier to satisfy both constraints. ! 257: // ! 258: if (constraints.alignStart < constraints.alignLength) ! 259: constraints.alignStart = constraints.alignLength; ! 260: ! 261: // Convert to alignment masks. ! 262: // ! 263: _alignStart = (constraints.alignStart) ? constraints.alignStart - 1 : 0; ! 264: _alignLength = (constraints.alignLength) ? constraints.alignLength - 1 : 0; ! 265: _alignPadding = _alignStart + _alignLength; ! 266: ! 267: // Starts the power manager ! 268: // ! 269: PMinit(); // initialize superclass power management variables ! 270: provider->joinPMtree(this); // attach into the power management hierarchy ! 271: ! 272: return true; ! 273: } ! 274: ! 275: //--------------------------------------------------------------------------- ! 276: // The opposite of start(). The controller has been instructed to stop running. ! 277: // This method should release resources and undo actions performed by start(). ! 278: // Subclasses must override this method and call super::stop() at the end of ! 279: // its implementation. ! 280: // ! 281: // provider: The provider that the controller was matched ! 282: // (and attached) to. ! 283: ! 284: void IONetworkController::stop(IOService * provider) ! 285: { ! 286: // Free the memory allocated by PMInit: ! 287: PMstop(); ! 288: ! 289: super::stop(provider); ! 290: } ! 291: ! 292: //--------------------------------------------------------------------------- ! 293: // Get the IOWorkLoop object created by IONetworkController. ! 294: // An IOWorkLoop object is created by the start() method. Drivers can call ! 295: // getWorkLoop() to obtain a reference to the IOWorkLoop object, and attach ! 296: // their event sources, such as IOTimerEventSource or IOInterruptEventSource. ! 297: // See IOWorkLoop. ! 298: // ! 299: // Returns the IOWorkLoop object created by IONetworkController. ! 300: ! 301: IOWorkLoop * IONetworkController::getWorkLoop() const ! 302: { ! 303: return _workLoop; ! 304: } ! 305: ! 306: //--------------------------------------------------------------------------- ! 307: // Get the IOCommandGate object created by IONetworkController. ! 308: // An IOCommandGate is created and attached to an IOWorkLoop by the start(). ! 309: // method This IOCommandGate object is used to handle client requests issued ! 310: // through the syncRequest() method. Subclasses that need an IOCommandGate ! 311: // should try to use the object returned by this method, rather than creating ! 312: // a new instance. ! 313: // See IOCommandGate. ! 314: // ! 315: // Returns the IOCommandGate object created by IONetworkController. ! 316: ! 317: IOCommandGate * IONetworkController::getCommandGate() const ! 318: { ! 319: return _cmdGate; ! 320: } ! 321: ! 322: //--------------------------------------------------------------------------- ! 323: // Get the address of the method designated to handle output packets. ! 324: // ! 325: // Returns the address of the outputPacket() method. ! 326: ! 327: IOOutputAction IONetworkController::getOutputHandler() const ! 328: { ! 329: return (IOOutputAction) &IONetworkController::outputPacket; ! 330: } ! 331: ! 332: //--------------------------------------------------------------------------- ! 333: // Create a new interface client object and attach it ! 334: // to the controller. The createInterface() method is called to ! 335: // perform the allocation and initialization, followed by a call to ! 336: // configureInterface() to configure the interface. Both of these ! 337: // methods can be overridden by subclasses to customize the ! 338: // interface client attached. Drivers must call attachInterface() ! 339: // from its start() method, after it is ready to service client requests. ! 340: // ! 341: // interfaceP: If successful (return value is true), then the interface ! 342: // object will be written to the handle provided. ! 343: // ! 344: // doRegister: If true, then registerService() is called to register ! 345: // the interface, which will trigger the matching process, ! 346: // and cause the interface to become registered with the network ! 347: // layer. For drivers that wish to delay the registration, and ! 348: // hold off servicing requests and data packets from the network ! 349: // layer, set doRegister to false and call registerService() on ! 350: // the interface client when the controller becomes ready. ! 351: // ! 352: // Returns true on success, false otherwise. ! 353: ! 354: bool ! 355: IONetworkController::attachInterface(IONetworkInterface ** interfaceP, ! 356: bool doRegister = true) ! 357: { ! 358: IONetworkInterface * netif; ! 359: bool initOk = false; ! 360: ! 361: *interfaceP = 0; ! 362: ! 363: // We delay some initialization until the first time that ! 364: // attachInterface() is called by the subclass. ! 365: // ! 366: SYNC_REQ(this, &IONetworkController::_controllerIsReady, &initOk); ! 367: if (!initOk) ! 368: return false; ! 369: ! 370: do { ! 371: // Allocate a concrete subclass of IONetworkInterface ! 372: // by calling createInterface(). ! 373: // ! 374: netif = createInterface(); ! 375: if (!netif) ! 376: break; ! 377: ! 378: // Configure the interface instance by calling ! 379: // configureInterface(), then attach it as our client. ! 380: // ! 381: if (!configureInterface(netif) || ! 382: !configureNetworkInterface(netif) || ! 383: !netif->attach(this)) ! 384: { ! 385: netif->release(); ! 386: break; ! 387: } ! 388: ! 389: *interfaceP = netif; ! 390: ! 391: // Register the interface nub. Spawns a matching thread. ! 392: // ! 393: if (doRegister) ! 394: netif->registerService(); ! 395: ! 396: return true; ! 397: } ! 398: while (0); ! 399: ! 400: return false; // failed ! 401: } ! 402: ! 403: //--------------------------------------------------------------------------- ! 404: // Detach the interface object. This method will check that ! 405: // the object provided is indeed an IONetworkInterface, and if so its ! 406: // terminate() method is called. The interface object will close and detach ! 407: // from its controller only after the network layer has removed all references ! 408: // to the data structures exposed by the interface. ! 409: // ! 410: // interface: An interface object to be detached. ! 411: // sync: If true, the interface is terminated synchronously. ! 412: // Note that this may cause detachInterface() to block ! 413: // for an indefinite period of time. ! 414: ! 415: void ! 416: IONetworkController::detachInterface(IONetworkInterface * interface, ! 417: bool sync = false) ! 418: { ! 419: IOOptionBits options = kIOServiceRequired; ! 420: ! 421: if (OSDynamicCast(IONetworkInterface, interface) == 0) ! 422: return; ! 423: ! 424: if (sync) ! 425: options |= kIOServiceSynchronous; ! 426: ! 427: interface->terminate(options); ! 428: } ! 429: ! 430: //--------------------------------------------------------------------------- ! 431: // This method is called the first time that a controller driver calls ! 432: // attachInterface() or attachDebuggerClient(), which is an indication that ! 433: // the driver has been started and is ready to service client requests. ! 434: // IONetworkController uses this method to complete its initialization ! 435: // before any client objects are attached. ! 436: // ! 437: // provider: The controller's provider. ! 438: // ! 439: // Returns true on success, false otherwise. ! 440: ! 441: bool IONetworkController::ready(IOService * provider) ! 442: { ! 443: return publishCapabilities(); ! 444: } ! 445: ! 446: //--------------------------------------------------------------------------- ! 447: // Called when the controller is ready to handle client requests. ! 448: // Returns true to indicate success, false otherwise. ! 449: ! 450: bool IONetworkController::_controllerIsReady() ! 451: { ! 452: if (!_handleReady) ! 453: return true; ! 454: ! 455: if (!ready(getProvider())) // Call ready(). ! 456: return false; ! 457: ! 458: _handleReady = false; ! 459: return true; ! 460: } ! 461: ! 462: //--------------------------------------------------------------------------- ! 463: // Handle a client open on the controller object. IOService calls this method ! 464: // with the arbitration lock held. Subclasses are not expected to override ! 465: // this method. ! 466: // ! 467: // client: The client that is trying to open the controller. ! 468: // options: See IOService. ! 469: // argument: See IOService. ! 470: // ! 471: // Returns true to accept the client open, false to refuse the open. ! 472: ! 473: bool IONetworkController::handleOpen(IOService * client, ! 474: IOOptionBits options, ! 475: void * argument) ! 476: { ! 477: bool ok; ! 478: ! 479: assert(client); ! 480: ! 481: ok = _clientSet->setObject(client); ! 482: if (ok && OSDynamicCast(IOKernelDebugger, client)) ! 483: { ! 484: ok = (doEnable(client) == kIOReturnSuccess); ! 485: if (!ok) ! 486: _clientSet->removeObject(client); ! 487: } ! 488: return ok; ! 489: } ! 490: ! 491: //--------------------------------------------------------------------------- ! 492: // Handle a close from one of our client objects. IOService calls this method ! 493: // with the arbitration lock held. Subclasses are not expected to override this ! 494: // method. ! 495: // ! 496: // client: The client that has closed the controller. ! 497: // options: See IOService. ! 498: ! 499: void IONetworkController::handleClose(IOService * client, IOOptionBits options) ! 500: { ! 501: _clientSet->removeObject(client); ! 502: ! 503: if (OSDynamicCast(IOKernelDebugger, client)) ! 504: doDisable(client); ! 505: } ! 506: ! 507: //--------------------------------------------------------------------------- ! 508: // This method is always called by IOService with the arbitration lock held. ! 509: // Subclasses should not override this method. ! 510: // ! 511: // Returns true if the specified client, or any client if none is ! 512: // specified, presently has an open on this object. ! 513: ! 514: bool IONetworkController::handleIsOpen(const IOService * client) const ! 515: { ! 516: if (client) ! 517: return _clientSet->containsObject(client); ! 518: else ! 519: return (_clientSet->getCount() > 0); ! 520: } ! 521: ! 522: //--------------------------------------------------------------------------- ! 523: // Free the IONetworkController instance and all allocated resources, ! 524: // then call super::free(). ! 525: ! 526: void IONetworkController::free() ! 527: { ! 528: if (_outputQueue) ! 529: _outputQueue->release(); ! 530: ! 531: if (_cmdGate) ! 532: _cmdGate->release(); ! 533: ! 534: if (_workLoop) ! 535: _workLoop->release(); ! 536: ! 537: if (_clientSet) ! 538: { ! 539: // We should have no clients at this point. If we do, ! 540: // then something is very wrong! It means that a client ! 541: // has an open on us, and yet we are going away. ! 542: // ! 543: assert(_clientSet->getCount() == 0); ! 544: _clientSet->release(); ! 545: } ! 546: ! 547: if (_mediumLock) ! 548: IOLockFree(_mediumLock); ! 549: ! 550: super::free(); ! 551: } ! 552: ! 553: //--------------------------------------------------------------------------- ! 554: // Handle an enable request from a client. The client's class ! 555: // is typecasted using OSDynamicCast, and if the client is an ! 556: // IOKernelDebugger or an IONetworkInterface, an overloaded enable ! 557: // method that takes a more specific argument is called. If the client ! 558: // matches neither type, a kIOReturnBadArgument is returned. ! 559: // A driver has the option of override this generic enable method, ! 560: // or the derived version. ! 561: // ! 562: // client: The client object requesting the enable. ! 563: // ! 564: // The return value from the derived enable method, or ! 565: // kIOReturnBadArgument if the client's type is unknown. ! 566: ! 567: IOReturn IONetworkController::enable(IOService * client) ! 568: { ! 569: if (OSDynamicCast(IONetworkInterface, client)) ! 570: return enable((IONetworkInterface *) client); ! 571: ! 572: if (OSDynamicCast(IOKernelDebugger, client)) ! 573: return enable((IOKernelDebugger *) client); ! 574: ! 575: IOLog("%s::%s Unknown client type\n", getName(), __FUNCTION__); ! 576: return kIOReturnBadArgument; ! 577: } ! 578: ! 579: //--------------------------------------------------------------------------- ! 580: // Handle an enable request from a client. The client ! 581: // object is typecasted using OSDynamicCast, and if the client is an ! 582: // IOKernelDebugger or an IONetworkInterface, then an overloaded disable ! 583: // method that takes a more specific argument is called. If the client ! 584: // matches neither type, a kIOReturnBadArgument is returned. ! 585: // A driver has the option of override this generic enable method, ! 586: // or the derived version. ! 587: // ! 588: // client: The client object requesting the disable. ! 589: // ! 590: // The return from the derived disable method, or ! 591: // kIOReturnBadArgument if the client's type is unknown ! 592: ! 593: IOReturn IONetworkController::disable(IOService * client) ! 594: { ! 595: if (OSDynamicCast(IONetworkInterface, client)) ! 596: return disable((IONetworkInterface *) client); ! 597: ! 598: if (OSDynamicCast(IOKernelDebugger, client)) ! 599: return disable((IOKernelDebugger *) client); ! 600: ! 601: IOLog("%s::%s Unknown client type\n", getName(), __FUNCTION__); ! 602: return kIOReturnBadArgument; ! 603: } ! 604: ! 605: //--------------------------------------------------------------------------- ! 606: // Called by an interface client to enable the controller. ! 607: // This method must bring up the hardware and enable event sources ! 608: // to prepare for packet transmission and reception. A driver should ! 609: // delay the allocation of most runtime resources until this method is ! 610: // called to conserve shared system resources. ! 611: // ! 612: // interface: The interface object that requested the enable. ! 613: // ! 614: // Returns kIOReturnUnsupported. Driver may override this method and ! 615: // return kIOReturnSuccess on success, or an error code otherwise. ! 616: ! 617: IOReturn IONetworkController::enable(IONetworkInterface * interface) ! 618: { ! 619: IOLog("IONetworkController::%s called\n", __FUNCTION__); ! 620: return kIOReturnUnsupported; ! 621: } ! 622: ! 623: //--------------------------------------------------------------------------- ! 624: // Called by an interface object to disable the controller. ! 625: // This method should quiesce the hardware and disable event sources. ! 626: // Any resources allocated in enable() should also be deallocated. ! 627: // ! 628: // interface: The interface object that requested the disable. ! 629: // ! 630: // Returns kIOReturnUnsupported. Driver may override this method and ! 631: // return kIOReturnSuccess on success, or an error code otherwise. ! 632: ! 633: IOReturn IONetworkController::disable(IONetworkInterface * interface) ! 634: { ! 635: IOLog("IONetworkController::%s called\n", __FUNCTION__); ! 636: return kIOReturnUnsupported; ! 637: } ! 638: ! 639: //--------------------------------------------------------------------------- ! 640: // With the various overloaded forms of enable() and disable(), what does it ! 641: // mean when one does &IONetworkController::enable, to get the address of the ! 642: // member function? ! 643: // Instead, these private functions are registered which then calls the ! 644: // correct functions. ! 645: ! 646: IOReturn IONetworkController::_enable(IOService * client) ! 647: { ! 648: return enable(client); ! 649: }; ! 650: ! 651: IOReturn IONetworkController::_disable(IOService * client) ! 652: { ! 653: return disable(client); ! 654: }; ! 655: ! 656: //--------------------------------------------------------------------------- ! 657: // Discover and publish controller capabilities to the property table. ! 658: // This method is called by ready(). ! 659: // ! 660: // Returns true if all capabilities were discovered and published ! 661: // successfully, false otherwise. Returning false will prevent client ! 662: // objects from attaching to the controller since a property that ! 663: // a client depends on may be missing ! 664: ! 665: bool IONetworkController::publishCapabilities() ! 666: { ! 667: bool ret = true; ! 668: OSString * string; ! 669: UInt32 index; ! 670: ! 671: string = OSString::withCString(getVendorString()); ! 672: if (string) { ! 673: ret = setProperty(kIOVendor, string) && ret; ! 674: string->release(); ! 675: } ! 676: ! 677: string = OSString::withCString(getModelString()); ! 678: if (string) { ! 679: ret = setProperty(kIOModel, string) && ret; ! 680: string->release(); ! 681: } ! 682: ! 683: string = OSString::withCString(getRevisionString()); ! 684: if (string) { ! 685: ret = setProperty(kIORevision, string) && ret; ! 686: string->release(); ! 687: } ! 688: ! 689: string = OSString::withCString(getInfoString()); ! 690: if (string) { ! 691: ret = setProperty(kIOInfo, string) && ret; ! 692: string->release(); ! 693: } ! 694: ! 695: // Set OSNumber properties. ! 696: // ! 697: ret = (getControllerIndex(&index) == kIOReturnSuccess) && ret; ! 698: ret = setProperty(kIOControllerIndex, index, 32) && ret; ! 699: ret = setProperty(kIOFeatureSet, getFeatureSet(), 32) && ret; ! 700: ret = setProperty(kIOFamilyFeatureSet, getFamilyFeatureSet(), 32) && ret; ! 701: ! 702: if (getPacketFilters(&index) == kIOReturnSuccess) { ! 703: ret = setProperty(kIOPacketFilters, index, 32) && ret; ! 704: } ! 705: else { ! 706: ret = false; ! 707: } ! 708: ! 709: if (!ret) ! 710: DLOG("IONetworkController::%s error\n", __FUNCTION__); ! 711: ! 712: return ret; ! 713: } ! 714: ! 715: //--------------------------------------------------------------------------- ! 716: // Broadcast a network event to all attached interface objects. ! 717: // This is equivalent to calling the IONetworkInterface::inputEvent() ! 718: // function for each interface client. ! 719: // ! 720: // IONetworkController uses this method to broadcast link and media ! 721: // events. Drivers will usually call the inputEvent() method directly ! 722: // since it is more efficient, and most drivers will only attach a ! 723: // single interface client. ! 724: // ! 725: // type: Event type. ! 726: // arg: Event argument. ! 727: // ! 728: // Returns true if the event was delivered, false if an error occurred ! 729: // (unable to perform object allocation) and the event was not delivered ! 730: ! 731: bool IONetworkController::broadcastEvent(UInt32 type, void * arg = 0) ! 732: { ! 733: IONetworkInterface * netif; ! 734: OSCollectionIterator * iter = 0; ! 735: OSSet * clientSet; ! 736: ! 737: lockForArbitration(); // locks open/close/state changes. ! 738: ! 739: if (_clientSet->getCount()) { ! 740: clientSet = OSSet::withSet(_clientSet, _clientSet->getCount()); ! 741: if (clientSet) { ! 742: iter = OSCollectionIterator::withCollection(clientSet); ! 743: clientSet->release(); ! 744: } ! 745: } ! 746: ! 747: unlockForArbitration(); ! 748: ! 749: if (!iter) ! 750: return false; ! 751: ! 752: // Send the event to all attached interface objects. ! 753: // ! 754: while ((netif = (IONetworkInterface *) iter->getNextObject())) { ! 755: if (OSDynamicCast(IONetworkInterface, netif) == 0) ! 756: continue; // only send events to IONetworkInterface subclasses. ! 757: netif->inputEvent(type, arg); ! 758: } ! 759: ! 760: iter->release(); ! 761: ! 762: return true; ! 763: } ! 764: ! 765: //--------------------------------------------------------------------------- ! 766: // A client request for the controller to switch to a new MTU size. ! 767: // ! 768: // mtu: The new MTU size requested. ! 769: // ! 770: // Returns kIOReturnUnsupported. Drivers may override this method ! 771: // and return either kIOReturnSuccess to indicate that the new MTU size ! 772: // was accepted and is in effect, or an error to indicate failure. ! 773: ! 774: IOReturn IONetworkController::setMaxTransferUnit(UInt32 mtu) ! 775: { ! 776: return kIOReturnUnsupported; ! 777: } ! 778: ! 779: //--------------------------------------------------------------------------- ! 780: // A client request for the driver to perform hardware ! 781: // diagnostics and return the test result after completion. ! 782: // ! 783: // resultCodeP: In addition to the return code, drivers may return ! 784: // a hardware specific failure code. ! 785: // ! 786: // Return kIOReturnSuccess if the hardware passed all test, or an ! 787: // appropriate error code otherwise. The default return is always ! 788: // kIOReturnUnsupported. ! 789: ! 790: IOReturn IONetworkController::performDiagnostics(UInt32 * resultCodeP) ! 791: { ! 792: return kIOReturnUnsupported; ! 793: } ! 794: ! 795: //--------------------------------------------------------------------------- ! 796: // Transmit a packet mbuf. If an IOOutputQueue was allocated and returned by ! 797: // createOutputQueue(), then this method will be called by the queue object. ! 798: // Otherwise, an interface object will call this method directly upon ! 799: // receiving an output packet from the network layer. When a queue object ! 800: // is not present, this method must be safe from multiple client threads, ! 801: // each pushing a packet to be sent on the wire. ! 802: // ! 803: // There is no upper limit on the number of mbufs, hence the number of ! 804: // memory fragments, in the mbuf chain provided. Drivers must be able to ! 805: // handle cases when the chain might exceed the limit supported by their ! 806: // DMA engines, and perform coalescing to copy the various memory fragments ! 807: // into a lesser number of fragments. This complexity can be hidden from ! 808: // a driver when an IOMBufMemoryCursor is used, which is able to convert ! 809: // a mbuf chain into a physical address scatter-gather list that will not ! 810: // exceed a specified number of physically contiguous memory segments. ! 811: // See IOMBufMemoryCursor. ! 812: // ! 813: // Packets may also be chained to form a packet chain. Although the ! 814: // network layer, through the interface object, will currently only ! 815: // send a single mbuf packet to the controller for each outputPacket() ! 816: // call, it is possible for this to change. When a queue object is used, ! 817: // the queue will automatically accept a single packet or a packet chain, ! 818: // but it will call outputPacket() for each packet removed from the queue. ! 819: // ! 820: // The implementation in IONetworkController performs no useful action ! 821: // and will drop all packets. A driver must always override this method. ! 822: // ! 823: // m: The packet mbuf. ! 824: // ! 825: // Returns a return code defined by the caller. ! 826: ! 827: UInt32 IONetworkController::outputPacket(struct mbuf * m) ! 828: { ! 829: // The implementation here is simply a sink-hole, all packets are ! 830: // dropped. ! 831: // ! 832: if (m) freePacket(m); ! 833: return 0; ! 834: } ! 835: ! 836: //--------------------------------------------------------------------------- ! 837: // A client request to adjust the capacity of the driver's output queue ! 838: // (number of packets the queue can hold). If a driver does not override ! 839: // this method, then the default action is to forward the request to ! 840: // an IOOutputQueue object if it was created. Otherwise return ! 841: // kIOReturnUnsupported. ! 842: // ! 843: // capacity: The new capacity of the output queue. ! 844: // ! 845: // Returns kIOReturnSuccess on success, kIOReturnBadArgument if the ! 846: // specified capacity is invalid, or kIOReturnUnsupported if the ! 847: // function is not supported. ! 848: ! 849: IOReturn IONetworkController::setOutputQueueCapacity(UInt32 capacity) ! 850: { ! 851: if (_outputQueue) ! 852: return _outputQueue->setCapacity(capacity) ? ! 853: kIOReturnSuccess : kIOReturnBadArgument; ! 854: else ! 855: return kIOReturnUnsupported; ! 856: } ! 857: ! 858: //--------------------------------------------------------------------------- ! 859: // A client request to get the capacity of the output queue. If a driver ! 860: // does not override this method, then the default action is to forward the ! 861: // request to an IOOutputQueue object if it was created. Otherwise return ! 862: // kIOReturnUnsupported. ! 863: // ! 864: // capacityP: Address of an integer where the capacity ! 865: // shall be written to. ! 866: // ! 867: // Returns kIOReturnSuccess on success, or kIOReturnUnsupported if an ! 868: // IOOutputQueue object was not created. ! 869: ! 870: IOReturn IONetworkController::getOutputQueueCapacity(UInt32 * capacityP) const ! 871: { ! 872: if (_outputQueue) { ! 873: *capacityP = _outputQueue->getCapacity(); ! 874: return kIOReturnSuccess; ! 875: } ! 876: return kIOReturnUnsupported; ! 877: } ! 878: ! 879: //--------------------------------------------------------------------------- ! 880: // A client request to fetch the number of packets currently held by the ! 881: // queue. If a driver does not override this method, then the default action ! 882: // is to forward the request to an IOOutputQueue object if it was created. ! 883: // Otherwise return kIOReturnUnsupported. ! 884: // ! 885: // sizeP: Address of an integer where the size shall be written to. ! 886: // ! 887: // Returns kIOReturnSuccess on success, or kIOReturnUnsupported if an ! 888: // IOOutputQueue object was not created. ! 889: ! 890: IOReturn IONetworkController::getOutputQueueSize(UInt32 * sizeP) const ! 891: { ! 892: if (_outputQueue) { ! 893: *sizeP = _outputQueue->getSize(); ! 894: return kIOReturnSuccess; ! 895: } ! 896: return kIOReturnUnsupported; ! 897: } ! 898: ! 899: //--------------------------------------------------------------------------- ! 900: // A client request to flush all packets currently held by the queue, ! 901: // and return the number of packets discarded. If a driver does not ! 902: // override this method, then the default action is to forward the ! 903: // request to an IOOutputQueue object if it was created. ! 904: // Otherwise return kIOReturnUnsupported. ! 905: // ! 906: // flushCountP: Address of an integer where the number of packets ! 907: // discarded shall be written to. ! 908: // ! 909: // Returns kIOReturnSuccess on success, or kIOReturnUnsupported if an ! 910: // IOOutputQueue object was not created. ! 911: ! 912: IOReturn IONetworkController::flushOutputQueue(UInt32 * flushCountP) ! 913: { ! 914: if (_outputQueue) { ! 915: *flushCountP = _outputQueue->flush(); ! 916: return kIOReturnSuccess; ! 917: } ! 918: return kIOReturnUnsupported; ! 919: } ! 920: ! 921: //--------------------------------------------------------------------------- ! 922: // Report features supported by the controller. ! 923: // ! 924: // Returns 0. Drivers may override this method and return a mask ! 925: // containing all supported feature bits. ! 926: ! 927: UInt32 IONetworkController::getFeatureSet() const ! 928: { ! 929: return 0; ! 930: } ! 931: ! 932: //--------------------------------------------------------------------------- ! 933: // Return a string describing the revision level of the controller. ! 934: ! 935: const char * IONetworkController::getRevisionString() const ! 936: { ! 937: return 0; ! 938: } ! 939: ! 940: //--------------------------------------------------------------------------- ! 941: // Return a string containing any additional information about the controller ! 942: // and/or driver. ! 943: ! 944: const char * IONetworkController::getInfoString() const ! 945: { ! 946: return 0; ! 947: } ! 948: ! 949: //--------------------------------------------------------------------------- ! 950: // Return an ordinal number for multiport network adapters. ! 951: // The implementation in IONetworkController will work for PCI controllers ! 952: // behind a PCI-PCI bridge. This method exists solely to support the ! 953: // current interface naming scheme, and is likely to ! 954: // undergo changes or may disappear in the future. ! 955: // ! 956: // indexP: The oridinal number should be written to the ! 957: // integer at this address. ! 958: // ! 959: // Returns kIOReturnSuccess. ! 960: ! 961: IOReturn IONetworkController::getControllerIndex(UInt32 * index) const ! 962: { ! 963: IOService * provider = getProvider(); ! 964: ! 965: *index = 0; ! 966: ! 967: if (provider) { ! 968: OSNumber * offset = OSDynamicCast(OSNumber, ! 969: provider->getProperty("IOChildIndex")); ! 970: if (offset) ! 971: *index = offset->unsigned32BitValue(); ! 972: } ! 973: return kIOReturnSuccess; ! 974: } ! 975: ! 976: //--------------------------------------------------------------------------- ! 977: // Encodes a request received by syncRequest. This command structure is then ! 978: // submitted to commandHandler() through the IOCommandGate::runAction(). ! 979: ! 980: struct cmdStruct { ! 981: OSObject * client; ! 982: OSObject * target; ! 983: IONetworkController::RequestAction action; ! 984: void * arg0; ! 985: void * arg1; ! 986: void * arg2; ! 987: void * arg3; ! 988: }; ! 989: ! 990: //--------------------------------------------------------------------------- ! 991: // Execute the request received by syncRequest() and encoded onto ! 992: // a cmdStruct structure. This method is called by IOCommandGate's ! 993: // runAction() method. ! 994: ! 995: void IONetworkController::commandHandler(void * arg0, ! 996: void * arg1, ! 997: void * arg2, ! 998: void * /*arg3*/) ! 999: { ! 1000: cmdStruct * cmd = (cmdStruct *) arg0; // cmdStruct ! 1001: UInt32 * actRetP = (UInt32 *) arg1; // action return ! 1002: IOReturn * cmdRetP = (IOReturn *) arg2; // commandHandler return ! 1003: OSObject * oldClient = _reqClient; ! 1004: bool accept = true; ! 1005: ! 1006: assert(cmd && actRetP && cmdRetP); ! 1007: ! 1008: if (cmd->client != this) ! 1009: { ! 1010: // Filter the client request. ! 1011: ! 1012: accept = syncRequestFilter(cmd->client, ! 1013: cmd->target, ! 1014: cmd->action, ! 1015: cmd->arg0, ! 1016: cmd->arg1, ! 1017: cmd->arg2, ! 1018: cmd->arg3); ! 1019: } ! 1020: ! 1021: if (accept) { ! 1022: _reqClient = cmd->client; ! 1023: ! 1024: *actRetP = ((cmd->target)->*(cmd->action))(cmd->arg0, ! 1025: cmd->arg1, ! 1026: cmd->arg2, ! 1027: cmd->arg3); ! 1028: ! 1029: _reqClient = oldClient; ! 1030: ! 1031: *cmdRetP = kIOReturnSuccess; ! 1032: } ! 1033: else { ! 1034: // actRetP is not set if the request was rejected by the filter. ! 1035: *cmdRetP = kIOReturnNotReady; ! 1036: } ! 1037: } ! 1038: ! 1039: //--------------------------------------------------------------------------- ! 1040: // Perform a request action synchronously. Used both internally and also by ! 1041: // clients to execute an arbitrary request action using the IOCommandGate's ! 1042: // runAction() method. For client requests, where the client field is not ! 1043: // equal to 'this', the request is filtered by calling syncRequestFilter() ! 1044: // to qualify the client request. This filter function must return true ! 1045: // in order for the request to be accepted and the request action called. ! 1046: // ! 1047: // client: The client (caller) of the synchronous request. ! 1048: // target: The target object that implements the request action. ! 1049: // action: The action to perform. ! 1050: // ret: The return value from the action is written to the ! 1051: // integer with the provided address. The result is ! 1052: // not written if the request was rejected by the request filter. ! 1053: // arg0: Optional action argument. ! 1054: // arg1: Optional action argument. ! 1055: // arg2: Optional action argument. ! 1056: // arg3: Optional action argument. ! 1057: // ! 1058: // kIOReturnNotReady if the client request was rejected by the filter. ! 1059: // Otherwise kIOReturnSuccess is returned. ! 1060: ! 1061: IOReturn IONetworkController::syncRequest(OSObject * sender, ! 1062: OSObject * target, ! 1063: RequestAction action, ! 1064: UInt32 * ret = 0, ! 1065: void * arg0 = 0, ! 1066: void * arg1 = 0, ! 1067: void * arg2 = 0, ! 1068: void * arg3 = 0) ! 1069: { ! 1070: cmdStruct cmd; ! 1071: IOReturn rc; ! 1072: UInt32 ra; ! 1073: ! 1074: // bzero(&cmd, sizeof(cmd)); ! 1075: ! 1076: cmd.client = sender; // request client. ! 1077: cmd.target = target; // target object. ! 1078: cmd.action = action; // target action. ! 1079: cmd.arg0 = arg0; // action arguments. ! 1080: cmd.arg1 = arg1; ! 1081: cmd.arg2 = arg2; ! 1082: cmd.arg3 = arg3; ! 1083: ! 1084: _cmdGate->runAction( (IOCommandGate::Action) ! 1085: &IONetworkController::commandHandler, /* Action */ ! 1086: (void *) &cmd, /* arg0 - cmdStruct */ ! 1087: (void *) &ra, /* arg1 - action return */ ! 1088: (void *) &rc ); /* arg2 - commandHandler return */ ! 1089: ! 1090: if ((rc == kIOReturnSuccess) && ret) ! 1091: *ret = ra; ! 1092: ! 1093: return rc; ! 1094: } ! 1095: ! 1096: //--------------------------------------------------------------------------- ! 1097: // This method is called to qualify all client requests ! 1098: // sent to syncRequest(). This implementation will either allow or ! 1099: // refuse all requests, and this behavior is set by calling the ! 1100: // enableSyncRequest() or disableSyncRequest() methods. By default, ! 1101: // all requests are allowed. ! 1102: // ! 1103: // client: The client of the synchronous request. ! 1104: // target: The target object that implements the request action. ! 1105: // action: The action to perform. ! 1106: // arg0: Action argument. ! 1107: // arg1: Action argument. ! 1108: // arg2: Action argument. ! 1109: // arg3: Action argument. ! 1110: // ! 1111: // Returns true to accept the request and allow the request action to be ! 1112: // called, or false to refuse it. ! 1113: ! 1114: bool IONetworkController::syncRequestFilter(OSObject * client, ! 1115: OSObject * target, ! 1116: RequestAction action, ! 1117: void * arg0, ! 1118: void * arg1, ! 1119: void * arg2, ! 1120: void * arg3) ! 1121: { ! 1122: // If _requestEnabled ifs true, allow the request, otherwise refuse it. ! 1123: ! 1124: return _requestEnabled; ! 1125: } ! 1126: ! 1127: //--------------------------------------------------------------------------- ! 1128: // A static member function to control the default syncRequestFilter() ! 1129: // filter function. ! 1130: ! 1131: void IONetworkController::_enableSyncRequestFilter(IONetworkController * ctlr, ! 1132: bool enabled) ! 1133: { ! 1134: ctlr->_requestEnabled = enabled; ! 1135: } ! 1136: ! 1137: //--------------------------------------------------------------------------- ! 1138: // Enable all client requests sent to the syncRequest() method. ! 1139: // Don't use this method if the driver overrides syncRequestFilter(). ! 1140: ! 1141: void IONetworkController::enableSyncRequest() ! 1142: { ! 1143: _cmdGate->runAction( (IOCommandGate::Action) ! 1144: &IONetworkController::_enableSyncRequestFilter, ! 1145: (void *) true ); ! 1146: } ! 1147: ! 1148: //--------------------------------------------------------------------------- ! 1149: // Disable all client requests sent to the syncRequest() method. ! 1150: // Don't use this method if the driver overrides syncRequestFilter(). ! 1151: ! 1152: void IONetworkController::disableSyncRequest() ! 1153: { ! 1154: _cmdGate->runAction( (IOCommandGate::Action) ! 1155: &IONetworkController::_enableSyncRequestFilter, ! 1156: (void *) false ); ! 1157: } ! 1158: ! 1159: //--------------------------------------------------------------------------- ! 1160: // Get request client. Methods that are called by syncRequest() can call this ! 1161: // to get the client object which initiated the request. ! 1162: // ! 1163: // Returns the request client. If the caller's context does not indicate ! 1164: // that it is running through syncRequest(), then 0 is returned. ! 1165: ! 1166: OSObject * IONetworkController::getSyncRequestClient() const ! 1167: { ! 1168: return ( _workLoop->inGate() ? _reqClient : 0 ); ! 1169: } ! 1170: ! 1171: //--------------------------------------------------------------------------- ! 1172: // Configure an interface object created through ! 1173: // createInterface(). IONetworkController will register ! 1174: // its output handler with the interface object provided. ! 1175: // Subclasses may override this method to customize the interface object. ! 1176: // Once the interface is registered and opened by a client, it will ! 1177: // refuse changes to its properties. And since this method is called ! 1178: // before the interface has become registered, this is a final ! 1179: // opportunity for the controller to configure the interface. ! 1180: // ! 1181: // interface: The interface object to be configured. ! 1182: // ! 1183: // Returns true if configuration was successful, false otherwise (this ! 1184: // will cause attachInterface() to fail). ! 1185: ! 1186: bool IONetworkController::configureInterface(IONetworkInterface * interface) ! 1187: { ! 1188: IOOutputAction handler; ! 1189: OSObject * target; ! 1190: bool ret; ! 1191: IONetworkData * stats; ! 1192: ! 1193: if (!OSDynamicCast(IONetworkInterface, interface)) ! 1194: return false; ! 1195: ! 1196: IOOutputQueue * outQueue = getOutputQueue(); ! 1197: ! 1198: // Must register an output handler with the interface object. ! 1199: // The interface will send output packets, and requests (commands) ! 1200: // to its registered output handler. If we allocated an output ! 1201: // queue, then we register the queue as the output handler, ! 1202: // otherwise, we become the output handler. ! 1203: ! 1204: if (outQueue) ! 1205: { ! 1206: target = outQueue; ! 1207: handler = outQueue->getOutputHandler(); ! 1208: ! 1209: stats = outQueue->getStatisticsData(); ! 1210: interface->addNetworkData(stats); ! 1211: } ! 1212: else ! 1213: { ! 1214: target = this; ! 1215: handler = getOutputHandler(); ! 1216: } ! 1217: ret = interface->registerOutputHandler(target, handler); ! 1218: ! 1219: return ret; ! 1220: } ! 1221: ! 1222: bool ! 1223: IONetworkController::configureNetworkInterface(IONetworkInterface * interface) ! 1224: { ! 1225: return true; ! 1226: } ! 1227: ! 1228: //--------------------------------------------------------------------------- ! 1229: // Called by start() to create an optional IOOutputQueue instance to handle ! 1230: // output queueing. The default implementation will always return 0, hence ! 1231: // no output queue will be created. A driver may override this method and ! 1232: // return a subclass of IOOutputQueue. IONetworkController will keep a ! 1233: // reference to the queue created, and will release the object when ! 1234: // IONetworkController is freed. Also see getOutputQueue(). ! 1235: // ! 1236: // Returns a newly allocated and initialized IOOutputQueue instance. ! 1237: ! 1238: IOOutputQueue * IONetworkController::createOutputQueue() ! 1239: { ! 1240: return 0; ! 1241: } ! 1242: ! 1243: IOOutputQueue * IONetworkController::allocateOutputQueue() ! 1244: { ! 1245: return 0; ! 1246: } ! 1247: ! 1248: //--------------------------------------------------------------------------- ! 1249: // Return the output queue allocated though createOutputQueue(). ! 1250: ! 1251: IOOutputQueue * IONetworkController::getOutputQueue() const ! 1252: { ! 1253: return _outputQueue; ! 1254: } ! 1255: ! 1256: //--------------------------------------------------------------------------- ! 1257: // Called by start() to obtain the constraints on the memory buffer ! 1258: // associated with each mbuf allocated through allocatePacket(). ! 1259: // Drivers can override this method to specify their buffer constraints ! 1260: // imposed by their bus master hardware. Note that outbound packets, ! 1261: // those that originate from the network stack, are not subject ! 1262: // to the constraints reported here. ! 1263: // ! 1264: // constraintsP: A pointer to an IOPacketBufferConstraints structure ! 1265: // that that this method is expected to initialize. ! 1266: // See IOPacketBufferConstraints structure definition. ! 1267: ! 1268: void IONetworkController::getPacketBufferConstraints( ! 1269: IOPacketBufferConstraints * constraintsP) const ! 1270: { ! 1271: assert(constraintsP); ! 1272: constraintsP->alignStart = kIOPacketBufferAlign1; ! 1273: constraintsP->alignLength = kIOPacketBufferAlign1; ! 1274: } ! 1275: ! 1276: //--------------------------------------------------------------------------- ! 1277: // Allocates a mbuf chain. Each mbuf in the chain is aligned according to ! 1278: // the constraints from IONetworkController::getPacketBufferConstraints(). ! 1279: // The last mbuf in the chain will be guaranteed to be length aligned if ! 1280: // the 'size' argument is a multiple of the length alignment. ! 1281: // ! 1282: // The m->m_len and m->pkthdr.len fields are updated by this function. ! 1283: // This allows the driver to pass the mbuf chain obtained through this ! 1284: // function to the IOMbufMemoryCursor object directly. ! 1285: // ! 1286: // If (size + alignments) is smaller than MCLBYTES, then this function ! 1287: // will always return a single mbuf header or cluster. ! 1288: // ! 1289: // The allocation is guaranteed not to block. If a packet cannot be ! 1290: // allocated, this function will return NULL. ! 1291: ! 1292: static inline UInt IO_ALIGN_MBUF( ! 1293: struct mbuf * m, ! 1294: UInt size, ! 1295: UInt alignStart, ! 1296: UInt alignLength) ! 1297: { ! 1298: assert(m); ! 1299: UInt not_aligned = mtod(m, UInt) & alignStart; ! 1300: ! 1301: // Align starting address. ! 1302: // ! 1303: if (not_aligned) { ! 1304: not_aligned = alignStart - not_aligned + 1; ! 1305: m->m_data += not_aligned; ! 1306: size -= not_aligned; ! 1307: } ! 1308: ! 1309: // Align buffer length. ! 1310: // ! 1311: if ((not_aligned = size & alignLength)) ! 1312: size -= not_aligned; ! 1313: ! 1314: return size; ! 1315: } ! 1316: ! 1317: #define IO_APPEND_MBUF(head, tail, m) { \ ! 1318: if (tail) { \ ! 1319: (tail)->m_next = (m); \ ! 1320: (tail) = (m); \ ! 1321: } \ ! 1322: else { \ ! 1323: (head) = (tail) = (m); \ ! 1324: (head)->m_pkthdr.len = 0; \ ! 1325: } \ ! 1326: } ! 1327: ! 1328: struct mbuf * IONetworkController::allocatePacket(UInt size) ! 1329: { ! 1330: struct mbuf * head = 0; ! 1331: struct mbuf * tail = 0; ! 1332: ! 1333: while (size) { ! 1334: UInt mbufSize; ! 1335: struct mbuf * m; ! 1336: ! 1337: // Allocate a mbuf, for the initial mbuf segment, allocate a ! 1338: // mbuf header, otherwise a 'normal' mbuf will do. ! 1339: ! 1340: if (head) { ! 1341: MGET(m, M_DONTWAIT, MT_DATA); ! 1342: mbufSize = MLEN; ! 1343: } ! 1344: else { ! 1345: MGETHDR(m, M_DONTWAIT, MT_DATA); ! 1346: mbufSize = MHLEN; ! 1347: } ! 1348: ! 1349: if (!m) goto error; ! 1350: ! 1351: // Append the new mbuf to our chain. ! 1352: ! 1353: IO_APPEND_MBUF(head, tail, m); ! 1354: ! 1355: // If the remaining size exceed the buffer size of a normal mbuf, ! 1356: // then attach a cluster to our mbuf. Currently, the cluster size ! 1357: // is fixed, and the allocated memory is always MCLBYTES in size. ! 1358: ! 1359: if ((size + _alignPadding) > mbufSize) { ! 1360: MCLGET(m, M_DONTWAIT); ! 1361: if ((m->m_flags & M_EXT) == 0) goto error; ! 1362: mbufSize = MCLBYTES; ! 1363: } ! 1364: ! 1365: // mbufSize shall contain the (reduced) capacity of the mbuf after ! 1366: // alignment. ! 1367: // ! 1368: mbufSize = IO_ALIGN_MBUF(m, mbufSize, _alignStart, _alignLength); ! 1369: ! 1370: if (mbufSize > size) { ! 1371: // If we wanted to force all mbufs in the chain to be aligned, ! 1372: // including the last one, then do the following. ! 1373: // ! 1374: // mbufSize -= (mbufSize - size) & ~_alignLength; ! 1375: ! 1376: mbufSize = size; ! 1377: size = 0; ! 1378: } ! 1379: else ! 1380: size -= mbufSize; // decrement the remaining size ! 1381: ! 1382: m->m_len = mbufSize; // update the length for this mbuf ! 1383: head->m_pkthdr.len += mbufSize; // increment the total length ! 1384: } ! 1385: ! 1386: return head; ! 1387: ! 1388: error: ! 1389: if (head) m_freem(head); ! 1390: return 0; ! 1391: } ! 1392: ! 1393: //--------------------------------------------------------------------------- ! 1394: // Release the mbuf back to the free pool. ! 1395: ! 1396: void IONetworkController::freePacket(struct mbuf * m) ! 1397: { ! 1398: assert(m); ! 1399: while (m) m = m_free(m); ! 1400: } ! 1401: ! 1402: static inline bool IO_COPY_MBUF( ! 1403: const struct mbuf * src, ! 1404: struct mbuf * dst, ! 1405: int length) ! 1406: { ! 1407: caddr_t src_dat, dst_dat; ! 1408: int dst_len, src_len; ! 1409: ! 1410: assert(src && dst); ! 1411: ! 1412: dst_len = dst->m_len; ! 1413: dst_dat = dst->m_data; ! 1414: ! 1415: while (src) { ! 1416: ! 1417: src_len = src->m_len; ! 1418: src_dat = src->m_data; ! 1419: ! 1420: if (src_len > length) ! 1421: src_len = length; ! 1422: ! 1423: while (src_len) { ! 1424: ! 1425: if (dst_len >= src_len) { ! 1426: // copy entire src mbuf to dst mbuf. ! 1427: ! 1428: bcopy(src_dat, dst_dat, src_len); ! 1429: length -= src_len; ! 1430: dst_len -= src_len; ! 1431: dst_dat += src_len; ! 1432: src_len = 0; ! 1433: } ! 1434: else { ! 1435: // fill up dst mbuf with some portion of the data in ! 1436: // the src mbuf. ! 1437: ! 1438: bcopy(src_dat, dst_dat, dst_len); // dst_len = 0? ! 1439: length -= dst_len; ! 1440: dst_len = 0; ! 1441: src_len -= dst_len; ! 1442: } ! 1443: ! 1444: // Go to the next destination mbuf segment. ! 1445: ! 1446: if (dst_len == 0) { ! 1447: if (!(dst = dst->m_next)) ! 1448: return (length == 0); ! 1449: dst_len = dst->m_len; ! 1450: dst_dat = dst->m_data; ! 1451: } ! 1452: ! 1453: } /* while (src_len) */ ! 1454: ! 1455: src = src->m_next; ! 1456: ! 1457: } /* while (src) */ ! 1458: ! 1459: return (length == 0); // returns true on success. ! 1460: } ! 1461: ! 1462: //--------------------------------------------------------------------------- ! 1463: // Replace the mbuf pointed by the given pointer with another mbuf. ! 1464: // Drivers can call this method to replace a mbuf before passing the ! 1465: // original mbuf, which contains a received frame, to the network layer. ! 1466: // ! 1467: // mp: A pointer to the original mbuf that shall be updated by this ! 1468: // method to point to the new mbuf. ! 1469: // size: If size is 0, then the new mbuf shall have the same size ! 1470: // as the original mbuf that is being replaced. Otherwise, the new ! 1471: // mbuf shall have the size specified here. ! 1472: // ! 1473: // If mbuf allocation was successful, then the replacement will ! 1474: // take place and the original mbuf will be returned. Otherwise, ! 1475: // a NULL is returned. ! 1476: ! 1477: struct mbuf * IONetworkController::replacePacket(struct mbuf ** mp, ! 1478: UInt size = 0) ! 1479: { ! 1480: assert((mp != NULL) && (*mp != NULL)); ! 1481: ! 1482: struct mbuf * m = *mp; ! 1483: ! 1484: // If size is zero, then size is taken from the source mbuf. ! 1485: // ! 1486: if (size == 0) ! 1487: size = m->m_pkthdr.len; ! 1488: ! 1489: // Allocate a new packet to replace the current packet. ! 1490: // ! 1491: if (!(*mp = allocatePacket(size))) ! 1492: { ! 1493: *mp = m; m = 0; ! 1494: } ! 1495: ! 1496: return m; ! 1497: } ! 1498: ! 1499: //--------------------------------------------------------------------------- ! 1500: // Make a copy of a mbuf, and return the copy. The source mbuf is not modified. ! 1501: // ! 1502: // m: The source mbuf. ! 1503: // size: The number of bytes to copy. If set to 0, then the entire ! 1504: // source mbuf is copied. ! 1505: // ! 1506: // Returns a new mbuf created from the source packet. ! 1507: ! 1508: struct mbuf * IONetworkController::copyPacket(const struct mbuf * m, ! 1509: UInt size = 0) ! 1510: { ! 1511: struct mbuf * mn; ! 1512: ! 1513: assert(m != NULL); ! 1514: ! 1515: // If size is zero, then size is taken from the source mbuf. ! 1516: // ! 1517: if (size == 0) ! 1518: size = m->m_pkthdr.len; ! 1519: ! 1520: // Copy the current mbuf to the new mbuf, and return the new mbuf. ! 1521: // The input mbuf is left intact. ! 1522: // ! 1523: if (!(mn = allocatePacket(size))) ! 1524: return 0; ! 1525: ! 1526: if (!IO_COPY_MBUF(m, mn, size)) ! 1527: { ! 1528: IOLog("IONetworkController: copyPacket failure\n"); ! 1529: freePacket(mn); ! 1530: mn = 0; ! 1531: } ! 1532: ! 1533: return mn; ! 1534: } ! 1535: ! 1536: //--------------------------------------------------------------------------- ! 1537: // Either replace or copy the source mbuf given depending on the amount of ! 1538: // data in the source mbuf. This method will either perform a copy or replace ! 1539: // the source mbuf, whichever is more time efficient. If replaced, then the ! 1540: // original mbuf is returned, and a new mbuf is allocated to take its place. ! 1541: // If copied, the source mbuf is left intact, while a copy is returned that ! 1542: // is just big enough to hold all the data from the source mbuf. ! 1543: // ! 1544: // mp: A pointer to the source mbuf that may be updated by this ! 1545: // method to point to the new mbuf if replaced. ! 1546: // rcvlen: The number of data bytes in the source mbuf. ! 1547: // replacedP: Pointer to a bool that is set to true if the ! 1548: // source mbuf was replaced, or set to false if the ! 1549: // source mbuf was copied. ! 1550: // ! 1551: // Returns a replacement or a copy of the source mbuf, 0 if mbuf ! 1552: // allocation failed. ! 1553: ! 1554: struct mbuf * IONetworkController::replaceOrCopyPacket(struct mbuf ** mp, ! 1555: UInt rcvlen, ! 1556: bool * replacedP) ! 1557: { ! 1558: struct mbuf * m; ! 1559: ! 1560: if ((rcvlen + _alignPadding) > MHLEN) ! 1561: { ! 1562: // Large packet, it is more efficient to allocate a new mbuf ! 1563: // to replace the original mbuf than to make a copy. The new ! 1564: // packet shall have the same size as the original mbuf being ! 1565: // replaced. ! 1566: // ! 1567: m = replacePacket(mp); ! 1568: *replacedP = true; ! 1569: } ! 1570: else { ! 1571: // The copy will fit within a header mbuf. Fine, make a copy ! 1572: // of the original mbuf instead of replacing it. We only copy ! 1573: // the rcvlen bytes, not the entire source mbuf. ! 1574: // ! 1575: assert((mp != NULL) && (*mp != NULL)); ! 1576: m = copyPacket(*mp, rcvlen); ! 1577: *replacedP = false; ! 1578: } ! 1579: ! 1580: return m; ! 1581: } ! 1582: ! 1583: //--------------------------------------------------------------------------- ! 1584: // Used for debugging only. Log the mbuf header. ! 1585: ! 1586: void IONetworkController::_logMbuf(struct mbuf * m) ! 1587: { ! 1588: if (!m) { ! 1589: IOLog("logMbuf: NULL mbuf\n"); ! 1590: return; ! 1591: } ! 1592: ! 1593: while (m) { ! 1594: IOLog("m_next : %08x\n", (UInt) m->m_next); ! 1595: IOLog("m_nextpkt: %08x\n", (UInt) m->m_nextpkt); ! 1596: IOLog("m_len : %d\n", (UInt) m->m_len); ! 1597: IOLog("m_data : %08x\n", (UInt) m->m_data); ! 1598: IOLog("m_type : %08x\n", (UInt) m->m_type); ! 1599: IOLog("m_flags : %08x\n", (UInt) m->m_flags); ! 1600: ! 1601: if (m->m_flags & M_PKTHDR) ! 1602: IOLog("m_pkthdr.len : %d\n", (UInt) m->m_pkthdr.len); ! 1603: ! 1604: if (m->m_flags & M_EXT) { ! 1605: IOLog("m_ext.ext_buf : %08x\n", (UInt) m->m_ext.ext_buf); ! 1606: IOLog("m_ext.ext_size: %d\n", (UInt) m->m_ext.ext_size); ! 1607: } ! 1608: ! 1609: m = m->m_next; ! 1610: } ! 1611: IOLog("\n"); ! 1612: } ! 1613: ! 1614: //--------------------------------------------------------------------------- ! 1615: // Allocate and attache a new IOKernelDebugger client object. ! 1616: // ! 1617: // debuggerP: An IOKernelDebugger handle that is updated by this method ! 1618: // to contain the allocated IOKernelDebugger instance. ! 1619: // ! 1620: // Returns true on success, false otherwise. ! 1621: ! 1622: bool IONetworkController::attachDebuggerClient(IOKernelDebugger ** debugger) ! 1623: { ! 1624: IOKernelDebugger * client; ! 1625: OSString * debuggerString; ! 1626: bool ret = false; ! 1627: bool initOk = false; ! 1628: ! 1629: // We delay some initialization until the first time that ! 1630: // attachInterface() is called by the subclass. ! 1631: // ! 1632: SYNC_REQ(this, &IONetworkController::_controllerIsReady, &initOk); ! 1633: if (!initOk) ! 1634: return false; ! 1635: ! 1636: // Refuse to attach a debugger client if the controller's kIOEnableDebugger ! 1637: // property set to No (first letter starts with 'n' or 'N'). ! 1638: ! 1639: debuggerString = OSDynamicCast(OSString, getProperty(kIOEnableDebugger)); ! 1640: if (!debuggerString || ! 1641: (debuggerString->getChar(0) == 'N') || ! 1642: (debuggerString->getChar(0) == 'n')) ! 1643: return false; ! 1644: ! 1645: // Create a debugger client nub and register the static ! 1646: // member functions as the polled-mode handlers. ! 1647: // ! 1648: client = IOKernelDebugger::debugger(this, ! 1649: &debugTxHandler, ! 1650: &debugRxHandler); ! 1651: ! 1652: *debugger = client; ! 1653: ! 1654: if (client && !client->attach(this)) ! 1655: { ! 1656: // Unable to attach the client object. ! 1657: *debugger = 0; ! 1658: client->detach(this); ! 1659: client->release(); ! 1660: } ! 1661: ! 1662: if (*debugger) ! 1663: { ! 1664: IOLog("%s: Debugger client attached\n", getName()); ! 1665: publishResource("kdp"); ! 1666: ret = true; ! 1667: } ! 1668: ! 1669: return ret; ! 1670: } ! 1671: ! 1672: //--------------------------------------------------------------------------- ! 1673: // Detach and terminate the IOKernelDebugger client object provided. ! 1674: // A synchronous termination is issued, and this method returns after ! 1675: // the client has been terminated. ! 1676: // ! 1677: // debugger: The IOKernelDebugger instance to be detached and terminated. ! 1678: // If the argument provided is NULL or is not an IOKernelDebugger, ! 1679: // this method will return immediately. ! 1680: ! 1681: void IONetworkController::detachDebuggerClient(IOKernelDebugger * debugger) ! 1682: { ! 1683: if (OSDynamicCast(IOKernelDebugger, debugger) == 0) ! 1684: return; ! 1685: ! 1686: // Terminate the debugger client and return after the client has ! 1687: // been terminated. Since the debugger has no IOKit clients of ! 1688: // its own, this should be fast. ! 1689: ! 1690: debugger->terminate(kIOServiceRequired | kIOServiceSynchronous); ! 1691: } ! 1692: ! 1693: //--------------------------------------------------------------------------- ! 1694: // An enable request from an IOKernelDebugger client. This method is called ! 1695: // when an open is received from an IOKernelDebugger client. Drivers that ! 1696: // wish to provide debugging services must override this method and setup ! 1697: // the hardware to support the polled-mode send and receive methods; ! 1698: // receivePacket() and sendPacket(). Debug capable drivers may also override ! 1699: // the more generic enable/disable calls that take an IOService argument. ! 1700: // ! 1701: // debugger: The IOKernelDebugger client that issued the open. ! 1702: // ! 1703: // Returns kIOReturnSuccess. The driver method must return kIOReturnSuccess ! 1704: // to allow the debugger open, anything else will cause the debugger open ! 1705: // to fail and the attachDebuggerClient() method will return false. ! 1706: ! 1707: IOReturn IONetworkController::enable(IOKernelDebugger * debugger) ! 1708: { ! 1709: return handleDebuggerOpen(debugger); ! 1710: } ! 1711: ! 1712: IOReturn IONetworkController::handleDebuggerOpen(IOKernelDebugger * debugger) ! 1713: { ! 1714: return kIOReturnSuccess; ! 1715: } ! 1716: ! 1717: //--------------------------------------------------------------------------- ! 1718: // A disable request from an IOKernelDebugger client. This method is called ! 1719: // when a close is received from an IOKernelDebugger client. A driver which ! 1720: // implements enable(IOKernelDebugger *) should also implement this method ! 1721: // to disable hardware support for the polled-mode send and receive methods. ! 1722: // ! 1723: // debugger: The IOKernelDebugger client that issued the close. ! 1724: // ! 1725: // Returns kIOReturnSuccess. The driver method should return a status ! 1726: // from the disable operation. ! 1727: ! 1728: IOReturn IONetworkController::disable(IOKernelDebugger * debugger) ! 1729: { ! 1730: return handleDebuggerClose(debugger); ! 1731: } ! 1732: ! 1733: IOReturn IONetworkController::handleDebuggerClose(IOKernelDebugger * debugger) ! 1734: { ! 1735: return kIOReturnSuccess; ! 1736: } ! 1737: ! 1738: //--------------------------------------------------------------------------- ! 1739: // Take and release the debugger lock. ! 1740: ! 1741: void IONetworkController::reserveDebuggerLock() ! 1742: { ! 1743: _debugLockState = IODebuggerLock(this); ! 1744: } ! 1745: ! 1746: void IONetworkController::releaseDebuggerLock() ! 1747: { ! 1748: IODebuggerUnlock(_debugLockState); ! 1749: } ! 1750: ! 1751: //--------------------------------------------------------------------------- ! 1752: // This static C++ member function is registered by attachDebuggerClient() ! 1753: // as the debugger receive handler. IOKernelDebugger will call this ! 1754: // function when KDP is polling for a received packet. This function will ! 1755: // in turn will call the receivePacket() member function implemented by ! 1756: // a driver with debugger support. ! 1757: ! 1758: void IONetworkController::debugRxHandler(IOService * handler, ! 1759: void * buffer, ! 1760: UInt * length, ! 1761: UInt timeout) ! 1762: { ! 1763: ((IONetworkController *) handler)->receivePacket(buffer, ! 1764: length, ! 1765: timeout); ! 1766: } ! 1767: ! 1768: //--------------------------------------------------------------------------- ! 1769: // This static C++ member function is registered by attachDebuggerClient() ! 1770: // as the debugger transmit handler. IOKernelDebugger will call this ! 1771: // function when KDP sends an outgoing packet. This function will in turn ! 1772: // call the sendPacket() member function implemented by a driver with ! 1773: // debugger support. ! 1774: ! 1775: void IONetworkController::debugTxHandler(IOService * handler, ! 1776: void * buffer, ! 1777: UInt length) ! 1778: { ! 1779: ((IONetworkController *) handler)->sendPacket(buffer, length); ! 1780: } ! 1781: ! 1782: //--------------------------------------------------------------------------- ! 1783: // Debugger polled-mode receive handler. This method must be implemented ! 1784: // by a driver that supports kernel debugging. After a debugger client is ! 1785: // attached through attachDebuggerClient(), this method will be called by ! 1786: // the debugger object to poll for a incoming packet when the debugger is ! 1787: // active. This method can be called from an interrupt context, and the ! 1788: // driver must never block or perform any memory allocation. The ! 1789: // receivePacket() method in IONetworkController is used as a placeholder ! 1790: // and should never be called. A driver that attaches a debugger client ! 1791: // must override this method. ! 1792: // ! 1793: // pkt: Pointer to a receive buffer where the received packet should ! 1794: // be stored to. The buffer has room for 1518 bytes. ! 1795: // pkt_len: The length of the received packet must be written to the ! 1796: // integer pointed by pkt_len. ! 1797: // timeout: The maximum amount of time in milliseconds to poll for ! 1798: // a packet to arrive before this method must return. ! 1799: ! 1800: void IONetworkController::receivePacket(void * /*pkt*/, ! 1801: UInt * /*pkt_len*/, ! 1802: UInt /*timeout*/) ! 1803: { ! 1804: IOLog("IONetworkController::%s()\n", __FUNCTION__); ! 1805: } ! 1806: ! 1807: //--------------------------------------------------------------------------- ! 1808: // Debugger polled-mode transmit handler. This method must be implemented ! 1809: // by a driver that supports kernel debugging. After a debugger client is ! 1810: // attached through attachDebuggerClient(), this method will be called by ! 1811: // the debugger object to send an outbound packet generated by the debugger. ! 1812: // This method can be called from an interrupt context, and the ! 1813: // driver must never block or perform any memory allocation. The ! 1814: // sendPacket() method in IONetworkController is used as a placeholder ! 1815: // and should never be called. A driver that attaches a debugger client ! 1816: // must override this method. ! 1817: // ! 1818: // pkt: Pointer to a transmit buffer containing the packet to be sent. ! 1819: // pkt_len: The amount of data in the transmit buffer. ! 1820: ! 1821: void IONetworkController::sendPacket(void * /*pkt*/, UInt /*pkt_len*/) ! 1822: { ! 1823: IOLog("IONetworkController::%s()\n", __FUNCTION__); ! 1824: } ! 1825: ! 1826: //--------------------------------------------------------------------------- ! 1827: // Report the link status and the active medium. Update the link status ! 1828: // parameters published by the controller. Drivers should call this method ! 1829: // whenever the link status changes. Never call this method from interrupt ! 1830: // context since this method may block. An event will be sent to all attached ! 1831: // interface objects when a change is detected. ! 1832: // ! 1833: // status: Link status bits. See IONetworkMedium.h for defined link ! 1834: // status bits. ! 1835: // speed: Link speed in units of bits per second. ! 1836: // activeMedium: A medium entry in the published medium dictionary ! 1837: // where the link was established. This may not be the ! 1838: // same as the current medium. ! 1839: // data: An OSData containing any additional link information. ! 1840: // ! 1841: // Returns true if all link properties were successfully updated, ! 1842: // false otherwise. ! 1843: ! 1844: bool IONetworkController::setLinkStatus(UInt32 status, ! 1845: UInt64 speed, ! 1846: const IONetworkMedium * activeMedium, ! 1847: OSData * data = 0) ! 1848: { ! 1849: bool ret; ! 1850: bool changed = false; ! 1851: ! 1852: MEDIUM_LOCK; ! 1853: ! 1854: ret = setMediumProperty(gIOActiveMediumKey, ! 1855: activeMedium, ! 1856: &_activeMedium, ! 1857: false, ! 1858: &changed); ! 1859: ! 1860: ret = setLink32Property(kIOLinkStatus, ! 1861: status, ! 1862: &_linkStatus, ! 1863: false, ! 1864: &changed) && ret; ! 1865: ! 1866: ret = setLink64Property(kIOLinkSpeed, ! 1867: speed, ! 1868: &_linkSpeed, ! 1869: false, ! 1870: &changed) && ret; ! 1871: ! 1872: if (data) { ! 1873: if (_linkData != data) { ! 1874: ret = setProperty(kIOLinkData, data) && ret; ! 1875: _linkData = data; ! 1876: changed = true; ! 1877: } ! 1878: } ! 1879: else if (_linkData) { ! 1880: _linkData = 0; ! 1881: removeProperty(kIOLinkData); ! 1882: changed = true; ! 1883: } ! 1884: ! 1885: MEDIUM_UNLOCK; ! 1886: ! 1887: if (changed) ! 1888: broadcastEvent(kIONetworkEventLinkChange); ! 1889: ! 1890: return ret; ! 1891: } ! 1892: ! 1893: //--------------------------------------------------------------------------- ! 1894: // Returns the medium dictionary published by the driver through ! 1895: // publishMediumDictionary(). Use copyMediumDictionary() to get a copy ! 1896: // of the medium dictionary. ! 1897: // ! 1898: // Returns the published medium dictionary, or 0 if the driver has not ! 1899: // yet published a medium dictionary using publishMediumDictionary(). ! 1900: ! 1901: const OSDictionary * IONetworkController::getMediumDictionary() const ! 1902: { ! 1903: return OSDynamicCast(OSDictionary, getProperty(kIOMediumDictionary)); ! 1904: } ! 1905: ! 1906: //--------------------------------------------------------------------------- ! 1907: // Returns a.copy of the medium dictionary published by the driver. ! 1908: // The caller is responsible for releasing the dictionary object returned. ! 1909: // Use getMediumDictionary() to get a reference to the published medium ! 1910: // dictionary instead of creating a copy. ! 1911: // ! 1912: // Returns a copy of the medium dictionary, or 0 if the driver has not ! 1913: // published a medium dictionary using publishMediumDictionary(). ! 1914: ! 1915: OSDictionary * IONetworkController::copyMediumDictionary() const ! 1916: { ! 1917: OSDictionary * newMediumDict = 0; ! 1918: ! 1919: MEDIUM_LOCK; ! 1920: ! 1921: if (getMediumDictionary()) { ! 1922: newMediumDict = OSDictionary::withDictionary(getMediumDictionary(), ! 1923: getMediumDictionary()->getCount()); ! 1924: } ! 1925: ! 1926: MEDIUM_UNLOCK; ! 1927: ! 1928: return newMediumDict; ! 1929: } ! 1930: ! 1931: //--------------------------------------------------------------------------- ! 1932: // A client request for the controller to change the selected medium. ! 1933: // Drivers may override this method and provide an implementation ! 1934: // appropriate for its hardware, then call setCurrentMedium() to update ! 1935: // the current medium property if a change occurred. ! 1936: // ! 1937: // medium: An entry in the published medium dictionary. ! 1938: // ! 1939: // Return kIOReturnUnsupported. Drivers may override this method and ! 1940: // return kIOReturnSuccess if the selected medium was activated, ! 1941: // or an error code otherwise. ! 1942: ! 1943: IOReturn IONetworkController::selectMedium(const IONetworkMedium * medium) ! 1944: { ! 1945: return kIOReturnUnsupported; ! 1946: } ! 1947: ! 1948: //--------------------------------------------------------------------------- ! 1949: // Private function to lookup a key in the medium dictionary and call ! 1950: // setMedium() if a match is found. This function is called by our ! 1951: // clients to change the medium by passing a name for the desired medium. ! 1952: ! 1953: IOReturn IONetworkController::selectMediumWithName(const OSSymbol * mediumName) ! 1954: { ! 1955: OSSymbol * currentMediumName; ! 1956: IONetworkMedium * newMedium = 0; ! 1957: bool doChange = true; ! 1958: IOReturn ret = kIOReturnSuccess; ! 1959: ! 1960: if (OSDynamicCast(OSSymbol, mediumName) == 0) ! 1961: return kIOReturnBadArgument; ! 1962: ! 1963: MEDIUM_LOCK; ! 1964: ! 1965: do { ! 1966: const OSDictionary * mediumDict = getMediumDictionary(); ! 1967: if (!mediumDict) { // no medium dictionary, bail out. ! 1968: ret = kIOReturnUnsupported; ! 1969: break; ! 1970: } ! 1971: ! 1972: // Lookup the new medium in the dictionary. ! 1973: // ! 1974: newMedium = OSDynamicCast(IONetworkMedium, ! 1975: mediumDict->getObject(mediumName)); ! 1976: if (!newMedium) { ! 1977: ret = kIOReturnBadArgument; ! 1978: break; // not found, invalid mediumName. ! 1979: } ! 1980: ! 1981: newMedium->retain(); ! 1982: ! 1983: // Lookup the current medium key to avoid unnecessary ! 1984: // medium changes. ! 1985: // ! 1986: currentMediumName = (OSSymbol *) getProperty(gIOCurrentMediumKey); ! 1987: ! 1988: // Is change necessary? ! 1989: // ! 1990: if (currentMediumName && mediumName->isEqualTo(currentMediumName)) ! 1991: doChange = false; ! 1992: } ! 1993: while (0); ! 1994: ! 1995: MEDIUM_UNLOCK; ! 1996: ! 1997: if (newMedium) ! 1998: { ! 1999: // Call the driver's selectMedium() without holding the medium lock. ! 2000: ! 2001: if (doChange) ! 2002: ret = selectMedium(newMedium); ! 2003: ! 2004: // offset the earlier retain count increment. ! 2005: // ! 2006: newMedium->release(); ! 2007: } ! 2008: ! 2009: return ret; ! 2010: } ! 2011: ! 2012: //--------------------------------------------------------------------------- ! 2013: // Private function to add/replace/remove a medium property in the ! 2014: // property table. Returns true if the medium property was successfully ! 2015: // added to the property table. The medium lock should be held before ! 2016: // calling this function. ! 2017: ! 2018: bool IONetworkController::setMediumProperty(const OSSymbol * key, ! 2019: const IONetworkMedium * medium, ! 2020: const IONetworkMedium ** cache, ! 2021: bool force, ! 2022: bool * changed) ! 2023: { ! 2024: bool ret = false; ! 2025: ! 2026: do { ! 2027: if (!force && (*cache == medium)) ! 2028: { ! 2029: ret = true; ! 2030: break; ! 2031: } ! 2032: ! 2033: if (medium == 0) ! 2034: { ! 2035: removeProperty(key); ! 2036: if (changed) *changed = true; ! 2037: *cache = 0; ! 2038: ret = true; ! 2039: break; ! 2040: } ! 2041: ! 2042: const OSDictionary * mediumDict = getMediumDictionary(); ! 2043: if (!mediumDict) ! 2044: break; // no medium dictionary, bail out. ! 2045: ! 2046: if (OSDynamicCast(IONetworkMedium, medium) == 0) ! 2047: break; // not a valid IONetworkMedium. ! 2048: ! 2049: // Make sure the medium given is an entry in the medium dictionary. ! 2050: // ! 2051: if (mediumDict->getObject(medium->getName()) != (OSObject *) medium) ! 2052: break; // not a member of dictionary. ! 2053: ! 2054: // Update property table. ! 2055: // ! 2056: if ((ret = setProperty(key, (OSSymbol *) medium->getName()))) ! 2057: { ! 2058: if (changed) *changed = true; ! 2059: *cache = medium; ! 2060: } ! 2061: } ! 2062: while (0); ! 2063: ! 2064: return ret; ! 2065: } ! 2066: ! 2067: bool IONetworkController::setLink64Property(const char * key, ! 2068: UInt64 value, ! 2069: UInt64 * cache, ! 2070: bool force = false, ! 2071: bool * changed = 0) ! 2072: { ! 2073: if (!force && (*cache == value)) ! 2074: return true; ! 2075: ! 2076: if (setProperty(key, value, 64)) ! 2077: { ! 2078: if (changed) *changed = true; ! 2079: *cache = value; ! 2080: return true; ! 2081: } ! 2082: ! 2083: return false; ! 2084: } ! 2085: ! 2086: bool IONetworkController::setLink32Property(const char * key, ! 2087: UInt32 value, ! 2088: UInt32 * cache, ! 2089: bool force = false, ! 2090: bool * changed = 0) ! 2091: { ! 2092: if (!force && (*cache == value)) ! 2093: return true; ! 2094: ! 2095: if (setProperty(key, value, 32)) ! 2096: { ! 2097: if (changed) *changed = true; ! 2098: *cache = value; ! 2099: return true; ! 2100: } ! 2101: ! 2102: return false; ! 2103: } ! 2104: ! 2105: //--------------------------------------------------------------------------- ! 2106: // From the set of medium objects in the medium dictionary published by the ! 2107: // driver, one of them can be designated as the currently selected medium. ! 2108: // Drivers should call this method whenever their media selection changes. ! 2109: // An entry in the driver's property table is updated to advertise the ! 2110: // current medium. ! 2111: // ! 2112: // A media change event will be broadcasted to all attached interface ! 2113: // clients when the current medium property changes. ! 2114: // ! 2115: // medium: A medium object to promote as the current medium. ! 2116: // ! 2117: // Returns true if the medium dictionary exists, the medium object ! 2118: // provided matches an entry in this dictionary, and the property ! 2119: // table update was successful, false otherwise. ! 2120: ! 2121: bool IONetworkController::setCurrentMedium(const IONetworkMedium * medium) ! 2122: { ! 2123: bool ret, changed; ! 2124: ! 2125: MEDIUM_LOCK; ! 2126: ret = setMediumProperty(gIOCurrentMediumKey, ! 2127: medium, ! 2128: &_currentMedium, ! 2129: false, ! 2130: &changed); ! 2131: MEDIUM_UNLOCK; ! 2132: ! 2133: if (changed) ! 2134: broadcastEvent(kIONetworkEventMediumChange); ! 2135: ! 2136: return ret; ! 2137: } ! 2138: ! 2139: //--------------------------------------------------------------------------- ! 2140: // Returns the currently selected medium object. If the driver has yet to ! 2141: // assign an entry in its medium dictionary as the current medium using the ! 2142: // setCurrentMedium() method, then the driver's property table is consulted ! 2143: // and a default medium property (can be set by the user), is looked ! 2144: // up and the corresponding entry in the medium dictionary is returned. ! 2145: // Therefore, drivers can always call getCurrentMedium() to either get ! 2146: // the current medium selected by the driver, or the default ! 2147: // medium chosen by the user. ! 2148: // ! 2149: // Returns the current medium entry from the medium dictionary, or 0 ! 2150: // if a matching entry was not found. ! 2151: ! 2152: const IONetworkMedium * IONetworkController::getCurrentMedium() const ! 2153: { ! 2154: IONetworkMedium * currentMedium = 0; ! 2155: OSString * currentMediumName = 0; ! 2156: ! 2157: MEDIUM_LOCK; ! 2158: ! 2159: do { ! 2160: const OSDictionary * mediumDict = getMediumDictionary(); ! 2161: if (!mediumDict) // no medium dictionary, bail out. ! 2162: break; ! 2163: ! 2164: // Fetch the current medium name from the property table. ! 2165: // ! 2166: currentMediumName = OSDynamicCast(OSString, ! 2167: getProperty(gIOCurrentMediumKey)); ! 2168: ! 2169: // Make sure the current medium name points to an entry in ! 2170: // the medium dictionary. ! 2171: // ! 2172: if (currentMediumName && !mediumDict->getObject(currentMediumName)) ! 2173: currentMediumName = 0; ! 2174: ! 2175: if (currentMediumName == 0) { ! 2176: OSString * defaultMediumName; ! 2177: ! 2178: // No (valid) current medium name, try the default medium name. ! 2179: // ! 2180: defaultMediumName = OSDynamicCast(OSString, ! 2181: getProperty(kIODefaultMedium)); ! 2182: ! 2183: // If there is a default medium name, and it points to a ! 2184: // valid entry in the medium dictionary, then make it ! 2185: // current. ! 2186: // ! 2187: if (defaultMediumName && ! 2188: mediumDict->getObject(defaultMediumName)) ! 2189: { ! 2190: // setProperty(kIOCurrentMedium, defaultMediumKey); ! 2191: currentMediumName = defaultMediumName; ! 2192: } ! 2193: } ! 2194: ! 2195: if (currentMediumName) ! 2196: currentMedium = OSDynamicCast(IONetworkMedium, ! 2197: mediumDict->getObject(currentMediumName)); ! 2198: } ! 2199: while (0); ! 2200: ! 2201: MEDIUM_UNLOCK; ! 2202: ! 2203: return currentMedium; ! 2204: } ! 2205: ! 2206: //--------------------------------------------------------------------------- ! 2207: // A private function to verify a medium dictionary. Returns true if the ! 2208: // dictionary is OK. ! 2209: ! 2210: bool IONetworkController::verifyMediumDictionary( ! 2211: const OSDictionary * mediumDict) ! 2212: { ! 2213: OSCollectionIterator * iter; ! 2214: bool verifyOk = true; ! 2215: OSSymbol * key; ! 2216: ! 2217: if (!OSDynamicCast(OSDictionary, mediumDict)) ! 2218: return false; // invalid argument ! 2219: ! 2220: if (mediumDict->getCount() == 0) ! 2221: return false; // empty dictionary ! 2222: ! 2223: iter = OSCollectionIterator::withCollection((OSDictionary *) mediumDict); ! 2224: if (!iter) ! 2225: return false; // cannot allocate iterator ! 2226: ! 2227: while ((key = (OSSymbol *) iter->getNextObject())) ! 2228: { ! 2229: if ( !OSDynamicCast(IONetworkMedium, mediumDict->getObject(key)) ) ! 2230: { ! 2231: verifyOk = false; // non-medium object in dictionary ! 2232: break; ! 2233: } ! 2234: } ! 2235: ! 2236: iter->release(); ! 2237: ! 2238: return verifyOk; ! 2239: } ! 2240: ! 2241: //--------------------------------------------------------------------------- ! 2242: // Called by drivers to publish their medium dictionary. ! 2243: // The dictionary consist of IONetworkMedium entries that represent ! 2244: // the entire media selection supported by the hardware. This method ! 2245: // will make a copy of the provided dictionary, then add the copy to ! 2246: // the driver's property table. The dictionary provided can be ! 2247: // released after this call returns. It is permissible to call ! 2248: // this method multiple times, which may be necessary if the hardware's ! 2249: // media capability changes dynamically. However, if this were not ! 2250: // so, then drivers will typically call this method from its start() ! 2251: // implementation, after the hardware capability is discovered. ! 2252: // ! 2253: // Several methods depend on the presence of a medium dictionary. ! 2254: // They should be called after the dictionary has been published. ! 2255: // Those are: ! 2256: // selectMedium() ! 2257: // setCurrentMedium() ! 2258: // getCurrentMedium() ! 2259: // getMediumDictionary() ! 2260: // copyMediumDictionary() ! 2261: // ! 2262: // Calling publishMediumDictionary() will cause a media change event ! 2263: // to be delivered to all attached interface clients. ! 2264: // ! 2265: // Returns true if the dictionary is valid, and was successfully ! 2266: // added to the property table, false otherwise. ! 2267: ! 2268: bool ! 2269: IONetworkController::publishMediumDictionary(const OSDictionary * mediumDict) ! 2270: { ! 2271: OSDictionary * cloneDict; ! 2272: bool ret = false; ! 2273: ! 2274: if (!verifyMediumDictionary(mediumDict)) ! 2275: return false; // invalid dictionary ! 2276: ! 2277: // Create a clone of the source dictionary. This prevents the driver ! 2278: // from adding/removing entries after the medium dictionary is added ! 2279: // to the property table. ! 2280: // ! 2281: cloneDict = OSDictionary::withDictionary(mediumDict, ! 2282: mediumDict->getCount()); ! 2283: if (!cloneDict) ! 2284: return false; // unable to create a copy ! 2285: ! 2286: MEDIUM_LOCK; ! 2287: ! 2288: // Add the dictionary to the property table. ! 2289: // ! 2290: if (setProperty(kIOMediumDictionary, cloneDict)) ! 2291: { ! 2292: const OSSymbol * mediumName; ! 2293: IONetworkMedium * medium; ! 2294: ! 2295: mediumName = (OSSymbol *) getProperty(gIOCurrentMediumKey); ! 2296: medium = mediumName ? ! 2297: (IONetworkMedium *) cloneDict->getObject(mediumName) : 0; ! 2298: setMediumProperty(gIOCurrentMediumKey, medium, &_currentMedium, true); ! 2299: ! 2300: mediumName = (OSSymbol *) getProperty(gIOActiveMediumKey); ! 2301: medium = mediumName ? ! 2302: (IONetworkMedium *) cloneDict->getObject(mediumName) : 0; ! 2303: setMediumProperty(gIOActiveMediumKey, medium, &_activeMedium, true); ! 2304: ! 2305: ret = true; ! 2306: } ! 2307: ! 2308: MEDIUM_UNLOCK; ! 2309: ! 2310: // Retained by the property table. drop our retain count. ! 2311: // ! 2312: cloneDict->release(); ! 2313: ! 2314: // Broadcast a medium change event. ! 2315: // ! 2316: broadcastEvent(kIONetworkEventMediumChange); ! 2317: ! 2318: return ret; ! 2319: } ! 2320: ! 2321: //--------------------------------------------------------------------------- ! 2322: // Call enablePacketFilters() through syncRequest(). See enablePacketFilters(). ! 2323: ! 2324: IOReturn IONetworkController::doEnablePacketFilters(IOService * client, ! 2325: UInt32 newFilters, ! 2326: UInt32 * activeFiltersP) ! 2327: { ! 2328: IOReturn ret = kIOReturnNotReady; ! 2329: UInt32 dummy; ! 2330: UInt32 * activeP = activeFiltersP ? activeFiltersP : &dummy; ! 2331: ! 2332: *activeP = 0; ! 2333: ! 2334: if (SYNC_REQ(client, &IONetworkController::enablePacketFilters, ! 2335: &ret, ! 2336: (void *) newFilters, (void *) activeP) == kIOReturnSuccess) ! 2337: { ! 2338: // Update the registry. ! 2339: // ! 2340: setProperty(kIOActivePacketFilters, *activeP, 32); ! 2341: } ! 2342: ! 2343: return ret; ! 2344: } ! 2345: ! 2346: //--------------------------------------------------------------------------- ! 2347: // Calls getPacketFilters() through syncRequest(). See getPacketFilters(). ! 2348: ! 2349: IOReturn IONetworkController::doGetPacketFilters(IOService * client, ! 2350: UInt32 * filtersP) ! 2351: { ! 2352: DO_SYNC_REQ(getPacketFilters, (void *) filtersP) ! 2353: } ! 2354: ! 2355: //--------------------------------------------------------------------------- ! 2356: // Call enable(IOService *) through syncRequest(). See enable(). ! 2357: ! 2358: IOReturn IONetworkController:: doEnable(IOService * client) ! 2359: { ! 2360: DO_SYNC_REQ(_enable, (void *) client) ! 2361: } ! 2362: ! 2363: //--------------------------------------------------------------------------- ! 2364: // Call disable(IOService *) through syncRequest(). See disable(). ! 2365: ! 2366: IOReturn IONetworkController:: doDisable(IOService * client) ! 2367: { ! 2368: DO_SYNC_REQ(_disable, (void *) client) ! 2369: } ! 2370: ! 2371: //--------------------------------------------------------------------------- ! 2372: // Call getControllerIndex() through syncRequest(). See getControllerIndex(). ! 2373: ! 2374: IOReturn IONetworkController::doGetControllerIndex(IOService * client, ! 2375: UInt32 * index) ! 2376: { ! 2377: DO_SYNC_REQ(getControllerIndex, (void *) index) ! 2378: } ! 2379: ! 2380: //--------------------------------------------------------------------------- ! 2381: // Call setMaxTransferUnit() through syncRequest(). See setMaxTransferUnit(). ! 2382: ! 2383: IOReturn IONetworkController::doSetMaxTransferUnit(IOService * client, ! 2384: UInt32 mtu) ! 2385: { ! 2386: DO_SYNC_REQ(setMaxTransferUnit, (void *) mtu) ! 2387: } ! 2388: ! 2389: //--------------------------------------------------------------------------- ! 2390: // Call selectMedium() through syncRequest(). See selectMedium(). ! 2391: ! 2392: IOReturn IONetworkController::doSelectMedium(IOService * client, ! 2393: const OSSymbol * mediumName) ! 2394: { ! 2395: DO_SYNC_REQ(selectMediumWithName, (void *) mediumName) ! 2396: } ! 2397: ! 2398: //--------------------------------------------------------------------------- ! 2399: // Call setOutputQueueCapacity() through syncRequest(). ! 2400: // See setOutputQueueCapacity(). ! 2401: ! 2402: IOReturn IONetworkController::doSetOutputQueueCapacity(IOService * client, ! 2403: UInt32 capacity) ! 2404: { ! 2405: DO_SYNC_REQ(setOutputQueueCapacity, (void *) capacity) ! 2406: } ! 2407: ! 2408: //--------------------------------------------------------------------------- ! 2409: // Call getOutputQueueCapacity() through syncRequest(). ! 2410: // See getOutputQueueCapacity(). ! 2411: ! 2412: IOReturn ! 2413: IONetworkController::doGetOutputQueueCapacity(IOService * client, ! 2414: UInt32 * capacityP) ! 2415: { ! 2416: DO_SYNC_REQ(getOutputQueueCapacity, (void *) capacityP) ! 2417: } ! 2418: ! 2419: //--------------------------------------------------------------------------- ! 2420: // Call getOutputQueueSize() through syncRequest(). ! 2421: // See getOutputQueueSize(). ! 2422: ! 2423: IOReturn ! 2424: IONetworkController::doGetOutputQueueSize(IOService * client, ! 2425: UInt32 * sizeP) ! 2426: { ! 2427: DO_SYNC_REQ(getOutputQueueSize, (void *) sizeP) ! 2428: } ! 2429: ! 2430: //--------------------------------------------------------------------------- ! 2431: // Call flushOutputQueue() through syncRequest(). See flushOutputQueue(). ! 2432: ! 2433: IOReturn ! 2434: IONetworkController::doFlushOutputQueue(IOService * client, ! 2435: UInt32 * flushCountP) ! 2436: { ! 2437: DO_SYNC_REQ(flushOutputQueue, (void *) flushCountP) ! 2438: } ! 2439: ! 2440: //--------------------------------------------------------------------------- ! 2441: // Call performDiagnostics() through syncRequest(). ! 2442: // See performDiagnostics(). ! 2443: ! 2444: IOReturn ! 2445: IONetworkController::doPerformDiagnostics(IOService * client, ! 2446: UInt32 * failureCode) ! 2447: { ! 2448: DO_SYNC_REQ(performDiagnostics, (void *) failureCode) ! 2449: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.