VirtualBox

Changeset 26593 in vbox


Ignore:
Timestamp:
Feb 17, 2010 1:16:10 AM (15 years ago)
Author:
vboxsync
Message:

CPU hotplug: Remove a lot of code duplication in the CPU hotplug SSDT using the gcc preprocessor (iasl doesn't has something similar).

Location:
trunk/src/VBox/Devices
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/Makefile.kmk

    r26560 r26593  
    480480        $(PATH_DevicesR3)/vboxssdt-cpuhotplug.hex \
    481481        $(PATH_DevicesR3)/vboxssdt-cpuhotplug.aml \
    482         $(PATH_DevicesR3)/vboxssdt-cpuhotplug.aml.tmp
     482        $(PATH_DevicesR3)/vboxssdt-cpuhotplug.aml.tmp \
     483        $(PATH_DevicesR3)/vboxssdt-cpuhotplug.aml.pre
    483484 PC/ACPI/VBoxAcpi.cpp_DEPS = \
    484485        $(PATH_DevicesR3)/vboxaml.hex \
    … …  
    506507 $$(PATH_DevicesR3)/vboxssdt-cpuhotplug.hex: $(PATH_SUB_CURRENT)/PC/vbox-cpuhotplug.dsl | $$(dir $$@)
    507508        $(call MSG_TOOL,iasl,DevicesR3,$<,$@)
    508         $(QUIET)$(RM) -f $@ [email protected]
    509         $(QUIET)$(VBOX_IASLCMD) -tc -vs -p $@ $<
     509        $(QUIET)$(RM) -f $@ [email protected] [email protected]
     510        $(QUIET)$(TOOL_$(VBOX_GCC_TOOL)_CC) -E -P -x c -o [email protected] $<
     511        $(QUIET)$(VBOX_IASLCMD) -tc -vs -p $@ [email protected]
    510512        $(QUIET)$(MV) -f $@ [email protected]
    511513        $(QUIET)$(SED) "s/AmlCode/AmlCodeSsdtCpuHotPlug/g" \
    512514                --output $@ [email protected]
    513         $(QUIET)$(RM) -f [email protected]
     515        $(QUIET)$(RM) -f [email protected] [email protected]
    514516
    515517

  • trunk/src/VBox/Devices/PC/vbox-cpuhotplug.dsl

    r26095 r26593  
    3232    Scope (\_SB)
    3333    {
    34         Device (SCK0)
    35         {
    36             Name (_HID, "ACPI0004")
    37             Name (_UID, "SCKCPU0")
    3834
    39             Method (_STA, 0, NotSerialized)
    40             {
    41                 IF (CPCK(0x00))
    42                 {
    43                     Return (0xF)
    44                 }
    45                 Else
    46                 {
    47                     Return (0x0)
    48                 }
    49             }
     35#define GENERATE_CPU_OBJECT(id, sck, sckuid, cpu, cpuuid)                  \
     36    Device (sck)                                                           \
     37    {                                                                      \
     38        Name (_HID, "ACPI0004")                                            \
     39        Name (_UID, sckuid)                                                \
     40                                                                           \
     41        Method (_STA, 0, NotSerialized)                                    \
     42        {                                                                  \
     43            IF (CPCK(id))                                                  \
     44            {                                                              \
     45                Return (0xF)                                               \
     46            }                                                              \
     47            Else                                                           \
     48            {                                                              \
     49                Return (0x0)                                               \
     50            }                                                              \
     51        }                                                                  \
     52                                                                           \
     53        Processor (cpu, /* Name */                                         \
     54                   id,  /* Id */                                           \
     55                   0x0, /* Processor IO ports range start */               \
     56                   0x0  /* Processor IO ports range length */              \
     57                   )                                                       \
     58        {                                                                  \
     59            Name (_HID, "ACPI0007")                                        \
     60            Name (_UID, cpuuid)                                            \
     61            Name (_PXM, 0x00)                                              \
     62                                                                           \
     63            Method(_MAT, 0)                                                \
     64            {                                                              \
     65                IF (CPCK(id))                                              \
     66                {                                                          \
     67                    Name (APIC, Buffer (8) {0x00, 0x08, id, id, 0x01})     \
     68                    Return(APIC)                                           \
     69                }                                                          \
     70                Else                                                       \
     71                {                                                          \
     72                    Return (0x00)                                          \
     73                }                                                          \
     74            }                                                              \
     75            Method(_STA) /* Used for device presence detection */          \
     76            {                                                              \
     77                IF (CPCK(id))                                              \
     78                {                                                          \
     79                    Return (0xF)                                           \
     80                }                                                          \
     81                Else                                                       \
     82                {                                                          \
     83                    Return (0x0)                                           \
     84                }                                                          \
     85            }                                                              \
     86            Method(_EJ0, 1)                                                \
     87            {                                                              \
     88                Store(id, \_SB.CPUL) /* Unlock the CPU */                  \
     89                Return                                                     \
     90            }                                                              \
     91        }                                                                  \
     92    }                                                                      \
    5093
    51             Processor (CPU0, /* Name */
    52                        0x00, /* Id */
    53                        0x0,  /* Processor IO ports range start */
    54                        0x0   /* Processor IO ports range length */
    55                        )
    56             {
    57                 Name (_HID, "ACPI0007")
    58                 Name (_UID, "SCK0-CPU0")
    59                 Name (_PXM, 0x00)
     94        GENERATE_CPU_OBJECT(0x00, SCK0, "SCKCPU0", CPU0, "SCK0-CPU0")
     95        GENERATE_CPU_OBJECT(0x01, SCK1, "SCKCPU1", CPU1, "SCK1-CPU0")
     96        GENERATE_CPU_OBJECT(0x02, SCK2, "SCKCPU2", CPU2, "SCK2-CPU0")
     97        GENERATE_CPU_OBJECT(0x03, SCK3, "SCKCPU3", CPU3, "SCK3-CPU0")
     98        GENERATE_CPU_OBJECT(0x04, SCK4, "SCKCPU4", CPU4, "SCK4-CPU0")
     99        GENERATE_CPU_OBJECT(0x05, SCK5, "SCKCPU5", CPU5, "SCK5-CPU0")
     100        GENERATE_CPU_OBJECT(0x06, SCK6, "SCKCPU6", CPU6, "SCK6-CPU0")
     101        GENERATE_CPU_OBJECT(0x07, SCK7, "SCKCPU7", CPU7, "SCK7-CPU0")
     102        GENERATE_CPU_OBJECT(0x08, SCK8, "SCKCPU8", CPU8, "SCK8-CPU0")
     103        GENERATE_CPU_OBJECT(0x09, SCK9, "SCKCPU9", CPU9, "SCK9-CPU0")
     104        GENERATE_CPU_OBJECT(0x0a, SCKA, "SCKCPUA", CPUA, "SCKA-CPU0")
     105        GENERATE_CPU_OBJECT(0x0b, SCKB, "SCKCPUB", CPUB, "SCKB-CPU0")
     106        GENERATE_CPU_OBJECT(0x0c, SCKC, "SCKCPUC", CPUC, "SCKC-CPU0")
     107        GENERATE_CPU_OBJECT(0x0d, SCKD, "SCKCPUD", CPUD, "SCKD-CPU0")
     108        GENERATE_CPU_OBJECT(0x0e, SCKE, "SCKCPUE", CPUE, "SCKE-CPU0")
     109        GENERATE_CPU_OBJECT(0x0f, SCKF, "SCKCPUF", CPUF, "SCKF-CPU0")
     110        GENERATE_CPU_OBJECT(0x10, SCKG, "SCKCPUG", CPUG, "SCKG-CPU0")
     111        GENERATE_CPU_OBJECT(0x11, SCKH, "SCKCPUH", CPUH, "SCKH-CPU0")
     112        GENERATE_CPU_OBJECT(0x12, SCKI, "SCKCPUI", CPUI, "SCKI-CPU0")
     113        GENERATE_CPU_OBJECT(0x13, SCKJ, "SCKCPUJ", CPUJ, "SCKJ-CPU0")
     114        GENERATE_CPU_OBJECT(0x14, SCKK, "SCKCPUK", CPUK, "SCKK-CPU0")
     115        GENERATE_CPU_OBJECT(0x15, SCKL, "SCKCPUL", CPUL, "SCKL-CPU0")
     116        GENERATE_CPU_OBJECT(0x16, SCKM, "SCKCPUM", CPUM, "SCKM-CPU0")
     117        GENERATE_CPU_OBJECT(0x17, SCKN, "SCKCPUN", CPUN, "SCKN-CPU0")
     118        GENERATE_CPU_OBJECT(0x18, SCKO, "SCKCPUO", CPUO, "SCKO-CPU0")
     119        GENERATE_CPU_OBJECT(0x19, SCKP, "SCKCPUP", CPUP, "SCKP-CPU0")
     120        GENERATE_CPU_OBJECT(0x1a, SCKQ, "SCKCPUQ", CPUQ, "SCKQ-CPU0")
     121        GENERATE_CPU_OBJECT(0x1b, SCKR, "SCKCPUR", CPUR, "SCKR-CPU0")
     122        GENERATE_CPU_OBJECT(0x1c, SCKS, "SCKCPUS", CPUS, "SCKS-CPU0")
     123        GENERATE_CPU_OBJECT(0x1d, SCKT, "SCKCPUT", CPUT, "SCKT-CPU0")
     124        GENERATE_CPU_OBJECT(0x1e, SCKU, "SCKCPUU", CPUU, "SCKU-CPU0")
     125        GENERATE_CPU_OBJECT(0x1f, SCKV, "SCKCPUV", CPUV, "SCKV-CPU0")
    60126
    61                 Method(_MAT, 0)
    62                 {
    63                     IF (CPCK(0x00))
    64                     {
    65                         Name (APIC, Buffer (8) {0x00, 0x08, 0x00, 0x00, 0x01})
    66                         Return(APIC)
    67                     }
    68                     Else
    69                     {
    70                         Return (0x00)
    71                     }
    72                 }
    73                 Method(_STA) // Used for device presence detection
    74                 {
    75                     IF (CPCK(0x00))
    76                     {
    77                         Return (0xF)
    78                     }
    79                     Else
    80                     {
    81                         Return (0x0)
    82                     }
    83                 }
    84                 Method(_EJ0, 1)
    85                 {
    86                     Store(0x0, \_SB.CPUL) // Unlock the CPU
    87                     Return
    88                 }
    89             }
    90         }
    91 
    92         Device (SCK1)
    93         {
    94             Name (_HID, "ACPI0004")
    95             Name (_UID, "SCKCPU1")
    96 
    97             Method (_STA, 0, NotSerialized)
    98             {
    99                 Return (0xF)
    100             }
    101 
    102             Processor (CPU1, /* Name */
    103                        0x01, /* Id */
    104                        0x0,  /* Processor IO ports range start */
    105                        0x0   /* Processor IO ports range length */
    106                        )
    107             {
    108                 Name (_HID, "ACPI0007")
    109                 Name (_UID, "SCK1-CPU0")
    110                 Name (_PXM, 0x00)
    111 
    112                 Method(_MAT, 0)
    113                 {
    114                     IF (CPCK(0x01))
    115                     {
    116                         Name (APIC, Buffer (8) {0x00, 0x08, 0x01, 0x01, 0x01})
    117                         Return(APIC)
    118                     }
    119                     Else
    120                     {
    121                         Return (0x00)
    122                     }
    123                 }
    124 
    125                 Method(_STA) // Used for device presence detection
    126                 {
    127                     IF (CPCK(0x01))
    128                     {
    129                         Return (0xF)
    130                     }
    131                     Else
    132                     {
    133                         Return (0x0)
    134                     }
    135                 }
    136 
    137                 Method(_EJ0, 1)
    138                 {
    139                     Store(0x1, \_SB.CPUL) // Unlock the CPU
    140                     Return
    141                 }
    142             }
    143         }
    144 
    145         Device (SCK2)
    146         {
    147             Name (_HID, "ACPI0004")
    148             Name (_UID, "SCKCPU2")
    149 
    150             Method (_STA, 0, NotSerialized)
    151             {
    152                 IF (CPCK(0x02))
    153                 {
    154                     Return (0xF)
    155                 }
    156                 Else
    157                 {
    158                     Return (0x0)
    159                 }
    160             }
    161 
    162             Processor (CPU2, /* Name */
    163                        0x02, /* Id */
    164                        0x0,  /* Processor IO ports range start */
    165                        0x0   /* Processor IO ports range length */
    166                        )
    167             {
    168                 Name (_HID, "ACPI0007")
    169                 Name (_UID, "SCK2-CPU0")
    170                 Name (_PXM, 0x00)
    171 
    172                 Method(_MAT, 0)
    173                 {
    174                     IF (CPCK(0x02))
    175                     {
    176                         Name (APIC, Buffer (8) {0x00, 0x08, 0x02, 0x02, 0x01})
    177                         Return(APIC)
    178                     }
    179                     Else
    180                     {
    181                         Return (0x00)
    182                     }
    183                 }
    184 
    185                 Method(_STA) // Used for device presence detection
    186                 {
    187                     IF (CPCK(0x02))
    188                     {
    189                         Return (0xF)
    190                     }
    191                     Else
    192                     {
    193                         Return (0x0)
    194                     }
    195                 }
    196 
    197                 Method(_EJ0, 1)
    198                 {
    199                     Store(0x2, \_SB.CPUL) // Unlock the CPU
    200                     Return
    201                 }
    202             }
    203         }
    204 
    205         Device (SCK3)
    206         {
    207             Name (_HID, "ACPI0004")
    208             Name (_UID, "SCKCPU3")
    209 
    210             Method (_STA, 0, NotSerialized)
    211             {
    212                 IF (CPCK(0x03))
    213                 {
    214                     Return (0xF)
    215                 }
    216                 Else
    217                 {
    218                     Return (0x0)
    219                 }
    220             }
    221 
    222             Processor (CPU3, /* Name */
    223                        0x03, /* Id */
    224                        0x0,  /* Processor IO ports range start */
    225                        0x0   /* Processor IO ports range length */
    226                        )
    227             {
    228                 Name (_HID, "ACPI0007")
    229                 Name (_UID, "SCK3-CPU0")
    230                 Name (_PXM, 0x00)
    231 
    232                 Method(_MAT, 0)
    233                 {
    234                     IF (CPCK(0x03))
    235                     {
    236                         Name (APIC, Buffer (8) {0x00, 0x08, 0x03, 0x03, 0x01})
    237                         Return(APIC)
    238                     }
    239                     Else
    240                     {
    241                         Return (0x00)
    242                     }
    243                 }
    244 
    245                 Method(_STA) // Used for device presence detection
    246                 {
    247                     IF (CPCK(0x03))
    248                     {
    249                         Return (0xF)
    250                     }
    251                     Else
    252                     {
    253                         Return (0x0)
    254                     }
    255                 }
    256 
    257                 Method(_EJ0, 1)
    258                 {
    259                     Store(0x3, \_SB.CPUL) // Unlock the CPU
    260                     Return
    261                 }
    262             }
    263         }
    264 
    265         Device (SCK4)
    266         {
    267             Name (_HID, "ACPI0004")
    268             Name (_UID, "SCKCPU4")
    269 
    270             Method (_STA, 0, NotSerialized)
    271             {
    272                 IF (CPCK(0x04))
    273                 {
    274                     Return (0xF)
    275                 }
    276                 Else
    277                 {
    278                     Return (0x0)
    279                 }
    280             }
    281 
    282             Processor (CPU4, /* Name */
    283                        0x04, /* Id */
    284                        0x0,  /* Processor IO ports range start */
    285                        0x0   /* Processor IO ports range length */
    286                        )
    287             {
    288                 Name (_HID, "ACPI0007")
    289                 Name (_UID, "SCK4-CPU0")
    290                 Name (_PXM, 0x00)
    291 
    292                 Method(_MAT, 0)
    293                 {
    294                     IF (CPCK(0x04))
    295                     {
    296                         Name (APIC, Buffer (8) {0x00, 0x08, 0x04, 0x04, 0x01})
    297                         Return(APIC)
    298                     }
    299                     Else
    300                     {
    301                         Return (0x00)
    302                     }
    303                 }
    304 
    305                 Method(_STA) // Used for device presence detection
    306                 {
    307                     IF (CPCK(0x04))
    308                     {
    309                         Return (0xF)
    310                     }
    311                     Else
    312                     {
    313                         Return (0x0)
    314                     }
    315                 }
    316 
    317                 Method(_EJ0, 1)
    318                 {
    319                     Store(0x4, \_SB.CPUL) // Unlock the CPU
    320                     Return
    321                 }
    322             }
    323         }
    324 
    325         Device (SCK5)
    326         {
    327             Name (_HID, "ACPI0004")
    328             Name (_UID, "SCKCPU5")
    329 
    330             Method (_STA, 0, NotSerialized)
    331             {
    332                 IF (CPCK(0x05))
    333                 {
    334                     Return (0xF)
    335                 }
    336                 Else
    337                 {
    338                     Return (0x0)
    339                 }
    340             }
    341 
    342             Processor (CPU5, /* Name */
    343                        0x05, /* Id */
    344                        0x0,  /* Processor IO ports range start */
    345                        0x0   /* Processor IO ports range length */
    346                        )
    347             {
    348                 Name (_HID, "ACPI0007")
    349                 Name (_UID, "SCK5-CPU0")
    350                 Name (_PXM, 0x00)
    351 
    352                 Method(_MAT, 0)
    353                 {
    354                     IF (CPCK(0x05))
    355                     {
    356                         Name (APIC, Buffer (8) {0x00, 0x08, 0x05, 0x05, 0x01})
    357                         Return(APIC)
    358                     }
    359                     Else
    360                     {
    361                         Return (0x00)
    362                     }
    363                 }
    364 
    365                 Method(_STA) // Used for device presence detection
    366                 {
    367                     IF (CPCK(0x05))
    368                     {
    369                         Return (0xF)
    370                     }
    371                     Else
    372                     {
    373                         Return (0x0)
    374                     }
    375                 }
    376 
    377                 Method(_EJ0, 1)
    378                 {
    379                     Store(0x5, \_SB.CPUL) // Unlock the CPU
    380                     Return
    381                 }
    382             }
    383         }
    384 
    385         Device (SCK6)
    386         {
    387             Name (_HID, "ACPI0004")
    388             Name (_UID, "SCKCPU6")
    389 
    390             Method (_STA, 0, NotSerialized)
    391             {
    392                 IF (CPCK(0x06))
    393                 {
    394                     Return (0xF)
    395                 }
    396                 Else
    397                 {
    398                     Return (0x0)
    399                 }
    400             }
    401 
    402             Processor (CPU6, /* Name */
    403                        0x06, /* Id */
    404                        0x0,  /* Processor IO ports range start */
    405                        0x0   /* Processor IO ports range length */
    406                        )
    407             {
    408                 Name (_HID, "ACPI0007")
    409                 Name (_UID, "SCK6-CPU0")
    410                 Name (_PXM, 0x00)
    411 
    412                 Method(_MAT, 0)
    413                 {
    414                     IF (CPCK(0x6))
    415                     {
    416                         Name (APIC, Buffer (8) {0x00, 0x08, 0x06, 0x06, 0x01})
    417                         Return(APIC)
    418                     }
    419                     Else
    420                     {
    421                         Return (0x00)
    422                     }
    423                 }
    424 
    425                 Method(_STA) // Used for device presence detection
    426                 {
    427                     IF (CPCK(0x06))
    428                     {
    429                         Return (0xF)
    430                     }
    431                     Else
    432                     {
    433                         Return (0x0)
    434                     }
    435                 }
    436 
    437                 Method(_EJ0, 1)
    438                 {
    439                     Store(0x6, \_SB.CPUL) // Unlock the CPU
    440                     Return
    441                 }
    442             }
    443         }
    444 
    445         Device (SCK7)
    446         {
    447             Name (_HID, "ACPI0004")
    448             Name (_UID, "SCKCPU7")
    449 
    450             Method (_STA, 0, NotSerialized)
    451             {
    452                 IF (CPCK(0x07))
    453                 {
    454                     Return (0xF)
    455                 }
    456                 Else
    457                 {
    458                     Return (0x0)
    459                 }
    460             }
    461 
    462             Processor (CPU7, /* Name */
    463                        0x07, /* Id */
    464                        0x0,  /* Processor IO ports range start */
    465                        0x0   /* Processor IO ports range length */
    466                        )
    467             {
    468                 Name (_HID, "ACPI0007")
    469                 Name (_UID, "SCK7-CPU0")
    470                 Name (_PXM, 0x00)
    471 
    472                 Method(_MAT, 0)
    473                 {
    474                     IF (CPCK(0x07))
    475                     {
    476                         Name (APIC, Buffer (8) {0x00, 0x08, 0x07, 0x07, 0x01})
    477                         Return(APIC)
    478                     }
    479                     Else
    480                     {
    481                         Return (0x00)
    482                     }
    483                 }
    484 
    485                 Method(_STA) // Used for device presence detection
    486                 {
    487                     IF (CPCK(0x07))
    488                     {
    489                         Return (0xF)
    490                     }
    491                     Else
    492                     {
    493                         Return (0x0)
    494                     }
    495                 }
    496 
    497                 Method(_EJ0, 1)
    498                 {
    499                     Store(0x7, \_SB.CPUL) // Unlock the CPU
    500                     Return
    501                 }
    502             }
    503         }
    504 
    505         Device (SCK8)
    506         {
    507             Name (_HID, "ACPI0004")
    508             Name (_UID, "SCKCPU8")
    509 
    510             Method (_STA, 0, NotSerialized)
    511             {
    512                 IF (CPCK(0x08))
    513                 {
    514                     Return (0xF)
    515                 }
    516                 Else
    517                 {
    518                     Return (0x0)
    519                 }
    520             }
    521 
    522             Processor (CPU8, /* Name */
    523                        0x08, /* Id */
    524                        0x0,  /* Processor IO ports range start */
    525                        0x0   /* Processor IO ports range length */
    526                        )
    527             {
    528                 Name (_HID, "ACPI0007")
    529                 Name (_UID, "SCK4-CPU0")
    530                 Name (_PXM, 0x00)
    531 
    532                 Method(_MAT, 0)
    533                 {
    534                     IF (CPCK(0x08))
    535                     {
    536                         Name (APIC, Buffer (8) {0x00, 0x08, 0x08, 0x08, 0x01})
    537                         Return(APIC)
    538                     }
    539                     Else
    540                     {
    541                         Return (0x00)
    542                     }
    543                 }
    544 
    545                 Method(_STA) // Used for device presence detection
    546                 {
    547                     IF (CPCK(0x08))
    548                     {
    549                         Return (0xF)
    550                     }
    551                     Else
    552                     {
    553                         Return (0x0)
    554                     }
    555                 }
    556 
    557                 Method(_EJ0, 1)
    558                 {
    559                     Store(0x8, \_SB.CPUL) // Unlock the CPU
    560                     Return
    561                 }
    562             }
    563         }
    564 
    565         Device (SCK9)
    566         {
    567             Name (_HID, "ACPI0004")
    568             Name (_UID, "SCKCPU9")
    569 
    570             Method (_STA, 0, NotSerialized)
    571             {
    572                 IF (CPCK(0x09))
    573                 {
    574                     Return (0xF)
    575                 }
    576                 Else
    577                 {
    578                     Return (0x0)
    579                 }
    580             }
    581 
    582             Processor (CPU9, /* Name */
    583                        0x09, /* Id */
    584                        0x0,  /* Processor IO ports range start */
    585                        0x0   /* Processor IO ports range length */
    586                        )
    587             {
    588                 Name (_HID, "ACPI0007")
    589                 Name (_UID, "SCK9-CPU0")
    590                 Name (_PXM, 0x00)
    591 
    592                 Method(_MAT, 0)
    593                 {
    594                     IF (CPCK(0x09))
    595                     {
    596                         Name (APIC, Buffer (8) {0x00, 0x08, 0x09, 0x09, 0x01})
    597                         Return(APIC)
    598                     }
    599                     Else
    600                     {
    601                         Return (0x00)
    602                     }
    603                 }
    604 
    605                 Method(_STA) // Used for device presence detection
    606                 {
    607                     IF (CPCK(0x09))
    608                     {
    609                         Return (0xF)
    610                     }
    611                     Else
    612                     {
    613                         Return (0x0)
    614                     }
    615                 }
    616 
    617                 Method(_EJ0, 1)
    618                 {
    619                     Store(0x9, \_SB.CPUL) // Unlock the CPU
    620                     Return
    621                 }
    622             }
    623         }
    624 
    625         Device (SCKA)
    626         {
    627             Name (_HID, "ACPI0004")
    628             Name (_UID, "SCKCPUA")
    629 
    630             Method (_STA, 0, NotSerialized)
    631             {
    632                 IF (CPCK(0x0a))
    633                 {
    634                     Return (0xF)
    635                 }
    636                 Else
    637                 {
    638                     Return (0x0)
    639                 }
    640             }
    641 
    642             Processor (CPUA, /* Name */
    643                        0x0a, /* Id */
    644                        0x0,  /* Processor IO ports range start */
    645                        0x0   /* Processor IO ports range length */
    646                        )
    647             {
    648                 Name (_HID, "ACPI0007")
    649                 Name (_UID, "SCKA-CPU0")
    650                 Name (_PXM, 0x00)
    651 
    652                 Method(_MAT, 0)
    653                 {
    654                     IF (CPCK(0x0a))
    655                     {
    656                         Name (APIC, Buffer (8) {0x00, 0x08, 0x0a, 0x0a, 0x01})
    657                         Return(APIC)
    658                     }
    659                     Else
    660                     {
    661                         Return (0x00)
    662                     }
    663                 }
    664 
    665                 Method(_STA) // Used for device presence detection
    666                 {
    667                     IF (CPCK(0x0a))
    668                     {
    669                         Return (0xF)
    670                     }
    671                     Else
    672                     {
    673                         Return (0x0)
    674                     }
    675                 }
    676 
    677                 Method(_EJ0, 1)
    678                 {
    679                     Store(0x0a, \_SB.CPUL) // Unlock the CPU
    680                     Return
    681                 }
    682             }
    683         }
    684 
    685         Device (SCKB)
    686         {
    687             Name (_HID, "ACPI0004")
    688             Name (_UID, "SCKCPUB")
    689 
    690             Method (_STA, 0, NotSerialized)
    691             {
    692                 IF (CPCK(0x0b))
    693                 {
    694                     Return (0xF)
    695                 }
    696                 Else
    697                 {
    698                     Return (0x0)
    699                 }
    700             }
    701 
    702             Processor (CPUB, /* Name */
    703                        0x0b, /* Id */
    704                        0x0,  /* Processor IO ports range start */
    705                        0x0   /* Processor IO ports range length */
    706                        )
    707             {
    708                 Name (_HID, "ACPI0007")
    709                 Name (_UID, "SCKB-CPU0")
    710                 Name (_PXM, 0x00)
    711 
    712                 Method(_MAT, 0)
    713                 {
    714                     IF (CPCK(0x0b))
    715                     {
    716                         Name (APIC, Buffer (8) {0x00, 0x08, 0x0b, 0x0b, 0x01})
    717                         Return(APIC)
    718                     }
    719                     Else
    720                     {
    721                         Return (0x00)
    722                     }
    723                 }
    724 
    725                 Method(_STA) // Used for device presence detection
    726                 {
    727                     IF (CPCK(0x0b))
    728                     {
    729                         Return (0xF)
    730                     }
    731                     Else
    732                     {
    733                         Return (0x0)
    734                     }
    735                 }
    736 
    737                 Method(_EJ0, 1)
    738                 {
    739                     Store(0x0b, \_SB.CPUL) // Unlock the CPU
    740                     Return
    741                 }
    742             }
    743         }
    744 
    745         Device (SCKC)
    746         {
    747             Name (_HID, "ACPI0004")
    748             Name (_UID, "SCKCPUC")
    749 
    750             Method (_STA, 0, NotSerialized)
    751             {
    752                 IF (CPCK(0x0c))
    753                 {
    754                     Return (0xF)
    755                 }
    756                 Else
    757                 {
    758                     Return (0x0)
    759                 }
    760             }
    761 
    762             Processor (CPUC, /* Name */
    763                        0x0c, /* Id */
    764                        0x0,  /* Processor IO ports range start */
    765                        0x0   /* Processor IO ports range length */
    766                        )
    767             {
    768                 Name (_HID, "ACPI0007")
    769                 Name (_UID, "SCKC-CPU0")
    770                 Name (_PXM, 0x00)
    771 
    772                 Method(_MAT, 0)
    773                 {
    774                     IF (CPCK(0x0c))
    775                     {
    776                         Name (APIC, Buffer (8) {0x00, 0x08, 0x0c, 0x0c, 0x01})
    777                         Return(APIC)
    778                     }
    779                     Else
    780                     {
    781                         Return (0x00)
    782                     }
    783                 }
    784 
    785                 Method(_STA) // Used for device presence detection
    786                 {
    787                     IF (CPCK(0x0c))
    788                     {
    789                         Return (0xF)
    790                     }
    791                     Else
    792                     {
    793                         Return (0x0)
    794                     }
    795                 }
    796 
    797                 Method(_EJ0, 1)
    798                 {
    799                     Store(0x0c, \_SB.CPUL) // Unlock the CPU
    800                     Return
    801                 }
    802             }
    803         }
    804 
    805         Device (SCKD)
    806         {
    807             Name (_HID, "ACPI0004")
    808             Name (_UID, "SCKCPUD")
    809 
    810             Method (_STA, 0, NotSerialized)
    811             {
    812                 IF (CPCK(0x0d))
    813                 {
    814                     Return (0xF)
    815                 }
    816                 Else
    817                 {
    818                     Return (0x0)
    819                 }
    820             }
    821 
    822             Processor (CPUD, /* Name */
    823                        0x0d, /* Id */
    824                        0x0,  /* Processor IO ports range start */
    825                        0x0   /* Processor IO ports range length */
    826                        )
    827             {
    828                 Name (_HID, "ACPI0007")
    829                 Name (_UID, "SCKD-CPU0")
    830                 Name (_PXM, 0x00)
    831 
    832                 Method(_MAT, 0)
    833                 {
    834                     IF (CPCK(0x0d))
    835                     {
    836                         Name (APIC, Buffer (8) {0x00, 0x08, 0x0d, 0x0d, 0x01})
    837                         Return(APIC)
    838                     }
    839                     Else
    840                     {
    841                         Return (0x00)
    842                     }
    843                 }
    844 
    845                 Method(_STA) // Used for device presence detection
    846                 {
    847                     IF (CPCK(0x0d))
    848                     {
    849                         Return (0xF)
    850                     }
    851                     Else
    852                     {
    853                         Return (0x0)
    854                     }
    855                 }
    856 
    857                 Method(_EJ0, 1)
    858                 {
    859                     Store(0x0d, \_SB.CPUL) // Unlock the CPU
    860                     Return
    861                 }
    862             }
    863         }
    864 
    865         Device (SCKE)
    866         {
    867             Name (_HID, "ACPI0004")
    868             Name (_UID, "SCKCPUE")
    869 
    870             Method (_STA, 0, NotSerialized)
    871             {
    872                 IF (CPCK(0x0e))
    873                 {
    874                     Return (0xF)
    875                 }
    876                 Else
    877                 {
    878                     Return (0x0)
    879                 }
    880             }
    881 
    882             Processor (CPUE, /* Name */
    883                        0x0e, /* Id */
    884                        0x0,  /* Processor IO ports range start */
    885                        0x0   /* Processor IO ports range length */
    886                        )
    887             {
    888                 Name (_HID, "ACPI0007")
    889                 Name (_UID, "SCKE-CPU0")
    890                 Name (_PXM, 0x00)
    891 
    892                 Method(_MAT, 0)
    893                 {
    894                     IF (CPCK(0x0e))
    895                     {
    896                         Name (APIC, Buffer (8) {0x00, 0x08, 0x0e, 0x0e, 0x01})
    897                         Return(APIC)
    898                     }
    899                     Else
    900                     {
    901                         Return (0x00)
    902                     }
    903                 }
    904 
    905                 Method(_STA) // Used for device presence detection
    906                 {
    907                     IF (CPCK(0x0e))
    908                     {
    909                         Return (0xF)
    910                     }
    911                     Else
    912                     {
    913                         Return (0x0)
    914                     }
    915                 }
    916 
    917                 Method(_EJ0, 1)
    918                 {
    919                     Store(0x0e, \_SB.CPUL) // Unlock the CPU
    920                     Return
    921                 }
    922             }
    923         }
    924 
    925         Device (SCKF)
    926         {
    927             Name (_HID, "ACPI0004")
    928             Name (_UID, "SCKCPUF")
    929 
    930             Method (_STA, 0, NotSerialized)
    931             {
    932                 IF (CPCK(0x0f))
    933                 {
    934                     Return (0xF)
    935                 }
    936                 Else
    937                 {
    938                     Return (0x0)
    939                 }
    940             }
    941 
    942             Processor (CPUF, /* Name */
    943                        0x0f, /* Id */
    944                        0x0,  /* Processor IO ports range start */
    945                        0x0   /* Processor IO ports range length */
    946                        )
    947             {
    948                 Name (_HID, "ACPI0007")
    949                 Name (_UID, "SCKF-CPU0")
    950                 Name (_PXM, 0x00)
    951 
    952                 Method(_MAT, 0)
    953                 {
    954                     IF (CPCK(0x0f))
    955                     {
    956                         Name (APIC, Buffer (8) {0x00, 0x08, 0x0f, 0x0f, 0x01})
    957                         Return(APIC)
    958                     }
    959                     Else
    960                     {
    961                         Return (0x00)
    962                     }
    963                 }
    964 
    965                 Method(_STA) // Used for device presence detection
    966                 {
    967                     IF (CPCK(0x0f))
    968                     {
    969                         Return (0xF)
    970                     }
    971                     Else
    972                     {
    973                         Return (0x0)
    974                     }
    975                 }
    976 
    977                 Method(_EJ0, 1)
    978                 {
    979                     Store(0xf, \_SB.CPUL) // Unlock the CPU
    980                     Return
    981                 }
    982             }
    983         }
    984 
    985         Device (SCKG)
    986         {
    987             Name (_HID, "ACPI0004")
    988             Name (_UID, "SCKCPUG")
    989 
    990             Method (_STA, 0, NotSerialized)
    991             {
    992                 IF (CPCK(0x10))
    993                 {
    994                     Return (0xF)
    995                 }
    996                 Else
    997                 {
    998                     Return (0x0)
    999                 }
    1000             }
    1001 
    1002             Processor (CPUG, /* Name */
    1003                        0x10, /* Id */
    1004                        0x0,  /* Processor IO ports range start */
    1005                        0x0   /* Processor IO ports range length */
    1006                        )
    1007             {
    1008                 Name (_HID, "ACPI0007")
    1009                 Name (_UID, "SCKG-CPU0")
    1010                 Name (_PXM, 0x00)
    1011 
    1012                 Method(_MAT, 0)
    1013                 {
    1014                     IF (CPCK(0x10))
    1015                     {
    1016                         Name (APIC, Buffer (8) {0x00, 0x08, 0x10, 0x10, 0x01})
    1017                         Return(APIC)
    1018                     }
    1019                     Else
    1020                     {
    1021                         Return (0x00)
    1022                     }
    1023                 }
    1024 
    1025                 Method(_STA) // Used for device presence detection
    1026                 {
    1027                     IF (CPCK(0x10))
    1028                     {
    1029                         Return (0xF)
    1030                     }
    1031                     Else
    1032                     {
    1033                         Return (0x0)
    1034                     }
    1035                 }
    1036 
    1037                 Method(_EJ0, 1)
    1038                 {
    1039                     Store(0x10, \_SB.CPUL) // Unlock the CPU
    1040                     Return
    1041                 }
    1042             }
    1043         }
    1044 
    1045         Device (SCKH)
    1046         {
    1047             Name (_HID, "ACPI0004")
    1048             Name (_UID, "SCKCPUH")
    1049 
    1050             Method (_STA, 0, NotSerialized)
    1051             {
    1052                 IF (CPCK(0x11))
    1053                 {
    1054                     Return (0xF)
    1055                 }
    1056                 Else
    1057                 {
    1058                     Return (0x0)
    1059                 }
    1060             }
    1061 
    1062             Processor (CPUH, /* Name */
    1063                        0x11, /* Id */
    1064                        0x0,  /* Processor IO ports range start */
    1065                        0x0   /* Processor IO ports range length */
    1066                        )
    1067             {
    1068                 Name (_HID, "ACPI0007")
    1069                 Name (_UID, "SCKH-CPU0")
    1070                 Name (_PXM, 0x00)
    1071 
    1072                 Method(_MAT, 0)
    1073                 {
    1074                     IF (CPCK(0x11))
    1075                     {
    1076                         Name (APIC, Buffer (8) {0x00, 0x08, 0x11, 0x11, 0x01})
    1077                         Return(APIC)
    1078                     }
    1079                     Else
    1080                     {
    1081                         Return (0x00)
    1082                     }
    1083                 }
    1084 
    1085                 Method(_STA) // Used for device presence detection
    1086                 {
    1087                     IF (CPCK(0x11))
    1088                     {
    1089                         Return (0xF)
    1090                     }
    1091                     Else
    1092                     {
    1093                         Return (0x0)
    1094                     }
    1095                 }
    1096 
    1097                 Method(_EJ0, 1)
    1098                 {
    1099                     Store(0x11, \_SB.CPUL) // Unlock the CPU
    1100                     Return
    1101                 }
    1102             }
    1103         }
    1104 
    1105         Device (SCKI)
    1106         {
    1107             Name (_HID, "ACPI0004")
    1108             Name (_UID, "SCKCPUI")
    1109 
    1110             Method (_STA, 0, NotSerialized)
    1111             {
    1112                 IF (CPCK(0x12))
    1113                 {
    1114                     Return (0xF)
    1115                 }
    1116                 Else
    1117                 {
    1118                     Return (0x0)
    1119                 }
    1120             }
    1121 
    1122             Processor (CPUI, /* Name */
    1123                        0x12, /* Id */
    1124                        0x0,  /* Processor IO ports range start */
    1125                        0x0   /* Processor IO ports range length */
    1126                        )
    1127             {
    1128                 Name (_HID, "ACPI0007")
    1129                 Name (_UID, "SCKI-CPU0")
    1130                 Name (_PXM, 0x00)
    1131 
    1132                 Method(_MAT, 0)
    1133                 {
    1134                     IF (CPCK(0x12))
    1135                     {
    1136                         Name (APIC, Buffer (8) {0x00, 0x08, 0x12, 0x12, 0x01})
    1137                         Return(APIC)
    1138                     }
    1139                     Else
    1140                     {
    1141                         Return (0x00)
    1142                     }
    1143                 }
    1144 
    1145                 Method(_STA) // Used for device presence detection
    1146                 {
    1147                     IF (CPCK(0x12))
    1148                     {
    1149                         Return (0xF)
    1150                     }
    1151                     Else
    1152                     {
    1153                         Return (0x0)
    1154                     }
    1155                 }
    1156 
    1157                 Method(_EJ0, 1)
    1158                 {
    1159                     Store(0x12, \_SB.CPUL) // Unlock the CPU
    1160                     Return
    1161                 }
    1162             }
    1163         }
    1164 
    1165         Device (SCKJ)
    1166         {
    1167             Name (_HID, "ACPI0004")
    1168             Name (_UID, "SCKCPUJ")
    1169 
    1170             Method (_STA, 0, NotSerialized)
    1171             {
    1172                 IF (CPCK(0x13))
    1173                 {
    1174                     Return (0xF)
    1175                 }
    1176                 Else
    1177                 {
    1178                     Return (0x0)
    1179                 }
    1180             }
    1181 
    1182             Processor (CPUJ, /* Name */
    1183                        0x13, /* Id */
    1184                        0x0,  /* Processor IO ports range start */
    1185                        0x0   /* Processor IO ports range length */
    1186                        )
    1187             {
    1188                 Name (_HID, "ACPI0007")
    1189                 Name (_UID, "SCKJ-CPU0")
    1190                 Name (_PXM, 0x00)
    1191 
    1192                 Method(_MAT, 0)
    1193                 {
    1194                     IF (CPCK(0x13))
    1195                     {
    1196                         Name (APIC, Buffer (8) {0x00, 0x08, 0x13, 0x13, 0x01})
    1197                         Return(APIC)
    1198                     }
    1199                     Else
    1200                     {
    1201                         Return (0x00)
    1202                     }
    1203                 }
    1204 
    1205                 Method(_STA) // Used for device presence detection
    1206                 {
    1207                     IF (CPCK(0x13))
    1208                     {
    1209                         Return (0xF)
    1210                     }
    1211                     Else
    1212                     {
    1213                         Return (0x0)
    1214                     }
    1215                 }
    1216 
    1217                 Method(_EJ0, 1)
    1218                 {
    1219                     Store(0x13, \_SB.CPUL) // Unlock the CPU
    1220                     Return
    1221                 }
    1222             }
    1223         }
    1224 
    1225         Device (SCKK)
    1226         {
    1227             Name (_HID, "ACPI0004")
    1228             Name (_UID, "SCKCPUK")
    1229 
    1230             Method (_STA, 0, NotSerialized)
    1231             {
    1232                 IF (CPCK(0x14))
    1233                 {
    1234                     Return (0xF)
    1235                 }
    1236                 Else
    1237                 {
    1238                     Return (0x0)
    1239                 }
    1240             }
    1241 
    1242             Processor (CPUK, /* Name */
    1243                        0x14, /* Id */
    1244                        0x0,  /* Processor IO ports range start */
    1245                        0x0   /* Processor IO ports range length */
    1246                        )
    1247             {
    1248                 Name (_HID, "ACPI0007")
    1249                 Name (_UID, "SCKK-CPU0")
    1250                 Name (_PXM, 0x00)
    1251 
    1252                 Method(_MAT, 0)
    1253                 {
    1254                     IF (CPCK(0x14))
    1255                     {
    1256                         Name (APIC, Buffer (8) {0x00, 0x08, 0x14, 0x14, 0x01})
    1257                         Return(APIC)
    1258                     }
    1259                     Else
    1260                     {
    1261                         Return (0x00)
    1262                     }
    1263                 }
    1264 
    1265                 Method(_STA) // Used for device presence detection
    1266                 {
    1267                     IF (CPCK(0x14))
    1268                     {
    1269                         Return (0xF)
    1270                     }
    1271                     Else
    1272                     {
    1273                         Return (0x0)
    1274                     }
    1275                 }
    1276 
    1277                 Method(_EJ0, 1)
    1278                 {
    1279                     Store(0x14, \_SB.CPUL) // Unlock the CPU
    1280                     Return
    1281                 }
    1282             }
    1283         }
    1284 
    1285         Device (SCKL)
    1286         {
    1287             Name (_HID, "ACPI0004")
    1288             Name (_UID, "SCKCPUL")
    1289 
    1290             Method (_STA, 0, NotSerialized)
    1291             {
    1292                 IF (CPCK(0x15))
    1293                 {
    1294                     Return (0xF)
    1295                 }
    1296                 Else
    1297                 {
    1298                     Return (0x0)
    1299                 }
    1300             }
    1301 
    1302             Processor (CPUL, /* Name */
    1303                        0x15, /* Id */
    1304                        0x0,  /* Processor IO ports range start */
    1305                        0x0   /* Processor IO ports range length */
    1306                        )
    1307             {
    1308                 Name (_HID, "ACPI0007")
    1309                 Name (_UID, "SCKL-CPU0")
    1310                 Name (_PXM, 0x00)
    1311 
    1312                 Method(_MAT, 0)
    1313                 {
    1314                     IF (CPCK(0x15))
    1315                     {
    1316                         Name (APIC, Buffer (8) {0x00, 0x08, 0x15, 0x15, 0x01})
    1317                         Return(APIC)
    1318                     }
    1319                     Else
    1320                     {
    1321                         Return (0x00)
    1322                     }
    1323                 }
    1324 
    1325                 Method(_STA) // Used for device presence detection
    1326                 {
    1327                     IF (CPCK(0x15))
    1328                     {
    1329                         Return (0xF)
    1330                     }
    1331                     Else
    1332                     {
    1333                         Return (0x0)
    1334                     }
    1335                 }
    1336 
    1337                 Method(_EJ0, 1)
    1338                 {
    1339                     Store(0x15, \_SB.CPUL) // Unlock the CPU
    1340                     Return
    1341                 }
    1342             }
    1343         }
    1344 
    1345         Device (SCKM)
    1346         {
    1347             Name (_HID, "ACPI0004")
    1348             Name (_UID, "SCKCPUM")
    1349 
    1350             Method (_STA, 0, NotSerialized)
    1351             {
    1352                 IF (CPCK(0x16))
    1353                 {
    1354                     Return (0xF)
    1355                 }
    1356                 Else
    1357                 {
    1358                     Return (0x0)
    1359                 }
    1360             }
    1361 
    1362             Processor (CPUM, /* Name */
    1363                        0x16, /* Id */
    1364                        0x0,  /* Processor IO ports range start */
    1365                        0x0   /* Processor IO ports range length */
    1366                        )
    1367             {
    1368                 Name (_HID, "ACPI0007")
    1369                 Name (_UID, "SCKM-CPU0")
    1370                 Name (_PXM, 0x00)
    1371 
    1372                 Method(_MAT, 0)
    1373                 {
    1374                     IF (CPCK(0x16))
    1375                     {
    1376                         Name (APIC, Buffer (8) {0x00, 0x08, 0x16, 0x16, 0x01})
    1377                         Return(APIC)
    1378                     }
    1379                     Else
    1380                     {
    1381                         Return (0x00)
    1382                     }
    1383                 }
    1384 
    1385                 Method(_STA) // Used for device presence detection
    1386                 {
    1387                     IF (CPCK(0x16))
    1388                     {
    1389                         Return (0xF)
    1390                     }
    1391                     Else
    1392                     {
    1393                         Return (0x0)
    1394                     }
    1395                 }
    1396 
    1397                 Method(_EJ0, 1)
    1398                 {
    1399                     Store(0x16, \_SB.CPUL) // Unlock the CPU
    1400                     Return
    1401                 }
    1402             }
    1403         }
    1404 
    1405         Device (SCKN)
    1406         {
    1407             Name (_HID, "ACPI0004")
    1408             Name (_UID, "SCKCPUN")
    1409 
    1410             Method (_STA, 0, NotSerialized)
    1411             {
    1412                 IF (CPCK(0x17))
    1413                 {
    1414                     Return (0xF)
    1415                 }
    1416                 Else
    1417                 {
    1418                     Return (0x0)
    1419                 }
    1420             }
    1421 
    1422             Processor (CPUN, /* Name */
    1423                        0x17, /* Id */
    1424                        0x0,  /* Processor IO ports range start */
    1425                        0x0   /* Processor IO ports range length */
    1426                        )
    1427             {
    1428                 Name (_HID, "ACPI0007")
    1429                 Name (_UID, "SCKN-CPU0")
    1430                 Name (_PXM, 0x00)
    1431 
    1432                 Method(_MAT, 0)
    1433                 {
    1434                     IF (CPCK(0x17))
    1435                     {
    1436                         Name (APIC, Buffer (8) {0x00, 0x08, 0x17, 0x17, 0x01})
    1437                         Return(APIC)
    1438                     }
    1439                     Else
    1440                     {
    1441                         Return (0x00)
    1442                     }
    1443                 }
    1444 
    1445                 Method(_STA) // Used for device presence detection
    1446                 {
    1447                     IF (CPCK(0x17))
    1448                     {
    1449                         Return (0xF)
    1450                     }
    1451                     Else
    1452                     {
    1453                         Return (0x0)
    1454                     }
    1455                 }
    1456 
    1457                 Method(_EJ0, 1)
    1458                 {
    1459                     Store(0x17, \_SB.CPUL) // Unlock the CPU
    1460                     Return
    1461                 }
    1462             }
    1463         }
    1464 
    1465         Device (SCKO)
    1466         {
    1467             Name (_HID, "ACPI0004")
    1468             Name (_UID, "SCKCPUO")
    1469 
    1470             Method (_STA, 0, NotSerialized)
    1471             {
    1472                 IF (CPCK(0x18))
    1473                 {
    1474                     Return (0xF)
    1475                 }
    1476                 Else
    1477                 {
    1478                     Return (0x0)
    1479                 }
    1480             }
    1481 
    1482             Processor (CPUO, /* Name */
    1483                        0x18, /* Id */
    1484                        0x0,  /* Processor IO ports range start */
    1485                        0x0   /* Processor IO ports range length */
    1486                        )
    1487             {
    1488                 Name (_HID, "ACPI0007")
    1489                 Name (_UID, "SCKO-CPU0")
    1490                 Name (_PXM, 0x00)
    1491 
    1492                 Method(_MAT, 0)
    1493                 {
    1494                     IF (CPCK(0x18))
    1495                     {
    1496                         Name (APIC, Buffer (8) {0x00, 0x08, 0x18, 0x18, 0x01})
    1497                         Return(APIC)
    1498                     }
    1499                     Else
    1500                     {
    1501                         Return (0x00)
    1502                     }
    1503                 }
    1504 
    1505                 Method(_STA) // Used for device presence detection
    1506                 {
    1507                     IF (CPCK(0x18))
    1508                     {
    1509                         Return (0xF)
    1510                     }
    1511                     Else
    1512                     {
    1513                         Return (0x0)
    1514                     }
    1515                 }
    1516 
    1517                 Method(_EJ0, 1)
    1518                 {
    1519                     Store(0x18, \_SB.CPUL) // Unlock the CPU
    1520                     Return
    1521                 }
    1522             }
    1523         }
    1524 
    1525         Device (SCKP)
    1526         {
    1527             Name (_HID, "ACPI0004")
    1528             Name (_UID, "SCKCPUP")
    1529 
    1530             Method (_STA, 0, NotSerialized)
    1531             {
    1532                 IF (CPCK(0x19))
    1533                 {
    1534                     Return (0xF)
    1535                 }
    1536                 Else
    1537                 {
    1538                     Return (0x0)
    1539                 }
    1540             }
    1541 
    1542             Processor (CPUP, /* Name */
    1543                        0x19, /* Id */
    1544                        0x0,  /* Processor IO ports range start */
    1545                        0x0   /* Processor IO ports range length */
    1546                        )
    1547             {
    1548                 Name (_HID, "ACPI0007")
    1549                 Name (_UID, "SCKP-CPU0")
    1550                 Name (_PXM, 0x00)
    1551 
    1552                 Method(_MAT, 0)
    1553                 {
    1554                     IF (CPCK(0x19))
    1555                     {
    1556                         Name (APIC, Buffer (8) {0x00, 0x08, 0x19, 0x19, 0x01})
    1557                         Return(APIC)
    1558                     }
    1559                     Else
    1560                     {
    1561                         Return (0x00)
    1562                     }
    1563                 }
    1564 
    1565                 Method(_STA) // Used for device presence detection
    1566                 {
    1567                     IF (CPCK(0x19))
    1568                     {
    1569                         Return (0xF)
    1570                     }
    1571                     Else
    1572                     {
    1573                         Return (0x0)
    1574                     }
    1575                 }
    1576 
    1577                 Method(_EJ0, 1)
    1578                 {
    1579                     Store(0x19, \_SB.CPUL) // Unlock the CPU
    1580                     Return
    1581                 }
    1582             }
    1583         }
    1584 
    1585         Device (SCKQ)
    1586         {
    1587             Name (_HID, "ACPI0004")
    1588             Name (_UID, "SCKCPUQ")
    1589 
    1590             Method (_STA, 0, NotSerialized)
    1591             {
    1592                 IF (CPCK(0x1a))
    1593                 {
    1594                     Return (0xF)
    1595                 }
    1596                 Else
    1597                 {
    1598                     Return (0x0)
    1599                 }
    1600             }
    1601 
    1602             Processor (CPUQ, /* Name */
    1603                        0x1a, /* Id */
    1604                        0x0,  /* Processor IO ports range start */
    1605                        0x0   /* Processor IO ports range length */
    1606                        )
    1607             {
    1608                 Name (_HID, "ACPI0007")
    1609                 Name (_UID, "SCKQ-CPU0")
    1610                 Name (_PXM, 0x00)
    1611 
    1612                 Method(_MAT, 0)
    1613                 {
    1614                     IF (CPCK(0x1a))
    1615                     {
    1616                         Name (APIC, Buffer (8) {0x00, 0x08, 0x1a, 0x1a, 0x01})
    1617                         Return(APIC)
    1618                     }
    1619                     Else
    1620                     {
    1621                         Return (0x00)
    1622                     }
    1623                 }
    1624 
    1625                 Method(_STA) // Used for device presence detection
    1626                 {
    1627                     IF (CPCK(0x1a))
    1628                     {
    1629                         Return (0xF)
    1630                     }
    1631                     Else
    1632                     {
    1633                         Return (0x0)
    1634                     }
    1635                 }
    1636 
    1637                 Method(_EJ0, 1)
    1638                 {
    1639                     Store(0x1a, \_SB.CPUL) // Unlock the CPU
    1640                     Return
    1641                 }
    1642             }
    1643         }
    1644 
    1645         Device (SCKR)
    1646         {
    1647             Name (_HID, "ACPI0004")
    1648             Name (_UID, "SCKCPUR")
    1649 
    1650             Method (_STA, 0, NotSerialized)
    1651             {
    1652                 IF (CPCK(0x1b))
    1653                 {
    1654                     Return (0xF)
    1655                 }
    1656                 Else
    1657                 {
    1658                     Return (0x0)
    1659                 }
    1660             }
    1661 
    1662             Processor (CPUR, /* Name */
    1663                        0x1b, /* Id */
    1664                        0x0,  /* Processor IO ports range start */
    1665                        0x0   /* Processor IO ports range length */
    1666                        )
    1667             {
    1668                 Name (_HID, "ACPI0007")
    1669                 Name (_UID, "SCKR-CPU0")
    1670                 Name (_PXM, 0x00)
    1671 
    1672                 Method(_MAT, 0)
    1673                 {
    1674                     IF (CPCK(0x1b))
    1675                     {
    1676                         Name (APIC, Buffer (8) {0x00, 0x08, 0x1b, 0x1b, 0x01})
    1677                         Return(APIC)
    1678                     }
    1679                     Else
    1680                     {
    1681                         Return (0x00)
    1682                     }
    1683                 }
    1684 
    1685                 Method(_STA) // Used for device presence detection
    1686                 {
    1687                     IF (CPCK(0x1b))
    1688                     {
    1689                         Return (0xF)
    1690                     }
    1691                     Else
    1692                     {
    1693                         Return (0x0)
    1694                     }
    1695                 }
    1696 
    1697                 Method(_EJ0, 1)
    1698                 {
    1699                     Store(0x1b, \_SB.CPUL) // Unlock the CPU
    1700                     Return
    1701                 }
    1702             }
    1703         }
    1704 
    1705         Device (SCKS)
    1706         {
    1707             Name (_HID, "ACPI0004")
    1708             Name (_UID, "SCKCPUS")
    1709 
    1710             Method (_STA, 0, NotSerialized)
    1711             {
    1712                 IF (CPCK(0x1c))
    1713                 {
    1714                     Return (0xF)
    1715                 }
    1716                 Else
    1717                 {
    1718                     Return (0x0)
    1719                 }
    1720             }
    1721 
    1722             Processor (CPUS, /* Name */
    1723                        0x1c, /* Id */
    1724                        0x0,  /* Processor IO ports range start */
    1725                        0x0   /* Processor IO ports range length */
    1726                        )
    1727             {
    1728                 Name (_HID, "ACPI0007")
    1729                 Name (_UID, "SCKS-CPU0")
    1730                 Name (_PXM, 0x00)
    1731 
    1732                 Method(_MAT, 0)
    1733                 {
    1734                     IF (CPCK(0x1c))
    1735                     {
    1736                         Name (APIC, Buffer (8) {0x00, 0x08, 0x1c, 0x1c, 0x01})
    1737                         Return(APIC)
    1738                     }
    1739                     Else
    1740                     {
    1741                         Return (0x00)
    1742                     }
    1743                 }
    1744 
    1745                 Method(_STA) // Used for device presence detection
    1746                 {
    1747                     IF (CPCK(0x1c))
    1748                     {
    1749                         Return (0xF)
    1750                     }
    1751                     Else
    1752                     {
    1753                         Return (0x0)
    1754                     }
    1755                 }
    1756 
    1757                 Method(_EJ0, 1)
    1758                 {
    1759                     Store(0x1c, \_SB.CPUL) // Unlock the CPU
    1760                     Return
    1761                 }
    1762             }
    1763         }
    1764 
    1765         Device (SCKT)
    1766         {
    1767             Name (_HID, "ACPI0004")
    1768             Name (_UID, "SCKCPUT")
    1769 
    1770             Method (_STA, 0, NotSerialized)
    1771             {
    1772                 IF (CPCK(0x1d))
    1773                 {
    1774                     Return (0xF)
    1775                 }
    1776                 Else
    1777                 {
    1778                     Return (0x0)
    1779                 }
    1780             }
    1781 
    1782             Processor (CPUT, /* Name */
    1783                        0x1d, /* Id */
    1784                        0x0,  /* Processor IO ports range start */
    1785                        0x0   /* Processor IO ports range length */
    1786                        )
    1787             {
    1788                 Name (_HID, "ACPI0007")
    1789                 Name (_UID, "SCKT-CPU0")
    1790                 Name (_PXM, 0x00)
    1791 
    1792                 Method(_MAT, 0)
    1793                 {
    1794                     IF (CPCK(0x1d))
    1795                     {
    1796                         Name (APIC, Buffer (8) {0x00, 0x08, 0x1d, 0x1d, 0x01})
    1797                         Return(APIC)
    1798                     }
    1799                     Else
    1800                     {
    1801                         Return (0x00)
    1802                     }
    1803                 }
    1804 
    1805                 Method(_STA) // Used for device presence detection
    1806                 {
    1807                     IF (CPCK(0x1d))
    1808                     {
    1809                         Return (0xF)
    1810                     }
    1811                     Else
    1812                     {
    1813                         Return (0x0)
    1814                     }
    1815                 }
    1816 
    1817                 Method(_EJ0, 1)
    1818                 {
    1819                     Store(0x1d, \_SB.CPUL) // Unlock the CPU
    1820                     Return
    1821                 }
    1822             }
    1823         }
    1824 
    1825         Device (SCKU)
    1826         {
    1827             Name (_HID, "ACPI0004")
    1828             Name (_UID, "SCKCPUU")
    1829 
    1830             Method (_STA, 0, NotSerialized)
    1831             {
    1832                 IF (CPCK(0x1e))
    1833                 {
    1834                     Return (0xF)
    1835                 }
    1836                 Else
    1837                 {
    1838                     Return (0x0)
    1839                 }
    1840             }
    1841 
    1842             Processor (CPUU, /* Name */
    1843                        0x1e, /* Id */
    1844                        0x0,  /* Processor IO ports range start */
    1845                        0x0   /* Processor IO ports range length */
    1846                        )
    1847             {
    1848                 Name (_HID, "ACPI0007")
    1849                 Name (_UID, "SCKU-CPU0")
    1850                 Name (_PXM, 0x00)
    1851 
    1852                 Method(_MAT, 0)
    1853                 {
    1854                     IF (CPCK(0x1e))
    1855                     {
    1856                         Name (APIC, Buffer (8) {0x00, 0x08, 0x1e, 0x1e, 0x01})
    1857                         Return(APIC)
    1858                     }
    1859                     Else
    1860                     {
    1861                         Return (0x00)
    1862                     }
    1863                 }
    1864 
    1865                 Method(_STA) // Used for device presence detection
    1866                 {
    1867                     IF (CPCK(0x1e))
    1868                     {
    1869                         Return (0xF)
    1870                     }
    1871                     Else
    1872                     {
    1873                         Return (0x0)
    1874                     }
    1875                 }
    1876 
    1877                 Method(_EJ0, 1)
    1878                 {
    1879                     Store(0x1e, \_SB.CPUL) // Unlock the CPU
    1880                     Return
    1881                 }
    1882             }
    1883         }
    1884 
    1885         Device (SCKV)
    1886         {
    1887             Name (_HID, "ACPI0004")
    1888             Name (_UID, "SCKCPUV")
    1889 
    1890             Method (_STA, 0, NotSerialized)
    1891             {
    1892                 IF (CPCK(0x1f))
    1893                 {
    1894                     Return (0xF)
    1895                 }
    1896                 Else
    1897                 {
    1898                     Return (0x0)
    1899                 }
    1900             }
    1901 
    1902             Processor (CPUV, /* Name */
    1903                        0x1f, /* Id */
    1904                        0x0,  /* Processor IO ports range start */
    1905                        0x0   /* Processor IO ports range length */
    1906                        )
    1907             {
    1908                 Name (_HID, "ACPI0007")
    1909                 Name (_UID, "SCKV-CPU0")
    1910                 Name (_PXM, 0x00)
    1911 
    1912                 Method(_MAT, 0)
    1913                 {
    1914                     IF (CPCK(0x1f))
    1915                     {
    1916                         Name (APIC, Buffer (8) {0x00, 0x08, 0x1f, 0x1f, 0x01})
    1917                         Return(APIC)
    1918                     }
    1919                     Else
    1920                     {
    1921                         Return (0x00)
    1922                     }
    1923                 }
    1924 
    1925                 Method(_STA) // Used for device presence detection
    1926                 {
    1927                     IF (CPCK(0x1f))
    1928                     {
    1929                         Return (0xF)
    1930                     }
    1931                     Else
    1932                     {
    1933                         Return (0x0)
    1934                     }
    1935                 }
    1936 
    1937                 Method(_EJ0, 1)
    1938                 {
    1939                     Store(0x1f, \_SB.CPUL) // Unlock the CPU
    1940                     Return
    1941                 }
    1942             }
    1943         }
     127#undef GENERATE_CPU_OBJECT
    1944128    }
    1945129
    1946130    Scope (\_GPE)
    1947131    {
     132
     133#define CHECK_CPU(cpu, sck)    \
     134    IF (CPCK(cpu))             \
     135    {                          \
     136        Notify (\_SB.sck, 0x1) \
     137    }                          \
     138
    1948139        // GPE bit 1 handler
    1949140        // GPE.1 must be set and SCI raised when
    1950         // processor info changed and CPU1 must be
     141        // processor info changed and CPU must be
    1951142        // re-evaluated
    1952143        Method (_L01, 0, NotSerialized)
    1953144        {
    1954             // Eject notifications from ACPI are not supported so far by any guest
    1955             //IF (And(\_SB.CPUD, 0x2))
    1956             //{
    1957             //    Notify(\_PR.SCK1, 0x3)
    1958             //}
     145            /*Store(\_SB.CPET, Local0)*/
     146            /*Store(\_SB.CPEV, Local1)*/
    1959147
    1960             IF (CPCK(0x01))
    1961             {
    1962                 Notify (\_SB.SCK1, 0x1)
    1963             }
    1964             IF (CPCK(0x02))
    1965             {
    1966                 Notify (\_SB.SCK2, 0x1)
    1967             }
    1968             IF (CPCK(0x03))
    1969             {
    1970                 Notify (\_SB.SCK3, 0x1)
    1971             }
    1972             IF (CPCK(0x04))
    1973             {
    1974                 Notify (\_SB.SCK4, 0x1)
    1975             }
    1976             IF (CPCK(0x05))
    1977             {
    1978                 Notify (\_SB.SCK5, 0x1)
    1979             }
    1980             IF (CPCK(0x06))
    1981             {
    1982                 Notify (\_SB.SCK6, 0x1)
    1983             }
    1984             IF (CPCK(0x07))
    1985             {
    1986                 Notify (\_SB.SCK7, 0x1)
    1987             }
    1988             IF (CPCK(0x08))
    1989             {
    1990                 Notify (\_SB.SCK8, 0x1)
    1991             }
    1992             IF (CPCK(0x09))
    1993             {
    1994                 Notify (\_SB.SCK9, 0x1)
    1995             }
    1996             IF (CPCK(0x0a))
    1997             {
    1998                 Notify (\_SB.SCKA, 0x1)
    1999             }
    2000             IF (CPCK(0x0b))
    2001             {
    2002                 Notify (\_SB.SCKB, 0x1)
    2003             }
    2004             IF (CPCK(0x0c))
    2005             {
    2006                 Notify (\_SB.SCKC, 0x1)
    2007             }
    2008             IF (CPCK(0x0d))
    2009             {
    2010                 Notify (\_SB.SCKD, 0x1)
    2011             }
    2012             IF (CPCK(0x0e))
    2013             {
    2014                 Notify (\_SB.SCKE, 0x1)
    2015             }
    2016             IF (CPCK(0x0f))
    2017             {
    2018                 Notify (\_SB.SCKF, 0x1)
    2019             }
    2020             IF (CPCK(0x10))
    2021             {
    2022                 Notify (\_SB.SCKG, 0x1)
    2023             }
    2024             IF (CPCK(0x11))
    2025             {
    2026                 Notify (\_SB.SCKH, 0x1)
    2027             }
    2028             IF (CPCK(0x12))
    2029             {
    2030                 Notify (\_SB.SCKI, 0x1)
    2031             }
    2032             IF (CPCK(0x13))
    2033             {
    2034                 Notify (\_SB.SCKJ, 0x1)
    2035             }
    2036             IF (CPCK(0x14))
    2037             {
    2038                 Notify (\_SB.SCKK, 0x1)
    2039             }
    2040             IF (CPCK(0x15))
    2041             {
    2042                 Notify (\_SB.SCKL, 0x1)
    2043             }
    2044             IF (CPCK(0x16))
    2045             {
    2046                 Notify (\_SB.SCKM, 0x1)
    2047             }
    2048             IF (CPCK(0x17))
    2049             {
    2050                 Notify (\_SB.SCKN, 0x1)
    2051             }
    2052             IF (CPCK(0x18))
    2053             {
    2054                 Notify (\_SB.SCKO, 0x1)
    2055             }
    2056             IF (CPCK(0x19))
    2057             {
    2058                 Notify (\_SB.SCKP, 0x1)
    2059             }
    2060             IF (CPCK(0x1a))
    2061             {
    2062                 Notify (\_SB.SCKQ, 0x1)
    2063             }
    2064             IF (CPCK(0x1b))
    2065             {
    2066                 Notify (\_SB.SCKR, 0x1)
    2067             }
    2068             IF (CPCK(0x1c))
    2069             {
    2070                 Notify (\_SB.SCKS, 0x1)
    2071             }
    2072             IF (CPCK(0x1d))
    2073             {
    2074                 Notify (\_SB.SCKT, 0x1)
    2075             }
    2076             IF (CPCK(0x1e))
    2077             {
    2078                 Notify (\_SB.SCKU, 0x1)
    2079             }
    2080             IF (CPCK(0x1f))
    2081             {
    2082                 Notify (\_SB.SCKV, 0x1)
    2083             }
     148            CHECK_CPU(0x01, SCK1)
     149            CHECK_CPU(0x02, SCK2)
     150            CHECK_CPU(0x03, SCK3)
     151            CHECK_CPU(0x04, SCK4)
     152            CHECK_CPU(0x05, SCK5)
     153            CHECK_CPU(0x06, SCK6)
     154            CHECK_CPU(0x07, SCK7)
     155            CHECK_CPU(0x08, SCK8)
     156            CHECK_CPU(0x09, SCK9)
     157            CHECK_CPU(0x0a, SCKA)
     158            CHECK_CPU(0x0b, SCKB)
     159            CHECK_CPU(0x0c, SCKC)
     160            CHECK_CPU(0x0d, SCKD)
     161            CHECK_CPU(0x0e, SCKE)
     162            CHECK_CPU(0x0f, SCKF)
     163            CHECK_CPU(0x10, SCKG)
     164            CHECK_CPU(0x11, SCKH)
     165            CHECK_CPU(0x12, SCKI)
     166            CHECK_CPU(0x13, SCKJ)
     167            CHECK_CPU(0x14, SCKK)
     168            CHECK_CPU(0x15, SCKL)
     169            CHECK_CPU(0x16, SCKM)
     170            CHECK_CPU(0x17, SCKN)
     171            CHECK_CPU(0x18, SCKO)
     172            CHECK_CPU(0x19, SCKP)
     173            CHECK_CPU(0x1a, SCKQ)
     174            CHECK_CPU(0x1b, SCKR)
     175            CHECK_CPU(0x1c, SCKS)
     176            CHECK_CPU(0x1d, SCKT)
     177            CHECK_CPU(0x1e, SCKU)
     178            CHECK_CPU(0x1f, SCKV)
    2084179        }
     180
     181#undef CHECK_CPU
    2085182    }
    2086183
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette