git.saurik.com Git - apple/xnu.git/blob - iokit/IOKit/IOPlatformExpert.h

1 /*

3 *

4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@

5 *

6 * This file contains Original Code and/or Modifications of Original Code

7 * as defined in and that are subject to the Apple Public Source License

8 * Version 2.0 (the 'License'). You may not use this file except in

9 * compliance with the License. The rights granted to you under the License

10 * may not be used to create, or enable the creation or redistribution of,

11 * unlawful or unlicensed copies of an Apple operating system, or to

12 * circumvent, violate, or enable the circumvention or violation of, any

13 * terms of an Apple operating system software license agreement.

14 *

15 * Please obtain a copy of the License at

16 * http://www.opensource.apple.com/apsl/ and read it before using this file.

17 *

18 * The Original Code and all software distributed under the License are

19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER

20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,

21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,

22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.

23 * Please see the License for the specific language governing rights and

24 * limitations under the License.

25 *

26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@

27 */

28 /*

30 *

31 * HISTORY

32 *

33 */

36 #ifndef _IOKIT_IOPLATFORMEXPERT_H

37 #define _IOKIT_IOPLATFORMEXPERT_H

39 #ifdef __cplusplus

40 #include <IOKit/IOLib.h>

41 #include <IOKit/IOService.h>

42 #include <IOKit/IOInterrupts.h>

43 #include <IOKit/IOInterruptController.h>

44 #include <libkern/c++/OSPtr.h>

46 extern "C" {

47 #else

48 #include <kern/clock.h>

49 #endif

51 #include <libkern/OSTypes.h>

53 typedef enum {

54 kCoprocessorVersionNone = 0x00000000,

55 kCoprocessorVersion1 = 0x00010000,

56 kCoprocessorVersion2 = 0x00020000,

57 } coprocessor_type_t;

60 /*

61 * PEGetMachineName() and PEGetModelName() are inconsistent across

62 * architectures, and considered deprecated.

63 * PEGetTargetName() and PEGetProductName() instead.

64 */

 extern boolean_t PEGetMachineName( char * name, int maxLength );

 extern boolean_t PEGetModelName( char * name, int maxLength );

 extern boolean_t PEGetTargetName( char * name, int maxLength );

 extern boolean_t PEGetProductName( char * name, int maxLength );

 extern int PEGetPlatformEpoch( void );

72 enum {

73 kPEHaltCPU,

74 kPERestartCPU,

75 kPEHangCPU,

76 kPEUPSDelayHaltCPU,

77 kPEPanicRestartCPU,

78 kPEPanicSync,

79 kPEPagingOff,

80 kPEPanicBegin,

81 kPEPanicEnd,

82 kPEPanicRestartCPUNoCallouts,

83 kPEPanicDiagnosticsDone,

84 };

86 /* Bitmask of details related to panic callouts */

87 #define kPanicDetailsForcePowerOff 0x1

 extern int (*PE_halt_restart)(unsigned int type);

 extern int PEHaltRestart(unsigned int type);

92 #ifdef XNU_KERNEL_PRIVATE

 extern int PEHaltRestartInternal(unsigned int type, uint32_t details);

96 enum {

97 kIOSystemShutdownNotificationStageProcessExit = 0,

98 kIOSystemShutdownNotificationStageRootUnmount = 1,

99 kIOSystemShutdownNotificationTerminateDEXTs = 2,

100 };

 extern void IOSystemShutdownNotification(int stage);

102

103 extern uint32_t gEnforceQuiesceSafety;

104 #endif /* XNU_KERNEL_PRIVATE */

105

106 #ifdef KERNEL_PRIVATE

 extern boolean_t IOPMRootDomainGetWillShutdown(void);

 extern void PEInitiatePanic(void);

109 #endif /* KERNEL_PRIVATE */

110

111 // Save the Panic Info. Returns the number of bytes saved.

 extern UInt32 PESavePanicInfo(UInt8 *buffer, UInt32 length);

 extern void PESavePanicInfoAction(void *buffer, UInt32 offset, UInt32 length);

114

115 /*

116 * SMC requires that all data is flushed in multiples of 16 bytes at 16 byte

117 * boundaries.

118 */

119 #define PANIC_FLUSH_BOUNDARY 16

120

 extern long PEGetGMTTimeOfDay( void );

 extern void PESetGMTTimeOfDay( long secs );

 extern void PEGetUTCTimeOfDay( clock_sec_t * secs, clock_usec_t * usecs );

 extern void PESetUTCTimeOfDay( clock_sec_t secs, clock_usec_t usecs );

125

126 /* unless it's a "well-known" property, these will read/write out the value as raw data */

127

 extern boolean_t PEWriteNVRAMBooleanProperty(const char *symbol, boolean_t value);

 extern boolean_t PEWriteNVRAMProperty(const char *symbol, const void *value, const unsigned int len);

 extern boolean_t PEWriteNVRAMPropertyWithCopy(const char *symbol, const void *value, const unsigned int len);

131

 extern boolean_t PEReadNVRAMProperty(const char *symbol, void *value, unsigned int *len);

133

 extern boolean_t PERemoveNVRAMProperty(const char *symbol);

135

 extern coprocessor_type_t PEGetCoprocessorVersion( void );

137

138 #ifdef __cplusplus

139 } /* extern "C" */

140

141 #define kIOPlatformMapperPresentKey "IOPlatformMapperPresent"

146 extern OSSymbol * gPlatformInterruptControllerName;

147

148 /*

149 * IOPlatformSleepAction

150 *

151 * Sleep is called after power management has finished all of the power plane

152 * driver power management notifications and state transitions and has

153 * committed to sleep, but before the other CPUs are powered off.

154 * The scheduler is still active.

155 */

156 extern const OSSymbol *gIOPlatformSleepActionKey;

157

158 /*

159 * IOPlatformWakeAction

160 *

161 * Wake is called with the scheduler enabled, but before

162 * powering on other CPUs, so try to minimize work done in this path to speed

163 * up wake time.

164 */

165 extern const OSSymbol *gIOPlatformWakeActionKey;

166

167 /*

168 * IOPlatformQuiesceAction

169 *

170 * Quiesce is called after all CPUs are off, scheduling is disabled,

171 * and the boot CPU is about to pull the plug.

172 * Mutexes and blocking are disallowed in this context and will panic.

173 * Do not pass this action to super() (incl. IOService, IOPlatformExpert)

174 */

175 extern const OSSymbol *gIOPlatformQuiesceActionKey;

176

177 /*

178 * IOPlatformActiveAction

179 *

180 * Active is called very early in the wake path before enabling the scheduler

181 * on the boot CPU.

182 * Mutexes and blocking are disallowed in this context and will panic.

183 * Do not pass this action to super() (incl. IOService, IOPlatformExpert)

184 */

185 extern const OSSymbol *gIOPlatformActiveActionKey;

186

187 /*

188 * IOPlatformHaltRestartAction

189 *

190 * Halt/Restart is called after the kernel finishes shutting down the

191 * system and is ready to power off or reboot.

192 *

193 * It is not guaranteed to be called in non-graceful shutdown scenarios.

194 */

195 extern const OSSymbol *gIOPlatformHaltRestartActionKey;

196

197 /*

198 * IOPlatformPanicAction

199 *

200 * Panic is called when the system is panicking before it records a core file

201 * (if it is configured to do so)

202 *

203 * It can be called at any time, in any context, in any state. Don't depend

204 * on anything being powered on in a useful state.

205 *

206 * Mutexes and blocking are disallowed in this context and will fail.

207 *

208 * If you hang or panic again in this callout, the panic log may not be recorded,

209 * leading to the loss of field reports about customer issues.

210 */

211 extern const OSSymbol *gIOPlatformPanicActionKey;

212

213 class IORangeAllocator;

214 class IONVRAMController;

215 class IOPMrootDomain;

216

217 class IOPlatformExpert : public IOService

218 {

219 OSDeclareDefaultStructors(IOPlatformExpert);

220

221 private:

222 long _peBootROMType;

223 long _peChipSetType;

224 long _peMachineType;

225

226 protected:

227 IOPMrootDomain * root;

228 int _pePMFeatures;

229 int _pePrivPMFeatures;

230 int _peNumBatteriesSupported;

231 OSArray * thePowerTree;

232

233 bool searchingForAdditionalParents;

234 OSNumber * multipleParentKeyValue;

235 int numInstancesRegistered;

236

237 struct ExpansionData { };

238 ExpansionData *iope_reserved __unused;

239

         virtual void setBootROMType(long peBootROMType);

         virtual void setChipSetType(long peChipSetType);

         virtual void setMachineType(long peMachineType);

243

         virtual bool CheckSubTree(OSArray * inSubTree, IOService * theNub, IOService * theDevice, OSDictionary * theParent);

         virtual bool RegisterServiceInTree(IOService * theService, OSDictionary * theTreeNode, OSDictionary * theTreeParentNode, IOService * theProvider);

246

         virtual void PMInstantiatePowerDomains( void );

248

249 public:

         virtual bool attach( IOService * provider ) APPLE_KEXT_OVERRIDE;

         virtual bool start( IOService * provider ) APPLE_KEXT_OVERRIDE;

         virtual bool configure( IOService * provider );

         virtual IOService * createNub( OSDictionary * from );

254

         virtual bool compareNubName( const IOService * nub, OSString * name,

             OSString ** matched = NULL ) const;

         bool compareNubName( const IOService * nub, OSString * name,

             OSSharedPtr<OSString>& matched ) const;

         virtual IOReturn getNubResources( IOService * nub );

260

         virtual long getBootROMType(void);

         virtual long getChipSetType(void);

         virtual long getMachineType(void);

264

265 /*

266 * getModelName() and getMachineName() are deprecated for direct

267 * use. Use getTargetName() and getProductName() instead.

268 */

         virtual bool getModelName( char * name, int maxLength );

         virtual bool getMachineName( char * name, int maxLength );

271

         virtual int haltRestart(unsigned int type);

         virtual void sleepKernel(void);

274

         virtual long getGMTTimeOfDay( void );

         virtual void setGMTTimeOfDay( long secs );

277

         virtual IOReturn getConsoleInfo( PE_Video * consoleInfo );

         virtual IOReturn setConsoleInfo( PE_Video * consoleInfo, unsigned int op );

280

         virtual void registerNVRAMController( IONVRAMController * nvram );

282

         virtual IOReturn registerInterruptController(OSSymbol *name, IOInterruptController *interruptController);

284 virtual LIBKERN_RETURNS_NOT_RETAINED IOInterruptController *

285 lookUpInterruptController(OSSymbol *name);

286

         virtual void setCPUInterruptProperties(IOService *service);

         virtual bool atInterruptLevel(void);

289

         virtual IOReturn callPlatformFunction(const OSSymbol *functionName,

291 bool waitForFunction,

             void *param1, void *param2,

             void *param3, void *param4) APPLE_KEXT_OVERRIDE;

294

         virtual IORangeAllocator * getPhysicalRangeAllocator(void);

296

         virtual bool platformAdjustService(IOService *service);

298

         virtual void PMRegisterDevice(IOService * theNub, IOService * theDevice);

         virtual void PMLog( const char *, unsigned long, unsigned long, unsigned long );

301

         virtual bool hasPMFeature(unsigned long featureMask);

         virtual bool hasPrivPMFeature(unsigned long privFeatureMask);

         virtual int  numBatteriesSupported(void);

305

         virtual IOByteCount savePanicInfo(UInt8 *buffer, IOByteCount length);

307

         virtual OSString* createSystemSerialNumberString(OSData* myProperty);

309

         virtual IOReturn deregisterInterruptController(OSSymbol *name);

311

         virtual void getUTCTimeOfDay( clock_sec_t * secs, clock_nsec_t * nsecs );

         virtual void setUTCTimeOfDay( clock_sec_t secs, clock_nsec_t nsecs );

         void publishPlatformUUIDAndSerial( void );

         void publishNVRAM( void );

316

         virtual bool getTargetName( char * name, int maxLength );

         virtual bool getProductName( char * name, int maxLength );

319

         OSMetaClassDeclareReservedUsedX86(IOPlatformExpert, 0);

         OSMetaClassDeclareReservedUsedX86(IOPlatformExpert, 1);

         OSMetaClassDeclareReservedUsedX86(IOPlatformExpert, 2);

         OSMetaClassDeclareReservedUsedX86(IOPlatformExpert, 3);

         OSMetaClassDeclareReservedUsedX86(IOPlatformExpert, 4);

         OSMetaClassDeclareReservedUsedX86(IOPlatformExpert, 5);

         OSMetaClassDeclareReservedUsedX86(IOPlatformExpert, 6);

327

         OSMetaClassDeclareReservedUnused(IOPlatformExpert, 7);

         OSMetaClassDeclareReservedUnused(IOPlatformExpert, 8);

         OSMetaClassDeclareReservedUnused(IOPlatformExpert, 9);

         OSMetaClassDeclareReservedUnused(IOPlatformExpert, 10);

         OSMetaClassDeclareReservedUnused(IOPlatformExpert, 11);

333 };

