iokit/Kernel/IOCPU.cpp

   1 /*
   2  * Copyright (c) 1999-2016 Apple Inc.  All rights reserved.
   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
  29 #define IOKIT_ENABLE_SHARED_PTR
  30
  31 extern "C" {
  32 #include <machine/machine_routines.h>
  33 #include <pexpert/pexpert.h>
  34 #include <kern/cpu_number.h>
  35 extern void kperf_kernel_configure(char *);
  36 }
  37
  38 #include <IOKit/IOLib.h>
  39 #include <IOKit/IOPlatformExpert.h>
  40 #include <IOKit/pwr_mgt/RootDomain.h>
  41 #include <IOKit/pwr_mgt/IOPMPrivate.h>
  42 #include <libkern/c++/OSSharedPtr.h>
  43 #include <IOKit/IOUserClient.h>
  44 #include <IOKit/IOKitKeysPrivate.h>
  45 #include <IOKit/IOCPU.h>
  46 #include "IOKitKernelInternal.h"
  47
  48 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  49
  50 #include <kern/queue.h>
  51 #include <kern/sched_prim.h>
  52
  53 extern "C" void console_suspend();
  54 extern "C" void console_resume();
  55 extern "C" void sched_override_recommended_cores_for_sleep(void);
  56 extern "C" void sched_restore_recommended_cores_after_sleep(void);
  57
  58 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  59
  60 static IOLock *gIOCPUsLock;
  61 static OSSharedPtr<OSArray> gIOCPUs;
  62 static OSSharedPtr<const OSSymbol> gIOCPUStateKey;
  63 static OSSharedPtr<OSString> gIOCPUStateNames[kIOCPUStateCount];
  64
  65 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  66
  67 #if !USE_APPLEARMSMP
  68
  69 void
  70 IOCPUInitialize(void)
  71 {
  72         gIOCPUsLock = IOLockAlloc();
  73         gIOCPUs     = OSArray::withCapacity(1);
  74
  75         gIOCPUStateKey = OSSymbol::withCStringNoCopy("IOCPUState");
  76
  77         gIOCPUStateNames[kIOCPUStateUnregistered] =
  78             OSString::withCStringNoCopy("Unregistered");
  79         gIOCPUStateNames[kIOCPUStateUninitalized] =
  80             OSString::withCStringNoCopy("Uninitalized");
  81         gIOCPUStateNames[kIOCPUStateStopped] =
  82             OSString::withCStringNoCopy("Stopped");
  83         gIOCPUStateNames[kIOCPUStateRunning] =
  84             OSString::withCStringNoCopy("Running");
  85 }
  86
  87 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  88
  89 kern_return_t
  90 PE_cpu_start(cpu_id_t target,
  91     vm_offset_t start_paddr, vm_offset_t arg_paddr)
  92 {
  93         IOCPU *targetCPU = (IOCPU *)target;
  94
  95         if (targetCPU == NULL) {
  96                 return KERN_FAILURE;
  97         }
  98         return targetCPU->startCPU(start_paddr, arg_paddr);
  99 }
 100
 101 void
 102 PE_cpu_halt(cpu_id_t target)
 103 {
 104         IOCPU *targetCPU = (IOCPU *)target;
 105
 106         targetCPU->haltCPU();
 107 }
 108
 109 void
 110 PE_cpu_signal(cpu_id_t source, cpu_id_t target)
 111 {
 112         IOCPU *sourceCPU = (IOCPU *)source;
 113         IOCPU *targetCPU = (IOCPU *)target;
 114
 115         sourceCPU->signalCPU(targetCPU);
 116 }
 117
 118 void
 119 PE_cpu_signal_deferred(cpu_id_t source, cpu_id_t target)
 120 {
 121         IOCPU *sourceCPU = (IOCPU *)source;
 122         IOCPU *targetCPU = (IOCPU *)target;
 123
 124         sourceCPU->signalCPUDeferred(targetCPU);
 125 }
 126
 127 void
 128 PE_cpu_signal_cancel(cpu_id_t source, cpu_id_t target)
 129 {
 130         IOCPU *sourceCPU = (IOCPU *)source;
 131         IOCPU *targetCPU = (IOCPU *)target;
 132
 133         sourceCPU->signalCPUCancel(targetCPU);
 134 }
 135
 136 void
 137 PE_cpu_machine_init(cpu_id_t target, boolean_t bootb)
 138 {
 139         IOCPU *targetCPU = OSDynamicCast(IOCPU, (OSObject *)target);
 140
 141         if (targetCPU == NULL) {
 142                 panic("%s: invalid target CPU %p", __func__, target);
 143         }
 144
 145         targetCPU->initCPU(bootb);
 146 #if defined(__arm__) || defined(__arm64__)
 147         if (!bootb && (targetCPU->getCPUNumber() == (UInt32)master_cpu)) {
 148                 ml_set_is_quiescing(false);
 149         }
 150 #endif /* defined(__arm__) || defined(__arm64__) */
 151 }
 152
 153 void
 154 PE_cpu_machine_quiesce(cpu_id_t target)
 155 {
 156         IOCPU *targetCPU = (IOCPU*)target;
 157 #if defined(__arm__) || defined(__arm64__)
 158         if (targetCPU->getCPUNumber() == (UInt32)master_cpu) {
 159                 ml_set_is_quiescing(true);
 160         }
 161 #endif /* defined(__arm__) || defined(__arm64__) */
 162         targetCPU->quiesceCPU();
 163 }
 164
 165 #if defined(__arm__) || defined(__arm64__)
 166 static perfmon_interrupt_handler_func pmi_handler = NULL;
 167
 168 kern_return_t
 169 PE_cpu_perfmon_interrupt_install_handler(perfmon_interrupt_handler_func handler)
 170 {
 171         pmi_handler = handler;
 172
 173         return KERN_SUCCESS;
 174 }
 175
 176 void
 177 PE_cpu_perfmon_interrupt_enable(cpu_id_t target, boolean_t enable)
 178 {
 179         IOCPU *targetCPU = (IOCPU*)target;
 180
 181         if (targetCPU == nullptr) {
 182                 return;
 183         }
 184
 185         if (enable) {
 186                 targetCPU->getProvider()->registerInterrupt(1, targetCPU, (IOInterruptAction)pmi_handler, NULL);
 187                 targetCPU->getProvider()->enableInterrupt(1);
 188         } else {
 189                 targetCPU->getProvider()->disableInterrupt(1);
 190         }
 191 }
 192 #endif
 193
 194 #endif /* !USE_APPLEARMSMP */
 195
 196 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 197
 198 #define super IOService
 199
 200 OSDefineMetaClassAndAbstractStructors(IOCPU, IOService);
 201 OSMetaClassDefineReservedUnused(IOCPU, 0);
 202 OSMetaClassDefineReservedUnused(IOCPU, 1);
 203 OSMetaClassDefineReservedUnused(IOCPU, 2);
 204 OSMetaClassDefineReservedUnused(IOCPU, 3);
 205 OSMetaClassDefineReservedUnused(IOCPU, 4);
 206 OSMetaClassDefineReservedUnused(IOCPU, 5);
 207 OSMetaClassDefineReservedUnused(IOCPU, 6);
 208 OSMetaClassDefineReservedUnused(IOCPU, 7);
 209
 210 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 211
 212 #if !USE_APPLEARMSMP
 213 void
 214 IOCPUSleepKernel(void)
 215 {
 216 #if defined(__x86_64__)
 217         extern IOCPU *currentShutdownTarget;
 218 #endif
 219         unsigned int cnt, numCPUs;
 220         IOCPU *target;
 221         IOCPU *bootCPU = NULL;
 222         IOPMrootDomain  *rootDomain = IOService::getPMRootDomain();
 223
 224         printf("IOCPUSleepKernel enter\n");
 225 #if defined(__arm64__)
 226         sched_override_recommended_cores_for_sleep();
 227 #endif
 228
 229         rootDomain->tracePoint( kIOPMTracePointSleepPlatformActions );
 230         IOPlatformActionsPreSleep();
 231         rootDomain->tracePoint( kIOPMTracePointSleepCPUs );
 232
 233         numCPUs = gIOCPUs->getCount();
 234 #if defined(__x86_64__)
 235         currentShutdownTarget = NULL;
 236 #endif
 237
 238         integer_t old_pri;
 239         thread_t self = current_thread();
 240
 241         /*
 242          * We need to boost this thread's priority to the maximum kernel priority to
 243          * ensure we can urgently preempt ANY thread currently executing on the
 244          * target CPU.  Note that realtime threads have their own mechanism to eventually
 245          * demote their priority below MAXPRI_KERNEL if they hog the CPU for too long.
 246          */
 247         old_pri = thread_kern_get_pri(self);
 248         thread_kern_set_pri(self, thread_kern_get_kernel_maxpri());
 249
 250         // Sleep the CPUs.
 251         ml_set_is_quiescing(true);
 252         cnt = numCPUs;
 253         while (cnt--) {
 254                 target = OSDynamicCast(IOCPU, gIOCPUs->getObject(cnt));
 255
 256                 // We make certain that the bootCPU is the last to sleep
 257                 // We'll skip it for now, and halt it after finishing the
 258                 // non-boot CPU's.
 259                 if (target->getCPUNumber() == (UInt32)master_cpu) {
 260                         bootCPU = target;
 261                 } else if (target->getCPUState() == kIOCPUStateRunning) {
 262 #if defined(__x86_64__)
 263                         currentShutdownTarget = target;
 264 #endif
 265                         target->haltCPU();
 266                 }
 267         }
 268
 269         assert(bootCPU != NULL);
 270         assert(cpu_number() == master_cpu);
 271
 272         console_suspend();
 273
 274         rootDomain->tracePoint( kIOPMTracePointSleepPlatformDriver );
 275         rootDomain->stop_watchdog_timer();
 276
 277         /*
 278          * Now sleep the boot CPU, including calling the kQueueQuiesce actions.
 279          * The system sleeps here.
 280          */
 281
 282         bootCPU->haltCPU();
 283         ml_set_is_quiescing(false);
 284
 285         /*
 286          * The system is now coming back from sleep on the boot CPU.
 287          * The kQueueActive actions have already been called.
 288          */
 289
 290         rootDomain->start_watchdog_timer();
 291         rootDomain->tracePoint( kIOPMTracePointWakePlatformActions );
 292
 293         console_resume();
 294
 295         IOPlatformActionsPostResume();
 296         rootDomain->tracePoint( kIOPMTracePointWakeCPUs );
 297
 298         // Wake the other CPUs.
 299         for (cnt = 0; cnt < numCPUs; cnt++) {
 300                 target = OSDynamicCast(IOCPU, gIOCPUs->getObject(cnt));
 301
 302                 // Skip the already-woken boot CPU.
 303                 if (target->getCPUNumber() != (UInt32)master_cpu) {
 304                         if (target->getCPUState() == kIOCPUStateRunning) {
 305                                 panic("Spurious wakeup of cpu %u", (unsigned int)(target->getCPUNumber()));
 306                         }
 307
 308                         if (target->getCPUState() == kIOCPUStateStopped) {
 309                                 processor_start(target->getMachProcessor());
 310                         }
 311                 }
 312         }
 313
 314 #if defined(__arm64__)
 315         sched_restore_recommended_cores_after_sleep();
 316 #endif
 317
 318         thread_kern_set_pri(self, old_pri);
 319         printf("IOCPUSleepKernel exit\n");
 320 }
 321
 322 static bool
 323 is_IOCPU_disabled(void)
 324 {
 325         return false;
 326 }
 327 #else /* !USE_APPLEARMSMP */
 328 static bool
 329 is_IOCPU_disabled(void)
 330 {
 331         return true;
 332 }
 333 #endif /* !USE_APPLEARMSMP */
 334
 335 bool
 336 IOCPU::start(IOService *provider)
 337 {
 338         if (is_IOCPU_disabled()) {
 339                 return false;
 340         }
 341
 342         if (!super::start(provider)) {
 343                 return false;
 344         }
 345
 346         _cpuGroup = gIOCPUs;
 347         cpuNub = provider;
 348
 349         IOLockLock(gIOCPUsLock);
 350         gIOCPUs->setObject(this);
 351         IOLockUnlock(gIOCPUsLock);
 352
 353         // Correct the bus, cpu and timebase frequencies in the device tree.
 354         if (gPEClockFrequencyInfo.bus_frequency_hz < 0x100000000ULL) {
 355                 OSSharedPtr<OSData> busFrequency = OSData::withBytesNoCopy((void *)&gPEClockFrequencyInfo.bus_clock_rate_hz, 4);
 356                 provider->setProperty("bus-frequency", busFrequency.get());
 357         } else {
 358                 OSSharedPtr<OSData> busFrequency = OSData::withBytesNoCopy((void *)&gPEClockFrequencyInfo.bus_frequency_hz, 8);
 359                 provider->setProperty("bus-frequency", busFrequency.get());
 360         }
 361
 362         if (gPEClockFrequencyInfo.cpu_frequency_hz < 0x100000000ULL) {
 363                 OSSharedPtr<OSData> cpuFrequency = OSData::withBytesNoCopy((void *)&gPEClockFrequencyInfo.cpu_clock_rate_hz, 4);
 364                 provider->setProperty("clock-frequency", cpuFrequency.get());
 365         } else {
 366                 OSSharedPtr<OSData> cpuFrequency = OSData::withBytesNoCopy((void *)&gPEClockFrequencyInfo.cpu_frequency_hz, 8);
 367                 provider->setProperty("clock-frequency", cpuFrequency.get());
 368         }
 369
 370         OSSharedPtr<OSData> timebaseFrequency = OSData::withBytesNoCopy((void *)&gPEClockFrequencyInfo.timebase_frequency_hz, 4);
 371         provider->setProperty("timebase-frequency", timebaseFrequency.get());
 372
 373         super::setProperty("IOCPUID", getRegistryEntryID(), sizeof(uint64_t) * 8);
 374
 375         setCPUNumber(0);
 376         setCPUState(kIOCPUStateUnregistered);
 377
 378         return true;
 379 }
 380
 381 void
 382 IOCPU::detach(IOService *provider)
 383 {
 384         if (is_IOCPU_disabled()) {
 385                 return;
 386         }
 387
 388         super::detach(provider);
 389         IOLockLock(gIOCPUsLock);
 390         unsigned int index = gIOCPUs->getNextIndexOfObject(this, 0);
 391         if (index != (unsigned int)-1) {
 392                 gIOCPUs->removeObject(index);
 393         }
 394         IOLockUnlock(gIOCPUsLock);
 395 }
 396
 397 OSObject *
 398 IOCPU::getProperty(const OSSymbol *aKey) const
 399 {
 400         if (aKey == gIOCPUStateKey) {
 401                 return gIOCPUStateNames[_cpuState].get();
 402         }
 403 #pragma clang diagnostic push
 404 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
 405         return super::getProperty(aKey);
 406 #pragma clang diagnostic pop
 407 }
 408
 409 bool
 410 IOCPU::setProperty(const OSSymbol *aKey, OSObject *anObject)
 411 {
 412         if (aKey == gIOCPUStateKey) {
 413                 return false;
 414         }
 415
 416         return super::setProperty(aKey, anObject);
 417 }
 418
 419 bool
 420 IOCPU::serializeProperties(OSSerialize *serialize) const
 421 {
 422         bool result;
 423         OSSharedPtr<OSDictionary> dict = dictionaryWithProperties();
 424         if (!dict) {
 425                 return false;
 426         }
 427         dict->setObject(gIOCPUStateKey.get(), gIOCPUStateNames[_cpuState].get());
 428         result = dict->serialize(serialize);
 429         return result;
 430 }
 431
 432 IOReturn
 433 IOCPU::setProperties(OSObject *properties)
 434 {
 435         OSDictionary *dict = OSDynamicCast(OSDictionary, properties);
 436         OSString     *stateStr;
 437         IOReturn     result;
 438
 439         if (dict == NULL) {
 440                 return kIOReturnUnsupported;
 441         }
 442
 443         stateStr = OSDynamicCast(OSString, dict->getObject(gIOCPUStateKey.get()));
 444         if (stateStr != NULL) {
 445                 result = IOUserClient::clientHasPrivilege(current_task(), kIOClientPrivilegeAdministrator);
 446                 if (result != kIOReturnSuccess) {
 447                         return result;
 448                 }
 449
 450                 if (setProperty(gIOCPUStateKey.get(), stateStr)) {
 451                         return kIOReturnSuccess;
 452                 }
 453
 454                 return kIOReturnUnsupported;
 455         }
 456
 457         return kIOReturnUnsupported;
 458 }
 459
 460 void
 461 IOCPU::signalCPU(IOCPU */*target*/)
 462 {
 463 }
 464
 465 void
 466 IOCPU::signalCPUDeferred(IOCPU *target)
 467 {
 468         // Our CPU may not support deferred IPIs,
 469         // so send a regular IPI by default
 470         signalCPU(target);
 471 }
 472
 473 void
 474 IOCPU::signalCPUCancel(IOCPU */*target*/)
 475 {
 476         // Meant to cancel signals sent by
 477         // signalCPUDeferred; unsupported
 478         // by default
 479 }
 480
 481 void
 482 IOCPU::enableCPUTimeBase(bool /*enable*/)
 483 {
 484 }
 485
 486 UInt32
 487 IOCPU::getCPUNumber(void)
 488 {
 489         return _cpuNumber;
 490 }
 491
 492 void
 493 IOCPU::setCPUNumber(UInt32 cpuNumber)
 494 {
 495         _cpuNumber = cpuNumber;
 496         super::setProperty("IOCPUNumber", _cpuNumber, 32);
 497 }
 498
 499 UInt32
 500 IOCPU::getCPUState(void)
 501 {
 502         return _cpuState;
 503 }
 504
 505 void
 506 IOCPU::setCPUState(UInt32 cpuState)
 507 {
 508         if (cpuState < kIOCPUStateCount) {
 509                 _cpuState = cpuState;
 510         }
 511 }
 512
 513 OSArray *
 514 IOCPU::getCPUGroup(void)
 515 {
 516         return _cpuGroup.get();
 517 }
 518
 519 UInt32
 520 IOCPU::getCPUGroupSize(void)
 521 {
 522         return _cpuGroup->getCount();
 523 }
 524
 525 processor_t
 526 IOCPU::getMachProcessor(void)
 527 {
 528         return machProcessor;
 529 }
 530
 531
 532 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 533
 534 #undef super
 535 #define super IOInterruptController
 536
 537 OSDefineMetaClassAndStructors(IOCPUInterruptController, IOInterruptController);
 538
 539 OSMetaClassDefineReservedUnused(IOCPUInterruptController, 1);
 540 OSMetaClassDefineReservedUnused(IOCPUInterruptController, 2);
 541 OSMetaClassDefineReservedUnused(IOCPUInterruptController, 3);
 542 OSMetaClassDefineReservedUnused(IOCPUInterruptController, 4);
 543 OSMetaClassDefineReservedUnused(IOCPUInterruptController, 5);
 544
 545
 546
 547 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 548
 549 IOReturn
 550 IOCPUInterruptController::initCPUInterruptController(int sources)
 551 {
 552         return initCPUInterruptController(sources, sources);
 553 }
 554
 555 IOReturn
 556 IOCPUInterruptController::initCPUInterruptController(int sources, int cpus)
 557 {
 558         int cnt;
 559
 560         if (!super::init()) {
 561                 return kIOReturnInvalid;
 562         }
 563
 564         numSources = sources;
 565         numCPUs = cpus;
 566
 567         vectors = (IOInterruptVector *)IOMalloc(numSources * sizeof(IOInterruptVector));
 568         if (vectors == NULL) {
 569                 return kIOReturnNoMemory;
 570         }
 571         bzero(vectors, numSources * sizeof(IOInterruptVector));
 572
 573         // Allocate a lock for each vector
 574         for (cnt = 0; cnt < numSources; cnt++) {
 575                 vectors[cnt].interruptLock = IOLockAlloc();
 576                 if (vectors[cnt].interruptLock == NULL) {
 577                         for (cnt = 0; cnt < numSources; cnt++) {
 578                                 if (vectors[cnt].interruptLock != NULL) {
 579                                         IOLockFree(vectors[cnt].interruptLock);
 580                                 }
 581                         }
 582                         return kIOReturnNoResources;
 583                 }
 584         }
 585
 586         ml_set_max_cpus(numSources);
 587         return kIOReturnSuccess;
 588 }
 589
 590 void
 591 IOCPUInterruptController::registerCPUInterruptController(void)
 592 {
 593         setProperty(gPlatformInterruptControllerName, kOSBooleanTrue);
 594         registerService();
 595
 596         getPlatform()->registerInterruptController(gPlatformInterruptControllerName,
 597             this);
 598 }
 599
 600 void
 601 IOCPUInterruptController::setCPUInterruptProperties(IOService *service)
 602 {
 603         int          cnt;
 604         OSSharedPtr<OSArray> specifier;
 605         OSSharedPtr<OSArray> controller;
 606         long         tmpLong;
 607
 608         if ((service->propertyExists(gIOInterruptControllersKey)) &&
 609             (service->propertyExists(gIOInterruptSpecifiersKey))) {
 610                 return;
 611         }
 612
 613         // Create the interrupt specifer array.
 614         specifier = OSArray::withCapacity(numSources);
 615         for (cnt = 0; cnt < numSources; cnt++) {
 616                 tmpLong = cnt;
 617                 OSSharedPtr<OSData> tmpData = OSData::withBytes(&tmpLong, sizeof(tmpLong));
 618                 specifier->setObject(tmpData.get());
 619         }
 620
 621         // Create the interrupt controller array.
 622         controller = OSArray::withCapacity(numSources);
 623         for (cnt = 0; cnt < numSources; cnt++) {
 624                 controller->setObject(gPlatformInterruptControllerName);
 625         }
 626
 627         // Put the two arrays into the property table.
 628         service->setProperty(gIOInterruptControllersKey, controller.get());
 629         service->setProperty(gIOInterruptSpecifiersKey, specifier.get());
 630 }
 631
 632 void
 633 IOCPUInterruptController::enableCPUInterrupt(IOCPU *cpu)
 634 {
 635         IOInterruptHandler handler = OSMemberFunctionCast(
 636                 IOInterruptHandler, this, &IOCPUInterruptController::handleInterrupt);
 637
 638         assert(numCPUs > 0);
 639
 640         ml_install_interrupt_handler(cpu, cpu->getCPUNumber(), this, handler, NULL);
 641
 642         IOTakeLock(vectors[0].interruptLock);
 643         ++enabledCPUs;
 644
 645         if (enabledCPUs == numCPUs) {
 646                 IOService::cpusRunning();
 647                 thread_wakeup(this);
 648         }
 649         IOUnlock(vectors[0].interruptLock);
 650 }
 651
 652 IOReturn
 653 IOCPUInterruptController::registerInterrupt(IOService *nub,
 654     int source,
 655     void *target,
 656     IOInterruptHandler handler,
 657     void *refCon)
 658 {
 659         IOInterruptVector *vector;
 660
 661         // Interrupts must be enabled, as this can allocate memory.
 662         assert(ml_get_interrupts_enabled() == TRUE);
 663
 664         if (source >= numSources) {
 665                 return kIOReturnNoResources;
 666         }
 667
 668         vector = &vectors[source];
 669
 670         // Get the lock for this vector.
 671         IOTakeLock(vector->interruptLock);
 672
 673         // Make sure the vector is not in use.
 674         if (vector->interruptRegistered) {
 675                 IOUnlock(vector->interruptLock);
 676                 return kIOReturnNoResources;
 677         }
 678
 679         // Fill in vector with the client's info.
 680         vector->handler = handler;
 681         vector->nub     = nub;
 682         vector->source  = source;
 683         vector->target  = target;
 684         vector->refCon  = refCon;
 685
 686         // Get the vector ready.  It starts hard disabled.
 687         vector->interruptDisabledHard = 1;
 688         vector->interruptDisabledSoft = 1;
 689         vector->interruptRegistered   = 1;
 690
 691         IOUnlock(vector->interruptLock);
 692
 693         IOTakeLock(vectors[0].interruptLock);
 694         if (enabledCPUs != numCPUs) {
 695                 assert_wait(this, THREAD_UNINT);
 696                 IOUnlock(vectors[0].interruptLock);
 697                 thread_block(THREAD_CONTINUE_NULL);
 698         } else {
 699                 IOUnlock(vectors[0].interruptLock);
 700         }
 701
 702         return kIOReturnSuccess;
 703 }
 704
 705 IOReturn
 706 IOCPUInterruptController::getInterruptType(IOService */*nub*/,
 707     int /*source*/,
 708     int *interruptType)
 709 {
 710         if (interruptType == NULL) {
 711                 return kIOReturnBadArgument;
 712         }
 713
 714         *interruptType = kIOInterruptTypeLevel;
 715
 716         return kIOReturnSuccess;
 717 }
 718
 719 IOReturn
 720 IOCPUInterruptController::enableInterrupt(IOService */*nub*/,
 721     int /*source*/)
 722 {
 723 //  ml_set_interrupts_enabled(true);
 724         return kIOReturnSuccess;
 725 }
 726
 727 IOReturn
 728 IOCPUInterruptController::disableInterrupt(IOService */*nub*/,
 729     int /*source*/)
 730 {
 731 //  ml_set_interrupts_enabled(false);
 732         return kIOReturnSuccess;
 733 }
 734
 735 IOReturn
 736 IOCPUInterruptController::causeInterrupt(IOService */*nub*/,
 737     int /*source*/)
 738 {
 739         ml_cause_interrupt();
 740         return kIOReturnSuccess;
 741 }
 742
 743 IOReturn
 744 IOCPUInterruptController::handleInterrupt(void */*refCon*/,
 745     IOService */*nub*/,
 746     int source)
 747 {
 748         IOInterruptVector *vector;
 749
 750         vector = &vectors[source];
 751
 752         if (!vector->interruptRegistered) {
 753                 return kIOReturnInvalid;
 754         }
 755
 756         vector->handler(vector->target, vector->refCon,
 757             vector->nub, vector->source);
 758
 759         return kIOReturnSuccess;
 760 }
 761
 762 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */