![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to i82557.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Drivers / network / drvIntel82557|
Return to i82557.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Drivers / network / drvIntel82557 |
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) 1996 NeXT Software, Inc. All rights reserved.
24: *
25: * i82557.cpp
26: *
27: * HISTORY
28: *
29: * 22-Jan-96 Dieter Siegmund (dieter) at NeXT
30: * Created.
31: *
32: * 03-May-96 Dieter Siegmund (dieter) at NeXT
33: * Added a real ISR to improve performance.
34: *
35: * 10-June-96 Dieter Siegmund (dieter) at NeXT
36: * Added support for Splash 3 (10 Base-T only card).
37: *
38: * 18-June-96 Dieter Siegmund (dieter) at NeXT
39: * Keep the transmit queue draining by interrupting every
40: * N / 2 transmits (where N is the size of the hardware queue).
41: *
42: * 15-Dec-97 Joe Liu (jliu) at Apple
43: * Updated PHY programming to be 82558 aware.
44: * Misc changes to conform to new 82558 register flags.
45: * Changed RNR interrupt handler to restart RU instead of a reset.
46: * Interrupt handler now does a thread_call_func() to do most of its work.
47: * Interrupts are disabled until the thread callout finishes its work.
48: * Increased the size of TX/RX rings.
49: * buffer object removed, we use cluster mbufs to back up the receive ring.
50: *
51: * 29-May-98 Joe Liu (jliu) at Apple
52: * Updated _setupPhy method to take advantage of parallel detection whenever
53: * possible in order to detect the proper link speed.
54: *
55: * 17-Aug-98 Joe Liu (jliu) at Apple
56: * Re-enabled the setting of txready_sel PHY (PCS) bit for DP83840.
57: * Simplified interrupt handling, resulting in RCV performance improvements.
58: * Receive packets are sent upstream via a cached function pointer.
59: */
60:
61: #include "i82557.h"
62:
63: #define ONE_SECOND_TICKS 1000
64: #define LOAD_STATISTICS_INTERVAL (4 * ONE_SECOND_TICKS)
65:
66: #define super IOEthernetController
67: OSDefineMetaClassAndStructors( Intel82557, IOEthernetController )
68:
69: //---------------------------------------------------------------------------
70: // Function: init <IORegistryEntry>
71: //
72: // Initialize the driver instance and prepare it for a probe() call.
73:
74: bool Intel82557::init(OSDictionary * properties)
75: {
76: return super::init(properties);
77: }
78:
79: //---------------------------------------------------------------------------
80: // Function: probe <IOService>
81: //
82: // Probe for the presence of Intel82557 by reading the PCI vendor ID
83: // from the PCI nub.
84:
85: IOService * Intel82557::probe(IOService * provider,
86: SInt32 * score)
87: {
88: IOPCIDevice * pciNub = OSDynamicCast(IOPCIDevice, provider);
89: UInt32 pciID;
90:
91: if (!pciNub) return 0;
92:
93: // Check PCI device ID.
94: //
95: pciID = pciNub->configRead32(PCI_CFID_OFFSET);
96: switch (pciID) {
97: case PCI_CFID_INTEL82557:
98: break;
99: default:
100: // IOLog("%s: Unknown device ID %08lx\n", getName(), pciID);
101: return 0;
102: }
103:
104: return super::probe(provider, score);
105: }
106:
107: //---------------------------------------------------------------------------
108: // Function: pciConfigInit
109: //
110: // Update PCI command register to enable the memory-mapped range,
111: // and bus-master interface.
112:
113: bool Intel82557::pciConfigInit(IOPCIDevice * provider)
114: {
115: UInt32 reg;
116:
117: reg = provider->configRead32(PCI_CFCS_OFFSET);
118: reg |= (0x04 | 0x02 | 0x10); // Master, Memory, PCI-MWI
119: reg &= ~0x01; // disable I/O space
120: provider->configWrite32(PCI_CFCS_OFFSET, reg);
121:
122: return true;
123: }
124:
125: //---------------------------------------------------------------------------
126: // Function: initDriver
127: //
128: // Create and initialize the driver objects before the hardware is
129: // enabled.
130: //
131: // Returns true on sucess, and false if initialization failed.
132:
133: bool Intel82557::initDriver(IOService * provider)
134: {
135: currentMediumType = MEDIUM_TYPE_INVALID;
136:
137: // This driver will allocate and use an IOOQGateFIFOQueue.
138: //
139: transmitQueue = OSDynamicCast(IOOQGateFIFOQueue, getOutputQueue());
140: if (!transmitQueue)
141: return false;
142: transmitQueue->retain();
143:
144: // Allocate two IOMBufLittleMemoryCursor instances. One for transmit and
145: // the other for receive.
146: //
147: rxMbufCursor = IOMBufLittleMemoryCursor::withSpecification(MAX_BUF_SIZE,1);
148: txMbufCursor = IOMBufLittleMemoryCursor::withSpecification(MAX_BUF_SIZE,
149: TBDS_PER_TCB);
150: if (!rxMbufCursor || !txMbufCursor)
151: return false;
152:
153: // Get a handle to our superclass' workloop.
154: //
155: IOWorkLoop * myWorkLoop = (IOWorkLoop *) getWorkLoop();
156: if (!myWorkLoop)
157: return false;
158:
159: // Create and register an interrupt event source. The provider will
160: // take care of the low-level interrupt registration stuff.
161: //
162: #if USE_FILTER_INTERRUPT_EVENT_SRC
163: interruptSrc =
164: IOFilterInterruptEventSource::filterInterruptEventSource(this,
165: (IOInterruptEventAction) &Intel82557::interruptOccurred,
166: (IOFilterInterruptAction) &Intel82557::checkForInterrupt,
167: provider);
168: #else
169: interruptSrc =
170: IOInterruptEventSource::interruptEventSource(this,
171: (IOInterruptEventAction) &Intel82557::interruptOccurred,
172: provider);
173: #endif
174: if (!interruptSrc ||
175: (myWorkLoop->addEventSource(interruptSrc) != kIOReturnSuccess))
176: return false;
177:
178: // Register a timer event source. This is used as a watchdog timer.
179: //
180: timerSrc = IOTimerEventSource::timerEventSource(this,
181: (IOTimerEventSource::Action) &Intel82557::timeoutOccurred);
182: if (!timerSrc ||
183: (myWorkLoop->addEventSource(timerSrc) != kIOReturnSuccess))
184: return false;
185:
186: // Create a dictionary to hold IONetworkMedium objects.
187: //
188: mediumDict = OSDictionary::withCapacity(5);
189: if (!mediumDict)
190: return false;
191:
192: return true;
193: }
194:
195: //---------------------------------------------------------------------------
196: // Function: getDefaultSettings
197: //
198: // Get the default driver settings chosen by the user. The properties
199: // are all stored in our property table (an OSDictionary).
200: // For convenience, all properties are OSNumbers.
201:
202: bool Intel82557::getDefaultSettings()
203: {
204: OSNumber * offset;
205:
206: // Check for PHY address override.
207: //
208: phyAddr = PHY_ADDRESS_DEFAULT;
209: offset = OSDynamicCast(OSNumber, getProperty("PHY Address"));
210: if (offset) {
211: phyAddr = offset->unsigned32BitValue();
212: }
213:
214: // Check for Verbose flag.
215: //
216: verbose = false;
217: offset = OSDynamicCast(OSNumber, getProperty("Verbose"));
218: if (offset && offset->unsigned32BitValue()) {
219: IOLog("%s: verbose mode enabled\n", getName());
220: verbose = true;
221: }
222:
223: // Check for Flow-Control enable flag.
224: //
225: flowControl = false;
226: offset = OSDynamicCast(OSNumber, getProperty("Flow Control"));
227: if (offset && offset->unsigned32BitValue()) {
228: IOLog("%s: 802.3x flow control enabled\n", getName());
229: flowControl = true;
230: }
231:
232: return true;
233: }
234:
235: //---------------------------------------------------------------------------
236: // Function: start <IOService>
237: //
238: // Hardware was detected and initialized, start the driver.
239:
240: bool Intel82557::start(IOService * provider)
241: {
242: IOPCIDevice * pciNub = OSDynamicCast(IOPCIDevice, provider);
243:
244: // Start our superclass first.
245: //
246: if (!pciNub || !super::start(provider))
247: return false;
248:
249: // Initialize the driver's event sources and other support objects.
250: //
251: if (!initDriver(provider))
252: return false;
253:
254: // Get the virtual address mapping of CSR registers located at
255: // Base Address Range 0 (0x10). The size of this range is 4K.
256: //
257: csrMap = pciNub->mapDeviceMemoryWithRegister(PCI_BAR0_OFFSET);
258: if (!csrMap)
259: return false;
260: CSR_p = (CSR_t *) csrMap->getVirtualAddress();
261:
262: // Enables the bus-master and turns on memory space decoding.
263: //
264: if (!pciConfigInit(pciNub))
265: return false;
266:
267: // Create the EEPROM object.
268: //
269: eeprom = i82557eeprom::withAddress(&CSR_p->eepromControl);
270: if (!eeprom) {
271: IOLog("%s: couldn't allocate eeprom object", getName());
272: return false;
273: }
274:
275: // Get default driver settings.
276: //
277: if (!getDefaultSettings())
278: return false;
279:
280: if (verbose)
281: eeprom->dumpContents();
282:
283: // Execute one-time initialization code.
284: //
285: if (!coldInit()) {
286: IOLog("%s: coldInit failed\n", getName());
287: return false;
288: }
289:
290: if (!hwInit()) {
291: IOLog("%s: hwInit failed\n", getName());
292: return false;
293: }
294:
295: // Publish our media capabilities.
296: //
297: _phyPublishMedia();
298: if (!publishMediumDictionary(mediumDict)) {
299: IOLog("%s: publishMediumDictionary failed\n", getName());
300: return false;
301: }
302:
303: // Announce the basic hardware configuration info.
304: //
305: IOLog("%s: Memory 0x%lx irq %d\n",
306: getName(), csrMap->getPhysicalAddress(), 0);
307:
308: // Allocate and attach an IOEthernetInterface instance to this driver
309: // object.
310: //
311: if (!attachInterface((IONetworkInterface **) &netif, false))
312: return false;
313:
314: // Attach a kernel debugger client.
315: //
316: attachDebuggerClient(&debugger);
317:
318: netif->registerService();
319:
320: return true;
321: }
322:
323: //---------------------------------------------------------------------------
324: // Function: stop <IOService>
325: //
326: // Stop all activities and prepare for termination.
327:
328: void Intel82557::stop(IOService * provider)
329: {
330: #if 0 // This belongs in stop()?
331: if (resetAndEnabled == YES) { /* shut down the hardware */
332: [self disableAdapterInterrupts];
333: resetAndEnabled = NO;
334: }
335: #endif
336: }
337:
338: bool Intel82557::configureInterface(IONetworkInterface * netif)
339: {
340: IONetworkData * param;
341:
342: if (super::configureInterface(netif) == false)
343: return false;
344:
345: // Get the generic network statistics structure.
346: //
347: param = netif->getParameter(kIONetworkStatsKey);
348: if (!param || !(netStats = (IONetworkStats *) param->getBuffer())) {
349: return false;
350: }
351:
352: // Get the Ethernet statistics structure.
353: //
354: param = netif->getParameter(kIOEthernetStatsKey);
355: if (!param || !(etherStats = (IOEthernetStats *) param->getBuffer())) {
356: return false;
357: }
358:
359: return true;
360: }
361:
362: //---------------------------------------------------------------------------
363: // Function: free <IOService>
364: //
365: // Deallocate all resources and destroy the instance.
366:
367: void Intel82557::free()
368: {
369: if (debugger) debugger->release();
370: if (netif) netif->release();
371: if (transmitQueue) transmitQueue->release();
372: if (interruptSrc) interruptSrc->release();
373: if (timerSrc) timerSrc->release();
374: if (rxMbufCursor) rxMbufCursor->release();
375: if (txMbufCursor) txMbufCursor->release();
376: if (csrMap) csrMap->release();
377: if (eeprom) eeprom->release();
378: if (mediumDict) mediumDict->release();
379:
380: _freeMemPage(&shared);
381: _freeMemPage(&txRing);
382: _freeMemPage(&rxRing);
383:
384: super::free(); // pass it to our superclass
385: }
386:
387: //---------------------------------------------------------------------------
388: // Function: enableAdapter
389: //
390: // Enables the adapter & driver to the given level of support.
391:
392: bool Intel82557::enableAdapter(UInt32 level)
393: {
394: bool ret = false;
395:
396: // IOLog("%s::%s enabling level %ld\n", getName(), __FUNCTION__, level);
397:
398: switch (level) {
399: case kAdapterLevel1:
400: if (!_initRingBuffers())
401: break;
402:
403: if (!_startReceive()) {
404: _clearRingBuffers();
405: break;
406: }
407:
408: // Set current medium.
409: //
410: if (setMedium(getCurrentMedium()) != kIOReturnSuccess)
411: IOLog("%s: setMedium error\n", getName());
412:
413: // Start the watchdog timer.
414: //
415: timerSrc->setTimeoutMS(LOAD_STATISTICS_INTERVAL);
416:
417: // Enable interrupt event sources and hardware interrupts.
418: //
419: if (getWorkLoop())
420: getWorkLoop()->enableAllInterrupts();
421: enableAdapterInterrupts();
422:
423: ret = true;
424: break;
425:
426: case kAdapterLevel2:
427: // Issue a dump statistics command.
428: //
429: _dumpStatistics();
430:
431: // Start our IOOutputQueue object.
432: //
433: transmitQueue->setCapacity(TRANSMIT_QUEUE_SIZE);
434: transmitQueue->start();
435:
436: ret = true;
437: break;
438: }
439:
440: if (!ret)
441: IOLog("%s::%s error in level %ld\n", getName(), __FUNCTION__, level);
442:
443: return ret;
444: }
445:
446: //---------------------------------------------------------------------------
447: // Function: disableAdapter
448: //
449: // Disables the adapter & driver to the given level of support.
450:
451: bool Intel82557::disableAdapter(UInt32 level)
452: {
453: bool ret = false;
454:
455: // IOLog("%s::%s disabling level %ld\n", getName(), __FUNCTION__, level);
456:
457: switch (level) {
458: case kAdapterLevel1:
459: // Disable interrupt handling and hardware interrupt sources.
460: //
461: disableAdapterInterrupts();
462: if (getWorkLoop())
463: getWorkLoop()->disableAllInterrupts();
464:
465: // Stop the timer event source, and initialize the watchdog state.
466: //
467: timerSrc->cancelTimeout();
468: packetsReceived = true; // assume we're getting packets
469: packetsTransmitted = false;
470: txCount = 0;
471:
472: // Reset the hardware engine.
473: //
474: ret = hwInit();
475:
476: // Clear the descriptor rings after the hardware is idle.
477: //
478: _clearRingBuffers();
479:
480: // Report no link.
481: //
482: setLinkStatus(kIONetworkLinkValid, 0, 0);
483:
484: // Flush all packets held in the queue and prevent it
485: // from accumulating any additional packets.
486: //
487: transmitQueue->setCapacity(0);
488: transmitQueue->flush();
489:
490: break;
491:
492: case kAdapterLevel2:
493: // Stop the transmit queue. outputPacket() will not get called
494: // after this.
495: //
496: transmitQueue->stop();
497:
498: ret = true;
499: break;
500: }
501:
502: if (!ret)
503: IOLog("%s::%s error in level %ld\n", getName(), __FUNCTION__, level);
504:
505: return ret;
506: }
507:
508: //---------------------------------------------------------------------------
509: // Function: setAdapterLevel
510: //
511: // Sets the adapter's run level depending on the type of client present.
512: //
513: // kAdapterLevel0 - Adapter is disabled.
514: // kAdapterLevel1 - Adapter is brought up just enough to support debugging.
515: // kAdapterLevel2 - Adapter is completely up.
516:
517: bool Intel82557::setAdapterLevel(UInt32 newLevel)
518: {
519: bool ret = false;
520: UInt32 nextLevel;
521:
522: // IOLog("---> DESIRED LEVEL : %d\n", newLevel);
523:
524: if (currentLevel == newLevel)
525: return true;
526:
527: for ( ; currentLevel > newLevel; currentLevel--)
528: {
529: if ((ret = disableAdapter(currentLevel)) == false)
530: break;
531: }
532:
533: for (nextLevel = currentLevel + 1; currentLevel < newLevel;
534: currentLevel++, nextLevel++)
535: {
536: if ((ret = enableAdapter(nextLevel)) == false)
537: break;
538: }
539:
540: // IOLog("---> PRESENT LEVEL : %d\n\n", currentLevel);
541:
542: return ret;
543: }
544:
545: //---------------------------------------------------------------------------
546: // Function: enable <IONetworkController>
547: //
548: // A request from our interface client to enable the adapter.
549:
550: IOReturn Intel82557::enable(IONetworkInterface * /*netif*/)
551: {
552: if (enabledForNetif)
553: return kIOReturnSuccess;
554:
555: enabledForNetif = setAdapterLevel(kAdapterLevel2);
556:
557: return (enabledForNetif ? kIOReturnSuccess : kIOReturnIOError);
558: }
559:
560: //---------------------------------------------------------------------------
561: // Function: disable <IONetworkController>
562: //
563: // A request from our interface client to disable the adapter.
564:
565: IOReturn Intel82557::disable(IONetworkInterface * /*netif*/)
566: {
567: enabledForNetif = false;
568:
569: if (enabledForDebugger)
570: setAdapterLevel(kAdapterLevel1);
571: else
572: setAdapterLevel(kAdapterLevel0);
573:
574: return kIOReturnSuccess;
575: }
576:
577: //---------------------------------------------------------------------------
578: // Function: enable <IONetworkController>
579: //
580: // A request from our debugger client to enable the adapter.
581:
582: IOReturn Intel82557::enable(IOKernelDebugger * /*debugger*/)
583: {
584: if (enabledForDebugger || enabledForNetif) {
585: enabledForDebugger = true;
586: return kIOReturnSuccess;
587: }
588:
589: enabledForDebugger = setAdapterLevel(kAdapterLevel1);
590:
591: return (enabledForDebugger ? kIOReturnSuccess : kIOReturnIOError);
592: }
593:
594: //---------------------------------------------------------------------------
595: // Function: disable <IONetworkController>
596: //
597: // A request from our debugger client to disable the adapter.
598:
599: IOReturn Intel82557::disable(IOKernelDebugger * /*debugger*/)
600: {
601: enabledForDebugger = false;
602:
603: if (!enabledForNetif)
604: setAdapterLevel(kAdapterLevel0);
605:
606: return kIOReturnSuccess;
607: }
608:
609: //---------------------------------------------------------------------------
610: // Function: timeoutOccurred
611: //
612: // Periodic timer that monitors the receiver status, updates error
613: // and collision statistics, and update the current link status.
614:
615: void Intel82557::timeoutOccurred(IOTimerEventSource * /*timer*/)
616: {
617: if ((packetsReceived == false) && (packetsTransmitted == true)) {
618: /*
619: * The B-step of the i82557 requires that an mcsetup command be
620: * issued if the receiver stops receiving. This is a documented
621: * errata.
622: */
623: mcSetup(0, 0, true);
624: }
625: packetsReceived = packetsTransmitted = false;
626:
627: _updateStatistics();
628:
629: updateLinkStatus();
630:
631: timerSrc->setTimeoutMS(LOAD_STATISTICS_INTERVAL);
632: }
633:
634: //---------------------------------------------------------------------------
635: // Function: setPromiscuousMode <IOEthernetController>
636:
637: IOReturn Intel82557::setPromiscuousMode(IOEnetPromiscuousMode mode)
638: {
639: bool rv;
640: promiscuousEnabled = (mode == kIOEnetPromiscuousModeOff) ? false : true;
641: reserveDebuggerLock();
642: rv = config();
643: releaseDebuggerLock();
644: return (rv ? kIOReturnSuccess : kIOReturnIOError);
645: }
646:
647: //---------------------------------------------------------------------------
648: // Function: setMulticastMode <IOEthernetController>
649:
650: IOReturn Intel82557::setMulticastMode(IOEnetMulticastMode mode)
651: {
652: multicastEnabled = (mode == kIOEnetMulticastModeOff) ? false : true;
653: return kIOReturnSuccess;
654: }
655:
656: //---------------------------------------------------------------------------
657: // Function: setMulticastList <IOEthernetController>
658:
659: IOReturn Intel82557::setMulticastList(enet_addr_t * addrs, UInt count)
660: {
661: IOReturn ret = kIOReturnSuccess;
662:
663: if (!mcSetup(addrs, count)) {
664: IOLog("%s: set multicast list failed\n", getName());
665: ret = kIOReturnIOError;
666: }
667: return ret;
668: }
669:
670: //---------------------------------------------------------------------------
671: // Function: getPacketBufferConstraints <IONetworkController>
672: //
673: // Return our driver's packet alignment requirements.
674:
675: void
676: Intel82557::getPacketBufferConstraints(IOPacketBufferConstraints * constraints) const
677: {
678: constraints->alignStart = kIOPacketBufferAlign2; // even word aligned.
679: constraints->alignLength = kIOPacketBufferAlign1; // no restriction.
680: }
681:
682: //---------------------------------------------------------------------------
683: // Function: getHardwareAddress <IOEthernetController>
684: //
685: // Return the adapter's hardware address.
686:
687: IOReturn Intel82557::getHardwareAddress(enet_addr_t * addrs)
688: {
689: bcopy(&myAddress, addrs, sizeof(*addrs));
690: return kIOReturnSuccess;
691: }
692:
693: //---------------------------------------------------------------------------
694: // Function: allocateOutputQueue <IONetworkController>
695: //
696: // Allocate an IOOQGateFIFOQueue instance.
697:
698: IOOutputQueue * Intel82557::createOutputQueue()
699: {
700: return IOOQGateFIFOQueue::withTarget(this, getWorkLoop());
701: }
702:
703: //---------------------------------------------------------------------------
704: // Function: updateLinkStatus
705: //
706: // Get the current link status and call the inherited setLinkStatus()
707: // function to update the status. This function is called periodically
708: // by timeoutOccurred() to poll the current link status.
709:
710: void Intel82557::updateLinkStatus()
711: {
712: bool linkUp;
713: IONetworkMedium * activeMedium = 0;
714: UInt32 linkStatus = kIONetworkLinkValid;
715: UInt64 linkSpeed = 0;
716: mediumType_t activeMediumType;
717:
718: // Query the hardware for the current active medium, and the link
719: // status flag.
720: //
721: if (_phyGetLinkStatus(&linkUp,
722: &activeMediumType,
723: currentMediumType) == false) {
724: return;
725: }
726:
727: if (linkUp) {
728: linkStatus |= kIONetworkLinkActive;
729:
730: // Link speeds are fixed per medium. Get the speed from the active
731: // medium.
732: //
733: activeMedium = _phyGetMediumWithCode(activeMediumType);
734: if (activeMedium)
735: linkSpeed = activeMedium->getSpeed();
736: }
737:
738: // Update the link status properties.
739: //
740: if (!setLinkStatus(linkStatus, linkSpeed, activeMedium))
741: IOLog("%s: setLinkStatus error\n", getName());
742: }
743:
744: //---------------------------------------------------------------------------
745: // Function: setMedium <IONetworkController>
746: //
747: // Transition the controller/PHY to use a new medium. Note that
748: // this function can be called my the driver, or by our client.
749:
750: IOReturn Intel82557::setMedium(const IONetworkMedium * medium)
751: {
752: bool r;
753:
754: if (!OSDynamicCast(IONetworkMedium, medium))
755: return kIOReturnBadArgument;
756:
757: #if 0
758: IOLog("%s: setMedium -> %s\n", getName(),
759: medium->getName()->getCStringNoCopy());
760: #endif
761:
762: // Program PHY.
763: //
764: r = _phySetMedium((mediumType_t) medium->getIndex());
765:
766: // Update the current medium property.
767: //
768: if (r && !setCurrentMedium(medium))
769: IOLog("%s: setCurrentMedium error\n", getName());
770:
771: return (r ? kIOReturnSuccess : kIOReturnIOError);
772: }
773:
774: //---------------------------------------------------------------------------
775: // Function: getVendorString(), getModelString(), getRevisionString()
776: // <IONetworkController>
777: //
778: // Report human readable hardware information strings.
779:
780: const char * Intel82557::getVendorString() const
781: {
782: return ("Intel");
783: }
784:
785: const char * Intel82557::getModelString() const
786: {
787: const char * model = 0;
788:
789: assert(eeprom && eeprom->getContents());
790:
791: switch(eeprom->getContents()->controllerType) {
792: case I82558_CONTROLLER_TYPE:
793: model = "82558";
794: break;
795: case I82557_CONTROLLER_TYPE:
796: default:
797: model = "82557";
798: break;
799: }
800: return model;
801: }
802:
803: const char * Intel82557::getRevisionString() const
804: {
805: return NULL;
806: }
807:
808: //---------------------------------------------------------------------------
809: // Kernel debugger entry points.
810: //
811: // KDP driven polling routines to send and transmit a frame.
812: // Remember, no memory allocation! Not even mbufs are safe.
813:
814: void Intel82557::sendPacket(void * pkt, UInt pkt_len)
815: {
816: _sendPacket(pkt, pkt_len);
817: }
818:
819: void Intel82557::receivePacket(void * pkt, UInt * pkt_len, UInt timeout)
820: {
821: _receivePacket(pkt, pkt_len, timeout);
822: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.