334

335 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

336

337 class IODTNVRAM;

338

339 class IODTPlatformExpert : public IOPlatformExpert

340 {

341 OSDeclareAbstractStructors(IODTPlatformExpert);

342

343 private:

344 IODTNVRAM *dtNVRAM;

345

346 struct ExpansionData { };

347 ExpansionData *iodtpe_reserved;

348

349 public:

         virtual IOService * probe(  IOService *     provider,

351 SInt32 * score ) APPLE_KEXT_OVERRIDE;

         virtual bool configure( IOService * provider ) APPLE_KEXT_OVERRIDE;

353

         virtual void processTopLevel( IORegistryEntry * root );

         virtual const char * deleteList( void ) = 0;

         virtual const char * excludeList( void ) = 0;

         virtual IOService * createNub( IORegistryEntry * from );

         virtual bool createNubs( IOService * parent, LIBKERN_CONSUMED OSIterator * iter );

359

         virtual bool compareNubName( const IOService * nub, OSString * name,

             OSString ** matched = NULL ) const APPLE_KEXT_OVERRIDE;

362

         virtual IOReturn getNubResources( IOService * nub ) APPLE_KEXT_OVERRIDE;

364

365 /*

366 * getModelName() and getMachineName() are deprecated. Use

367 * getTargetName() and getProductName() instead.

368 */

         virtual bool getModelName( char * name, int maxLength ) APPLE_KEXT_OVERRIDE;

         virtual bool getMachineName( char * name, int maxLength ) APPLE_KEXT_OVERRIDE;

371

         virtual bool getTargetName( char * name, int maxLength ) APPLE_KEXT_OVERRIDE;

         virtual bool getProductName( char * name, int maxLength ) APPLE_KEXT_OVERRIDE;

374

         virtual void registerNVRAMController( IONVRAMController * nvram ) APPLE_KEXT_OVERRIDE;

376

         virtual int haltRestart(unsigned int type) APPLE_KEXT_OVERRIDE;

378

 /* virtual */ IOReturn readXPRAM(IOByteCount offset, UInt8 * buffer,

380 IOByteCount length);

381

 /* virtual */ IOReturn writeXPRAM(IOByteCount offset, UInt8 * buffer,

383 IOByteCount length);

384

385 virtual IOReturn readNVRAMProperty(

386 IORegistryEntry * entry,

                 const OSSymbol ** name, OSData ** value );

388

389 IOReturn readNVRAMProperty(

390 IORegistryEntry * entry,

                 OSSharedPtr<const OSSymbol>& name, OSSharedPtr<OSData>& value );

392

393 virtual IOReturn writeNVRAMProperty(

394 IORegistryEntry * entry,

                 const OSSymbol * name, OSData * value );

396

397 // This returns a dictionary describing all the NVRAM partitions.

398 // The keys will be the partitionIDs of the form "0x52,nvram".

399 // The values will be OSNumbers of the partition's byte count.

 /* virtual */ OSDictionary *getNVRAMPartitions(void);

401

 /* virtual */ IOReturn readNVRAMPartition(const OSSymbol * partitionID,

403 IOByteCount offset, UInt8 * buffer,

404 IOByteCount length);

405

 /* virtual */ IOReturn writeNVRAMPartition(const OSSymbol * partitionID,

407 IOByteCount offset, UInt8 * buffer,

408 IOByteCount length);

409

         virtual IOByteCount savePanicInfo(UInt8 *buffer, IOByteCount length) APPLE_KEXT_OVERRIDE;

         virtual OSString* createSystemSerialNumberString(OSData* myProperty) APPLE_KEXT_OVERRIDE;

412

         OSMetaClassDeclareReservedUnused(IODTPlatformExpert, 0);

         OSMetaClassDeclareReservedUnused(IODTPlatformExpert, 1);

         OSMetaClassDeclareReservedUnused(IODTPlatformExpert, 2);

         OSMetaClassDeclareReservedUnused(IODTPlatformExpert, 3);

         OSMetaClassDeclareReservedUnused(IODTPlatformExpert, 4);

         OSMetaClassDeclareReservedUnused(IODTPlatformExpert, 5);

         OSMetaClassDeclareReservedUnused(IODTPlatformExpert, 6);

         OSMetaClassDeclareReservedUnused(IODTPlatformExpert, 7);

421 };

