![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IOPlatformExpert.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Kernel|
Return to IOPlatformExpert.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Kernel |
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: * HISTORY
24: */
25:
26: #include <IOKit/system.h>
27:
28: extern "C" {
29: #include <machine/machine_routines.h>
30: }
31:
32: #include <IOKit/IOInterrupts.h>
33: #include <IOKit/IOInterruptController.h>
34: #include <IOKit/IOPlatformExpert.h>
35: #include <IOKit/IOCPU.h>
36: #include <IOKit/IODeviceTreeSupport.h>
37: #include <IOKit/IORangeAllocator.h>
38: #include <libkern/c++/OSContainers.h>
39: #include <IOKit/IOLib.h>
40: #include <IOKit/nvram/IONVRAMController.h>
41: #include <IOKit/pwr_mgt/RootDomain.h>
42: #include <IOKit/IOKitDebug.h>
43: #include <IOKit/IOWorkLoop.h>
44:
45: #include <IOKit/assert.h>
46:
47: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
48:
49: #define super IOService
50:
51: OSDefineMetaClassAndStructors(IOPlatformExpert, IOService)
52:
53: static IOPlatformExpert * gIOPlatform;
54:
55: OSSymbol * gPlatformInterruptControllerName;
56:
57: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
58:
59: bool IOPlatformExpert::attach( IOService * provider )
60: {
61:
62: if( !super::attach( provider ))
63: return( false);
64:
65: return( true);
66: }
67:
68: bool IOPlatformExpert::start( IOService * provider )
69: {
70: IORangeAllocator * physicalRanges;
71:
72: if (!super::start(provider))
73: return false;
74:
75: gPlatformInterruptControllerName = (OSSymbol *)OSSymbol::withCStringNoCopy("IOPlatformInterruptController");
76:
77: physicalRanges = IORangeAllocator::withRange(0xffffffff, 1, 16,
78: IORangeAllocator::kLocking);
79: assert(physicalRanges);
80: setProperty("Platform Memory Ranges", physicalRanges);
81:
82: setPlatform( this );
83: gIOPlatform = this;
84:
85: PMInstantiatePowerDomains();
86:
87: return( configure(provider) );
88: }
89:
90: bool IOPlatformExpert::configure( IOService * provider )
91: {
92: OSSet * topLevel;
93: OSDictionary * dict;
94: IOService * nub;
95:
96: topLevel = OSDynamicCast( OSSet, getProperty("top-level"));
97:
98: if( topLevel) {
99: while( (dict = OSDynamicCast( OSDictionary,
100: topLevel->getAnyObject()))) {
101: dict->retain();
102: topLevel->removeObject( dict );
103: nub = createNub( dict );
104: if( 0 == nub)
105: continue;
106: dict->release();
107: nub->attach( this );
108: nub->registerService();
109: }
110: }
111:
112: return( true );
113: }
114:
115: IOService * IOPlatformExpert::createNub( OSDictionary * from )
116: {
117: IOService * nub;
118:
119: nub = new IOPlatformDevice;
120: if(nub) {
121: if( !nub->init( from )) {
122: nub->release();
123: nub = 0;
124: }
125: }
126: return( nub);
127: }
128:
129: bool IOPlatformExpert::compareNubName( const IOService * nub,
130: OSString * name, OSString ** matched = 0 ) const
131: {
132: return( nub->IORegistryEntry::compareName( name, matched ));
133: }
134:
135: IOReturn IOPlatformExpert::getNubResources( IOService * nub )
136: {
137: return( kIOReturnSuccess );
138: }
139:
140: int IOPlatformExpert::getEpoch(void)
141: {
142: return _peEpoch;
143: }
144:
145: int IOPlatformExpert::getFamily(void)
146: {
147: return _peFamily;
148: }
149:
150: void IOPlatformExpert::setEpoch(int peEpoch)
151: {
152: _peEpoch = peEpoch;
153: }
154:
155: void IOPlatformExpert::setFamily(int peFamily)
156: {
157: _peFamily = peFamily;
158: }
159:
160: bool IOPlatformExpert::getMachineName( char * /*name*/, int /*maxLength*/)
161: {
162: return( false );
163: }
164:
165: bool IOPlatformExpert::getModelName( char * /*name*/, int /*maxLength*/)
166: {
167: return( false );
168: }
169:
170: IORangeAllocator * IOPlatformExpert::getPhysicalRangeAllocator(void)
171: {
172: return(OSDynamicCast(IORangeAllocator,
173: getProperty("Platform Memory Ranges")));
174: }
175:
176: int (*PE_halt_restart)(unsigned int type) = 0;
177:
178: int IOPlatformExpert::haltRestart(unsigned int type)
179: {
180:
181: if (PE_halt_restart) return (*PE_halt_restart)(type);
182: else return -1;
183: }
184:
185: long IOPlatformExpert::getGMTTimeOfDay(void)
186: {
187: return(0);
188: }
189:
190: void IOPlatformExpert::setGMTTimeOfDay(long secs)
191: {
192: }
193:
194:
195: IOReturn IOPlatformExpert::getConsoleInfo( PE_Video * consoleInfo )
196: {
197: return( PE_current_console( consoleInfo));
198: }
199:
200: IOReturn IOPlatformExpert::setConsoleInfo( PE_Video * consoleInfo,
201: unsigned int op)
202: {
203: return( PE_initialize_console( consoleInfo, op ));
204: }
205:
206: void IOPlatformExpert::getDefaultBusSpeeds(int *numSpeeds,
207: unsigned long **speedList)
208: {
209: if (numSpeeds != 0) *numSpeeds = 0;
210: if (speedList != 0) *speedList = 0;
211: }
212:
213: IOReturn IOPlatformExpert::registerInterruptController(OSSymbol *name, IOInterruptController *interruptController)
214: {
215: publishResource(name, interruptController);
216:
217: return kIOReturnSuccess;
218: }
219:
220: IOInterruptController *IOPlatformExpert::lookUpInterruptController(OSSymbol *name)
221: {
222: IOInterruptController *interruptController;
223: IOService *service;
224:
225: service = waitForService(resourceMatching(name));
226:
227: interruptController = OSDynamicCast(IOInterruptController, service->getProperty(name));
228:
229: return interruptController;
230: }
231:
232:
233: void IOPlatformExpert::setCPUInterruptProperties(IOService *service)
234: {
235: IOCPUInterruptController *controller;
236:
237: controller = OSDynamicCast(IOCPUInterruptController, waitForService(serviceMatching("IOCPUInterruptController")));
238: if (controller) controller->setCPUInterruptProperties(service);
239: }
240:
241: bool IOPlatformExpert::atInterruptLevel(void)
242: {
243: return ml_at_interrupt_context();
244: }
245:
246: bool IOPlatformExpert::platformAdjustService(IOService */*service*/)
247: {
248: return true;
249: }
250:
251:
252: //*********************************************************************************
253: // PMLog
254: //
255: //*********************************************************************************
256:
257: void IOPlatformExpert::PMLog(const char * who,unsigned long event,unsigned long param1, unsigned long param2)
258: {
259: if( gIOKitDebug & kIOLogPower)
260: kprintf("%s %02d %08x %08x\n",who,event,param1,param2);
261: }
262:
263:
264: //*********************************************************************************
265: // PMInstantiatePowerDomains
266: //
267: // In this vanilla implementation, a Root Power Domain is instantiated.
268: // All other objects which register will be children of this Root.
269: // Where this is inappropriate, PMInstantiatePowerDomains is overridden
270: // in a platform-specific subclass.
271: //*********************************************************************************
272:
273: void IOPlatformExpert::PMInstantiatePowerDomains ( void )
274: {
275: root = new IOPMrootDomain;
276: root->init();
277: root->attach(this);
278: root->start(this);
279: root->youAreRoot();
280: }
281:
282:
283: //*********************************************************************************
284: // PMRegisterDevice
285: //
286: // In this vanilla implementation, all callers are made children of the root power domain.
287: // Where this is inappropriate, PMRegisterDevice is overridden in a platform-specific subclass.
288: //*********************************************************************************
289:
290: void IOPlatformExpert::PMRegisterDevice(IOService * theNub, IOService * theDevice)
291: {
292: root->addChild ( theDevice );
293: }
294:
295:
296: /*
297: * Platform Expert handler for Non-volatile RAM.
298: Called by BSD driver.
299: Calls whatever NVRAM driver has registered.
300: That's either the IOPMUNVRAMController or the IOMapNVRAMController.
301:
302: Suurballe 11 Feb 1999
303: */
304:
305:
306: // global pointer to whichever NVRAM controller is present
307: IONVRAMController * gNVRAMController = 0;
308:
309: extern "C" {
310:
311: //int PEnvopen(dev_t dev, int flag, int devtype,struct proc * pp)
312: int PEnvopen(dev_t, int, int,struct proc * )
313: {
314: if (gNVRAMController) return gNVRAMController->openNVRAM();
315: else return kNoNVRAM;
316: }
317:
318:
319: //int PEnvclose(dev_t dev, int flag, int mode, struct proc * pp)
320: int PEnvclose(dev_t, int, int, struct proc *)
321: {
322: if (gNVRAMController) return gNVRAMController->closeNVRAM();
323: else return kNoNVRAM;
324: }
325:
326:
327: int PEnvsync(void)
328: {
329: if (gNVRAMController) return gNVRAMController->syncNVRAM();
330: else return kNoNVRAM;
331: }
332:
333:
334: int PEnvread(long offset, int length, unsigned char * where)
335: {
336: IOByteCount bytecount = length;
337:
338: if (gNVRAMController)
339: return gNVRAMController->readNVRAM(offset, &bytecount, where);
340: else return kNoNVRAM;
341: }
342:
343:
344:
345: int PEnvwrite(long offset, int length, unsigned char * where)
346: {
347: IOByteCount bytecount = length;
348:
349: if (gNVRAMController)
350: return gNVRAMController->writeNVRAM(offset, &bytecount, where);
351: else return kNoNVRAM;
352: }
353:
354: /*
355: * Callouts from BSD for machine name & model
356: */
357:
358: boolean_t PEGetMachineName( char * name, int maxLength )
359: {
360: if( gIOPlatform)
361: return( gIOPlatform->getMachineName( name, maxLength ));
362: else
363: return( false );
364: }
365:
366: boolean_t PEGetModelName( char * name, int maxLength )
367: {
368: if( gIOPlatform)
369: return( gIOPlatform->getModelName( name, maxLength ));
370: else
371: return( false );
372: }
373:
374: int PEGetPlatformEpoch(void)
375: {
376: if( gIOPlatform)
377: return( gIOPlatform->getEpoch());
378: else
379: return( -1 );
380: }
381:
382: int PEHaltRestart(unsigned int type)
383: {
384: if (gNVRAMController) gNVRAMController->syncNVRAM();
385:
386: if (gIOPlatform) return gIOPlatform->haltRestart(type);
387: else return -1;
388: }
389:
390: long PEGetGMTTimeOfDay(void)
391: {
392: if( gIOPlatform)
393: return( gIOPlatform->getGMTTimeOfDay());
394: else
395: return( 0 );
396: }
397:
398: void PESetGMTTimeOfDay(long secs)
399: {
400: if( gIOPlatform)
401: gIOPlatform->setGMTTimeOfDay(secs);
402: }
403:
404: } /* extern "C" */
405:
406: void IOPlatformExpert::registerNVRAMController(IONVRAMController * caller)
407: {
408: gNVRAMController = caller;
409:
410: publishResource("IONVRAM");
411: }
412:
413:
414: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
415:
416: #undef super
417: #define super IOPlatformExpert
418:
419: OSDefineMetaClass(IODTPlatformExpert, IOPlatformExpert)
420: OSDefineAbstractStructors( IODTPlatformExpert, IOPlatformExpert )
421:
422: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
423:
424: IOService * IODTPlatformExpert::probe( IOService * provider,
425: SInt32 * score )
426: {
427: if( !super::probe( provider, score))
428: return( 0 );
429:
430: // check machine types
431: if( !provider->compareNames( getProperty( gIONameMatchKey ) ))
432: return( 0 );
433:
434: return( this);
435: }
436:
437: bool IODTPlatformExpert::configure( IOService * provider )
438: {
439: if( !super::configure( provider))
440: return( false);
441:
442: processTopLevel( provider );
443:
444: return( true );
445: }
446:
447: IOService * IODTPlatformExpert::createNub( IORegistryEntry * from )
448: {
449: IOService * nub;
450:
451: nub = new IOPlatformDevice;
452: if( nub) {
453: if( !nub->init( from, gIODTPlane )) {
454: nub->free();
455: nub = 0;
456: }
457: }
458: return( nub);
459: }
460:
461: bool IODTPlatformExpert::createNubs( IOService * parent, OSIterator * iter )
462: {
463: IORegistryEntry * next;
464: IOService * nub;
465: bool ok = true;
466:
467: if( iter) {
468: while( (next = (IORegistryEntry *) iter->getNextObject())) {
469:
470: if( 0 == (nub = createNub( next )))
471: continue;
472:
473: nub->attach( parent );
474: nub->registerService();
475: }
476: iter->release();
477: }
478:
479: return( ok );
480: }
481:
482: void IODTPlatformExpert::processTopLevel( IORegistryEntry * root )
483: {
484: OSIterator * kids;
485: IORegistryEntry * next;
486: IORegistryEntry * cpus;
487:
488: // infanticide
489: kids = IODTFindMatchingEntries( root, 0, deleteList() );
490: if( kids) {
491: while( (next = (IORegistryEntry *)kids->getNextObject())) {
492: next->detachAll( gIODTPlane);
493: }
494: kids->release();
495: }
496:
497: // publish top level, minus excludeList
498: createNubs( this, IODTFindMatchingEntries( root, kIODTExclusive, excludeList()));
499:
500: cpus = root->childFromPath( "cpus", gIODTPlane);
501: // kids = IODTFindMatchingEntries( root, 0, "cpus");
502: // cpus = (IORegistryEntry *)kids->getNextObject();
503: if ( cpus)
504: // publish cpus/*
505: createNubs( this, IODTFindMatchingEntries( cpus, kIODTExclusive, 0));
506:
507: }
508:
509: IOReturn IODTPlatformExpert::getNubResources( IOService * nub )
510: {
511: if( nub->getDeviceMemory())
512: return( kIOReturnSuccess );
513:
514: IODTResolveAddressing( nub, "reg", 0);
515:
516: return( kIOReturnSuccess);
517: }
518:
519: bool IODTPlatformExpert::compareNubName( const IOService * nub,
520: OSString * name, OSString ** matched ) const
521: {
522: return( IODTCompareNubName( nub, name, matched )
523: || super::compareNubName( nub, name, matched) );
524: }
525:
526: bool IODTPlatformExpert::getModelName( char * name, int maxLength )
527: {
528: OSData * prop;
529: const char * str;
530: int len;
531: char c;
532: bool ok = false;
533:
534: maxLength--;
535:
536: prop = (OSData *) getProvider()->getProperty( gIODTCompatibleKey );
537: if( prop ) {
538: str = (const char *) prop->getBytesNoCopy();
539:
540: if( 0 == strncmp( str, "AAPL,", strlen( "AAPL," ) ))
541: str += strlen( "AAPL," );
542:
543: len = 0;
544: while( (c = *str++)) {
545: if( (c == '/') || (c == ' '))
546: c = '-';
547:
548: name[ len++ ] = c;
549: if( len >= maxLength)
550: break;
551: }
552:
553: name[ len ] = 0;
554: ok = true;
555: }
556: return( ok );
557: }
558:
559: bool IODTPlatformExpert::getMachineName( char * name, int maxLength )
560: {
561: OSData * prop;
562: bool ok = false;
563:
564: maxLength--;
565: prop = (OSData *) getProvider()->getProperty( gIODTModelKey );
566: ok = (0 != prop);
567:
568: if( ok )
569: strncpy( name, (const char *) prop->getBytesNoCopy(), maxLength );
570:
571: return( ok );
572: }
573:
574: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
575:
576: enum {
577: kMaxNVNameLen = 4,
578: kMaxNVDataLen = 8
579: };
580:
581: #pragma options align=mac68k
582: struct NVRAMProperty
583: {
584: IONVRAMDescriptor header;
585: UInt8 nameLen;
586: UInt8 name[ kMaxNVNameLen ];
587: UInt8 dataLen;
588: UInt8 data[ kMaxNVDataLen ];
589: };
590: #pragma options align=reset
591:
592:
593: void IODTPlatformExpert::registerNVRAMController( IONVRAMController * nvram )
594: {
595: UInt32 off;
596: IOReturn err;
597: IOByteCount len;
598:
599: err = getNVRAMPartitionOffset( kIONameRegistryNVRAMPartition, &off );
600:
601: if( kIOReturnSuccess == err) {
602:
603: if( 0 == nvramBuffer)
604: nvramBuffer = IONew( UInt8, kIONameRegistryNVRAMPartitionSize );
605: assert( nvramBuffer );
606:
607: err = nvram->openNVRAM();
608: if( kIOReturnSuccess == err) {
609: len = kIONameRegistryNVRAMPartitionSize;
610: err = nvram->readNVRAM( off, &len, nvramBuffer );
611: nvram->closeNVRAM();
612: }
613:
614: if( err)
615: bzero( nvramBuffer, kIONameRegistryNVRAMPartitionSize );
616: }
617:
618: super::registerNVRAMController( nvram );
619: }
620:
621: bool IODTPlatformExpert::searchNVRAMProperty( IONVRAMDescriptor * hdr,
622: UInt32 * where )
623: {
624: UInt32 off;
625: SInt32 nvEnd;
626:
627: getNVRAMPartitionOffset( kIONameRegistryNVRAMPartition, &off );
628:
629: nvEnd = *((UInt16 *) nvramBuffer);
630: if( getEpoch())
631: nvEnd -= 0x100; // on new world, offset to partition start
632: else
633: nvEnd -= off; // on old world, absolute
634: if( (nvEnd < 0) || (nvEnd >= kIONameRegistryNVRAMPartitionSize) )
635: nvEnd = 2;
636:
637: off = 2;
638: while( (off + sizeof( NVRAMProperty)) <= (UInt32) nvEnd) {
639:
640: if( 0 == bcmp( nvramBuffer + off, hdr, sizeof( *hdr))) {
641: *where = off;
642: return( true );
643: }
644: off += sizeof( NVRAMProperty);
645: }
646:
647: if( (nvEnd + sizeof( NVRAMProperty)) <= kIONameRegistryNVRAMPartitionSize)
648: *where = nvEnd;
649: else
650: *where = 0;
651:
652: return( false );
653: }
654:
655: IOReturn IODTPlatformExpert::readNVRAMPropertyType0(
656: IORegistryEntry * entry,
657: const OSSymbol ** name, OSData ** value )
658: {
659: IONVRAMDescriptor hdr;
660: NVRAMProperty * prop;
661: IOByteCount len;
662: UInt32 off;
663: IOReturn err;
664: char nameBuf[ kMaxNVNameLen + 1 ];
665:
666: if( !nvramBuffer)
667: return( kIOReturnUnsupported );
668: if( !entry || !name || !value)
669: return( kIOReturnBadArgument );
670:
671: if( kIOReturnSuccess != (err = IODTMakeNVDescriptor( entry, &hdr)))
672: return( err);
673:
674: if( searchNVRAMProperty( &hdr, &off)) {
675:
676: prop = (NVRAMProperty *) (nvramBuffer + off);
677:
678: len = prop->nameLen;
679: if( len > kMaxNVNameLen)
680: len = kMaxNVNameLen;
681: strncpy( nameBuf, (const char *) prop->name, len );
682: nameBuf[ len ] = 0;
683: *name = OSSymbol::withCString( nameBuf );
684:
685: len = prop->dataLen;
686: if( len > kMaxNVDataLen)
687: len = kMaxNVDataLen;
688: *value = OSData::withBytes( prop->data, len );
689:
690: if( *name && *value )
691: return( kIOReturnSuccess );
692: else
693: return( kIOReturnNoMemory );
694: }
695:
696: return( kIOReturnNoResources );
697: }
698:
699: IOReturn IODTPlatformExpert::writeNVRAMPropertyType0(
700: IORegistryEntry * entry,
701: const OSSymbol * name, OSData * value )
702: {
703: IONVRAMDescriptor hdr;
704: NVRAMProperty * prop;
705: IOByteCount len;
706: IOByteCount nameLen;
707: IOByteCount dataLen;
708: UInt32 off;
709: IOReturn err;
710: UInt32 start;
711: UInt16 nvLen;
712: bool exists;
713:
714: if( !nvramBuffer)
715: return( kIOReturnUnsupported );
716: if( !entry || !name || !value)
717: return( kIOReturnBadArgument );
718:
719: nameLen = name->getLength();
720: dataLen = value->getLength();
721: if( nameLen > kMaxNVNameLen)
722: return( kIOReturnNoSpace);
723: if( dataLen > kMaxNVDataLen)
724: return( kIOReturnNoSpace);
725:
726: if( kIOReturnSuccess != (err = IODTMakeNVDescriptor( entry, &hdr)))
727: return( err);
728:
729: exists = searchNVRAMProperty( &hdr, &off);
730: if( !off)
731: return( kIOReturnNoMemory);
732:
733: prop = (NVRAMProperty *) (nvramBuffer + off);
734: if( !exists)
735: bcopy( &hdr, &prop->header, sizeof( hdr));
736:
737: prop->nameLen = nameLen;
738: bcopy( name->getCStringNoCopy(), prop->name, nameLen );
739: prop->dataLen = dataLen;
740: bcopy( value->getBytesNoCopy(), prop->data, dataLen );
741:
742: getNVRAMPartitionOffset( kIONameRegistryNVRAMPartition, &start );
743: if( !exists) {
744: nvLen = off + sizeof( NVRAMProperty);
745: if( getEpoch())
746: nvLen += 0x100;
747: else
748: nvLen += start;
749: *((UInt16 *) nvramBuffer) = nvLen;
750: }
751:
752: err = gNVRAMController->openNVRAM();
753: if( kIOReturnSuccess == err) {
754: len = 2;
755: if( !exists)
756: err = gNVRAMController->writeNVRAM( start, &len, nvramBuffer );
757: if( kIOReturnSuccess == err) {
758: len = sizeof( NVRAMProperty);
759: err = gNVRAMController->writeNVRAM( start + off, &len,
760: nvramBuffer + off );
761: }
762: gNVRAMController->closeNVRAM();
763: }
764:
765: return( err );
766: }
767:
768: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
769:
770: OSData * IODTPlatformExpert::getType1NVRAM( void )
771: {
772: OSData * data;
773: IORegistryEntry * options;
774:
775: options = IORegistryEntry::fromPath( "/options", gIODTPlane);
776: if( !options)
777: return( 0 );
778:
779: data = OSDynamicCast( OSData, options->getProperty( "aapl,pci" ));
780: if( data && (0 == data->getLength()))
781: data = 0;
782:
783: return( data );
784: }
785:
786: OSData * IODTPlatformExpert::unescapeValueToBinary( UInt8 * value )
787: {
788: OSData * data = 0;
789: UInt8 * buffer;
790: UInt32 len, totalLen = 0;
791: UInt8 byte;
792: enum { kMaxValueSize = 256 };
793:
794: buffer = IONew( UInt8, kMaxValueSize );
795: if( !buffer)
796: return( 0 );
797:
798: while( 0 != (byte = *(value++))) {
799:
800: if( 0xff == byte) {
801: byte = *(value++);
802: len = byte & 0x7f;
803: byte = (byte & 0x80) ? 0xff : 0;
804: } else
805: len = 1;
806:
807: if( (totalLen + len) >= kMaxValueSize) {
808: totalLen = 0;
809: break;
810: }
811:
812: memset( (void *) (buffer + totalLen), byte, len );
813: totalLen += len;
814: }
815:
816: if( totalLen)
817: data = OSData::withBytes( buffer, totalLen );
818:
819: IODelete( buffer, UInt8, kMaxValueSize );
820:
821: return( data );
822: }
823:
824: IOReturn IODTPlatformExpert::readNVRAMPropertyType1(
825: IORegistryEntry * entry,
826: const OSSymbol ** name, OSData ** value )
827: {
828: IOReturn err = kIOReturnNoResources;
829: OSData * data;
830: UInt8 * start;
831: UInt8 * end;
832: UInt8 * where;
833: UInt8 * nvPath = 0;
834: UInt8 * nvName = 0;
835: UInt8 byte;
836:
837: if( 0 == (data = getType1NVRAM()))
838: return( kIOReturnUnsupported );
839:
840: // data must have length from getType1NVRAM()
841: start = (UInt8 *) data->getBytesNoCopy();
842: if( strlen( (const char *) start) == (data->getLength() - 1)) {
843: data = unescapeValueToBinary( start );
844: if( 0 == data)
845: return( kIOReturnUnsupported );
846: } else
847: data->retain();
848:
849: start = (UInt8 *) data->getBytesNoCopy();
850: end = start + data->getLength();
851:
852: where = start;
853: while( where < end) {
854:
855: byte = *(where++);
856: if( byte)
857: continue;
858:
859: if( !nvPath)
860: nvPath = start;
861: else if( !nvName)
862: nvName = start;
863:
864: else if( entry == IORegistryEntry::fromPath( (const char *) nvPath, gIODTPlane )) {
865:
866: *name = OSSymbol::withCString( (const char *) nvName );
867: *value = unescapeValueToBinary( start );
868: if( *name && *value )
869: err = kIOReturnSuccess;
870: else
871: err = kIOReturnNoMemory;
872: break;
873:
874: } else
875: nvPath = nvName = 0;
876:
877: start = where;
878: }
879: data->release();
880:
881: return( err );
882: }
883:
884: IOReturn IODTPlatformExpert::writeNVRAMPropertyType1(
885: IORegistryEntry * entry,
886: const OSSymbol * name, OSData * value )
887: {
888: OSData * data;
889:
890: if( 0 == (data = getType1NVRAM()))
891: return( kIOReturnUnsupported );
892:
893: // tidbit left for PR2
894: return( kIOReturnNoResources );
895: }
896:
897: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
898:
899:
900: IOReturn IODTPlatformExpert::readNVRAMProperty(
901: IORegistryEntry * entry,
902: const OSSymbol ** name, OSData ** value )
903: {
904: IOReturn err;
905:
906: err = readNVRAMPropertyType1( entry, name, value );
907:
908: if( kIOReturnUnsupported == err)
909: err = readNVRAMPropertyType0( entry, name, value );
910:
911: return( err );
912: }
913:
914: IOReturn IODTPlatformExpert::writeNVRAMProperty(
915: IORegistryEntry * entry,
916: const OSSymbol * name, OSData * value )
917: {
918: IOReturn err;
919:
920: err = writeNVRAMPropertyType1( entry, name, value );
921:
922: if( kIOReturnUnsupported == err)
923: err = writeNVRAMPropertyType0( entry, name, value );
924:
925: return( err );
926: }
927:
928: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
929:
930: #undef super
931: #define super IOService
932:
933: OSDefineMetaClassAndStructors(IOPlatformExpertDevice, IOService)
934:
935: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
936:
937: bool IOPlatformExpertDevice::compareName( OSString * name,
938: OSString ** matched = 0 ) const
939: {
940: return( IODTCompareNubName( this, name, matched ));
941: }
942:
943: bool
944: IOPlatformExpertDevice::initWithArgs(
945: void * dtTop, void * p2, void * p3, void * p4 )
946: {
947: IORegistryEntry * dt = 0;
948: void * argsData[ 4 ];
949: bool ok;
950:
951: // dtTop may be zero on non- device tree systems
952: if( dtTop && (dt = IODeviceTreeAlloc( dtTop )))
953: ok = super::init( dt, gIODTPlane );
954: else
955: ok = super::init();
956:
957: if( !ok)
958: return( false);
959:
960: workLoop = IOWorkLoop::workLoop();
961: if (!workLoop)
962: return false;
963:
964: argsData[ 0 ] = dtTop;
965: argsData[ 1 ] = p2;
966: argsData[ 2 ] = p3;
967: argsData[ 3 ] = p4;
968:
969: setProperty("IOPlatformArgs", (void *)argsData, sizeof( argsData));
970:
971: return( true);
972: }
973:
974: IOWorkLoop *IOPlatformExpertDevice::getWorkLoop() const
975: {
976: return workLoop;
977: }
978:
979: void IOPlatformExpertDevice::free()
980: {
981: if (workLoop)
982: workLoop->release();
983: }
984:
985: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
986:
987: #undef super
988: #define super IOService
989:
990: OSDefineMetaClassAndStructors(IOPlatformDevice, IOService)
991:
992: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
993:
994: bool IOPlatformDevice::compareName( OSString * name,
995: OSString ** matched = 0 ) const
996: {
997: return( ((IOPlatformExpert *)getProvider())->
998: compareNubName( this, name, matched ));
999: }
1000:
1001: IOService * IOPlatformDevice::matchLocation( IOService * /* client */ )
1002: {
1003: return( this );
1004: }
1005:
1006: IOReturn IOPlatformDevice::getResources( void )
1007: {
1008: return( ((IOPlatformExpert *)getProvider())->getNubResources( this ));
1009: }
1010:
1011: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.