![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IOPCIDevice.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Families / IOPCIBus|
Return to IOPCIDevice.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Families / IOPCIBus |
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) 1998 Apple Computer, Inc. All rights reserved. ! 24: * ! 25: * HISTORY ! 26: * 23 Nov 98 sdouglas created from objc version. ! 27: */ ! 28: ! 29: #include <IOKit/system.h> ! 30: ! 31: #include <IOKit/pci/IOPCIBridge.h> ! 32: #include <IOKit/pci/IOPCIDevice.h> ! 33: #include <IOKit/pci/IOAGPDevice.h> ! 34: #include <IOKit/IOPlatformExpert.h> ! 35: ! 36: #include <IOKit/IOLib.h> ! 37: #include <IOKit/assert.h> ! 38: ! 39: #include <libkern/c++/OSContainers.h> ! 40: ! 41: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ ! 42: ! 43: #define super IOService ! 44: ! 45: OSDefineMetaClassAndStructors(IOPCIDevice, IOService) ! 46: ! 47: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ ! 48: ! 49: // stub driver has two power states, off and on ! 50: #define number_of_power_states 2 ! 51: ! 52: static IOPMPowerState ourPowerStates[number_of_power_states] = { ! 53: {1,IOPMNotAttainable,0,0,0,0,0,0,0,0,0,0}, ! 54: {1,IOPMNotAttainable,0,IOPMPowerOn,0,0,0,0,0,0,0,0} ! 55: }; ! 56: ! 57: ! 58: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ ! 59: // attach ! 60: // ! 61: // If the device is an expansion slot device, ! 62: // we volunteer to do power managment for the device, ! 63: // and all we do is request power stay on. The effect is ! 64: // to prevent system sleep. If a driver is loaded which can ! 65: // power manage the device, it will contact us and we ! 66: // will relinquish this control. This prevents the system ! 67: // from sleeping when there are non-power-managed ! 68: // PCI cards installed. ! 69: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ ! 70: bool IOPCIDevice::attach( IOService * provider ) ! 71: { ! 72: if ( getProperty("AAPL,slot-name") != NULL ) { ! 73: PMinit(); // initialize superclass variables ! 74: pm_vars->thePlatform->PMRegisterDevice((IOService *)this,(IOService *)this); // register as policy-maker ! 75: registerControllingDriver(this,ourPowerStates,number_of_power_states); // register as controlling driver ! 76: changeStateToPriv( number_of_power_states-1); // clamp power on ! 77: } ! 78: return super::attach(provider); ! 79: } ! 80: ! 81: ! 82: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ ! 83: // maxCapabilityForDomainState ! 84: // ! 85: // If the power domain is supplying power, the device ! 86: // can be on. If there is no power it can only be off. ! 87: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ ! 88: unsigned long IOPCIDevice::maxCapabilityForDomainState( ! 89: IOPMPowerFlags domainState ) ! 90: { ! 91: if( domainState & IOPMPowerOn ) ! 92: return number_of_power_states-1; ! 93: else ! 94: return 0; ! 95: } ! 96: ! 97: ! 98: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ ! 99: // initialPowerStateForDomainState ! 100: // ! 101: // This is our first information about the power domain state. ! 102: // If power is on in the new state, the device is on. ! 103: // If domain power is off, the device is also off. ! 104: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ ! 105: unsigned long IOPCIDevice::initialPowerStateForDomainState( ! 106: IOPMPowerFlags domainState ) ! 107: { ! 108: if( domainState & IOPMPowerOn ) ! 109: return number_of_power_states-1; ! 110: else ! 111: return 0; ! 112: } ! 113: ! 114: ! 115: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ ! 116: // powerStateForDomainState ! 117: // ! 118: // The power domain may be changing state. ! 119: // If power is on in the new state, the device will be on. ! 120: // If domain power is off, the device will be off. ! 121: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ ! 122: unsigned long IOPCIDevice::powerStateForDomainState( ! 123: IOPMPowerFlags domainState ) ! 124: { ! 125: if( domainState & IOPMPowerOn ) ! 126: return pm_vars->myCurrentState; ! 127: else ! 128: return 0; ! 129: } ! 130: ! 131: ! 132: //********************************************************************************* ! 133: // joinPMtree ! 134: // ! 135: // A policy-maker for our PCI device calls here when initializing, ! 136: // to be attached into the power management hierarchy. ! 137: // We are currently the (stub) policy-maker for the device, so we ! 138: // attach this driver and then pull ourselves out of the picture. ! 139: // ! 140: // This overrides the default function of the IOService joinPMtree. ! 141: //********************************************************************************* ! 142: void IOPCIDevice::joinPMtree ( IOService * driver ) ! 143: { ! 144: if ( getProperty("AAPL,slot-name") != NULL ) { ! 145: pm_vars->myParent->addChild(driver); // attach new driver to our parent ! 146: changeStateToPriv(0); // release our clamp ! 147: pm_vars->myParent->removeChild(this); // detach ourselves ! 148: PMstop(); // free structures, etc. ! 149: } ! 150: else { ! 151: super::joinPMtree(driver); // oops, they shouldn't have called here ! 152: } ! 153: } ! 154: ! 155: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ ! 156: ! 157: bool IOPCIDevice::matchPropertyTable( OSDictionary * table ) ! 158: { ! 159: return( parent->matchNubWithPropertyTable( this, table )); ! 160: } ! 161: ! 162: bool IOPCIDevice::compareName( OSString * name, OSString ** matched = 0 ) const ! 163: { ! 164: return( parent->compareNubName( this, name, matched )); ! 165: } ! 166: ! 167: IOReturn IOPCIDevice::getResources( void ) ! 168: { ! 169: return( parent->getNubResources( this )); ! 170: } ! 171: ! 172: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ ! 173: ! 174: UInt32 IOPCIDevice::configRead32( IOPCIAddressSpace _space, ! 175: UInt8 offset ) ! 176: { ! 177: return( parent->configRead32( _space, offset & 0xfc )); ! 178: } ! 179: ! 180: void IOPCIDevice::configWrite32( IOPCIAddressSpace _space, ! 181: UInt8 offset, UInt32 data ) ! 182: { ! 183: parent->configWrite32( _space, offset & 0xfc, data ); ! 184: } ! 185: ! 186: UInt32 IOPCIDevice::configRead32( UInt8 offset ) ! 187: { ! 188: return( parent->configRead32( space, offset & 0xfc )); ! 189: } ! 190: ! 191: void IOPCIDevice::configWrite32( UInt8 offset, UInt32 data ) ! 192: { ! 193: parent->configWrite32( space, offset & 0xfc, data ); ! 194: } ! 195: ! 196: UInt32 IOPCIDevice::findPCICapability( UInt8 capabilityID ) ! 197: { ! 198: return( parent->configRead32( space, capabilityID )); ! 199: } ! 200: ! 201: UInt32 IOPCIDevice::setConfigBits( UInt8 reg, UInt32 mask, UInt32 value ) ! 202: { ! 203: UInt32 was; ! 204: UInt32 bits; ! 205: ! 206: bits = configRead32( reg ); ! 207: was = (bits & mask); ! 208: bits &= ~mask; ! 209: bits |= (value & mask); ! 210: configWrite32( reg, bits ); ! 211: ! 212: return( was ); ! 213: } ! 214: ! 215: bool IOPCIDevice::setBusMasterEnable( bool enable ) ! 216: { ! 217: return( 0 != setConfigBits( kIOPCIConfigCommand, kIOPCICommandBusMaster, ! 218: enable ? kIOPCICommandBusMaster : 0)); ! 219: } ! 220: ! 221: bool IOPCIDevice::setMemoryEnable( bool enable ) ! 222: { ! 223: return( 0 != setConfigBits( kIOPCIConfigCommand, kIOPCICommandMemorySpace, ! 224: enable ? kIOPCICommandMemorySpace : 0)); ! 225: } ! 226: ! 227: bool IOPCIDevice::setIOEnable( bool enable, bool /* exclusive = false */ ) ! 228: { ! 229: // exclusive is TODO. ! 230: return( 0 != setConfigBits( kIOPCIConfigCommand, kIOPCICommandIOSpace, ! 231: enable ? kIOPCICommandIOSpace : 0)); ! 232: } ! 233: ! 234: UInt8 IOPCIDevice::getBusNumber( void ) ! 235: { ! 236: return( space.s.busNum ); ! 237: } ! 238: ! 239: UInt8 IOPCIDevice::getDeviceNumber( void ) ! 240: { ! 241: return( space.s.deviceNum ); ! 242: } ! 243: ! 244: UInt8 IOPCIDevice::getFunctionNumber( void ) ! 245: { ! 246: return( space.s.functionNum ); ! 247: } ! 248: ! 249: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ ! 250: ! 251: IODeviceMemory * IOPCIDevice::getDeviceMemoryWithRegister( UInt8 reg ) ! 252: { ! 253: OSArray * array; ! 254: IODeviceMemory * range; ! 255: unsigned int i = 0; ! 256: ! 257: array = (OSArray *) getProperty( gIODeviceMemoryKey); ! 258: if( 0 == array) ! 259: return( 0); ! 260: ! 261: while( (range = (IODeviceMemory *) array->getObject( i++ ))) { ! 262: if( reg == (range->getTag() & 0xff)) ! 263: break; ! 264: } ! 265: ! 266: return( range); ! 267: } ! 268: ! 269: IOMemoryMap * IOPCIDevice:: mapDeviceMemoryWithRegister( UInt8 reg, ! 270: IOOptionBits options = 0 ) ! 271: { ! 272: IODeviceMemory * range; ! 273: IOMemoryMap * map; ! 274: ! 275: range = getDeviceMemoryWithRegister( reg ); ! 276: if( range) ! 277: map = range->map( options ); ! 278: else ! 279: map = 0; ! 280: ! 281: return( map ); ! 282: } ! 283: ! 284: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ ! 285: ! 286: IODeviceMemory * IOPCIDevice::ioDeviceMemory( void ) ! 287: { ! 288: return( parent->ioDeviceMemory() ); ! 289: } ! 290: ! 291: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ ! 292: ! 293: IOService * IOPCIDevice::matchLocation( IOService * /* client */ ) ! 294: { ! 295: return( this ); ! 296: } ! 297: ! 298: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ ! 299: ! 300: #undef super ! 301: #define super IOPCIDevice ! 302: ! 303: OSDefineMetaClassAndStructors(IOAGPDevice, IOPCIDevice) ! 304: ! 305: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ ! 306: ! 307: IOReturn IOAGPDevice::createAGPSpace( IOOptionBits options, ! 308: IOPhysicalAddress * address, ! 309: IOPhysicalLength * length ) ! 310: { ! 311: return( parent->createAGPSpace( space, options, address, length )); ! 312: } ! 313: ! 314: IOReturn IOAGPDevice::destroyAGPSpace( void ) ! 315: { ! 316: return( parent->destroyAGPSpace( space )); ! 317: } ! 318: ! 319: IORangeAllocator * IOAGPDevice::getAGPRangeAllocator( void ) ! 320: { ! 321: return( parent->getAGPRangeAllocator( space )); ! 322: } ! 323: ! 324: IOOptionBits IOAGPDevice::getAGPStatus( IOOptionBits options = 0 ) ! 325: { ! 326: return( parent->getAGPStatus( space, options )); ! 327: } ! 328: ! 329: IOReturn IOAGPDevice::commitAGPMemory( IOMemoryDescriptor * memory, ! 330: IOByteCount agpOffset, ! 331: IOOptionBits options = 0 ) ! 332: { ! 333: return( parent->commitAGPMemory ( space, memory, agpOffset, options )); ! 334: } ! 335: ! 336: IOReturn IOAGPDevice::releaseAGPMemory( IOMemoryDescriptor * memory, ! 337: IOByteCount agpOffset ) ! 338: { ! 339: return( parent->releaseAGPMemory ( space, memory, agpOffset )); ! 340: } ! 341:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.