422

423 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

424

425 /* generic root nub of service tree */

426

427 class IOPlatformExpertDevice : public IOService

428 {

429 OSDeclareDefaultStructors(IOPlatformExpertDevice);

430

431 private:

432 IOWorkLoop *workLoop;

433

434 struct ExpansionData { };

435 ExpansionData *ioped_reserved __unused;

436

437 public:

         virtual bool init(void *dtRoot);

         virtual bool compareName( OSString * name, OSString ** matched = NULL ) const APPLE_KEXT_OVERRIDE;

440

         virtual IOWorkLoop *getWorkLoop() const APPLE_KEXT_OVERRIDE;

         virtual IOReturn setProperties( OSObject * properties ) APPLE_KEXT_OVERRIDE;

443

         virtual void free() APPLE_KEXT_OVERRIDE;

445

         virtual IOReturn newUserClient( task_t owningTask, void * securityID,

447 UInt32 type, OSDictionary * properties,

448 IOUserClient ** handler) APPLE_KEXT_OVERRIDE;

449

         bool startIOServiceMatching(void);

         void createNVRAM(void);

         void generatePlatformUUID(void);

         void configureDefaults(void);

454

         OSMetaClassDeclareReservedUnused(IOPlatformExpertDevice, 0);

         OSMetaClassDeclareReservedUnused(IOPlatformExpertDevice, 1);

         OSMetaClassDeclareReservedUnused(IOPlatformExpertDevice, 2);

         OSMetaClassDeclareReservedUnused(IOPlatformExpertDevice, 3);

459 };

460

461 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

462

463 /* generic nub for motherboard devices */

464

465 class IOPlatformDevice : public IOService

466 {

467 OSDeclareDefaultStructors(IOPlatformDevice);

468

469 struct ExpansionData { };

470 ExpansionData *iopd_reserved;

471

472 public:

         virtual bool compareName( OSString * name, OSString ** matched = NULL ) const APPLE_KEXT_OVERRIDE;

         virtual IOService * matchLocation( IOService * client ) APPLE_KEXT_OVERRIDE;

         virtual IOReturn getResources( void ) APPLE_KEXT_OVERRIDE;

476

         OSMetaClassDeclareReservedUnused(IOPlatformDevice, 0);

         OSMetaClassDeclareReservedUnused(IOPlatformDevice, 1);

         OSMetaClassDeclareReservedUnused(IOPlatformDevice, 2);

         OSMetaClassDeclareReservedUnused(IOPlatformDevice, 3);

481 };

482

483 #endif /* __cplusplus */

484

485 #endif /* ! _IOKIT_IOPLATFORMEXPERT_H */