QuarkPlatformPkg/Acpi/AcpiTables/Cpu0Cst/Cpu0Cst.asl

   1 /** @file
   2 CPU C State control methods
   3
   4 Copyright (c) 2013-2015 Intel Corporation.
   5
   6 This program and the accompanying materials
   7 are licensed and made available under the terms and conditions of the BSD License
   8 which accompanies this distribution.  The full text of the license may be found at
   9 http://opensource.org/licenses/bsd-license.php
  10
  11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13
  14 **/
  15
  16 DefinitionBlock (
  17     "Cpu0Cst.aml",
  18     "SSDT",
  19     0x01,
  20     "SsgPmm",
  21     "Cpu0Cst",
  22     0x0011
  23     )
  24 {
  25     External(\_PR.CPU0, DeviceObj)
  26     External (PDC0, IntObj)
  27     External (CFGD, FieldUnitObj)
  28
  29     Scope(\_PR.CPU0)
  30     {
  31         Method (_CST, 0)
  32         {
  33             // If CMP is supported, and OSPM is not capable of independent C1, P, T state
  34             // support for each processor for multi-processor configuration, we will just report
  35             // C1 halt
  36             //
  37             // PDCx[4] = Indicates whether OSPM is not capable of independent C1, P, T state
  38             // support for each processor for multi-processor configuration.
  39             //
  40             If(LAnd(And(CFGD,0x01000000), LNot(And(PDC0,0x10))))
  41             {
  42               Return(Package() {
  43                 1,
  44                 Package()
  45                 { // C1 halt
  46                   ResourceTemplate(){Register(FFixedHW, 0, 0, 0)},
  47                   1,
  48                   157,
  49                   1000
  50                 }
  51               })
  52             }
  53
  54             //
  55             // If MWAIT extensions is supported and OSPM is capable of performing
  56             // native C state instructions for the C2/C3 in multi-processor configuration,
  57             // we report every c state with MWAIT extensions.
  58             //
  59             // PDCx[9] = Indicates whether OSPM is capable of performing native C state instructions
  60             // for the C2/C3 in multi-processor configuration
  61             //
  62             If(LAnd(And(CFGD, 0x200000), And(PDC0,0x200)))
  63             {
  64               //
  65               // If C6 is supported, we report MWAIT C1,C2,C4,C6
  66               //
  67               If(And(CFGD,0x200))
  68               {
  69                 Return( Package()
  70                 {
  71                   4,
  72                   Package()
  73                   { // MWAIT C1, hardware coordinated with no bus master avoidance
  74                     ResourceTemplate(){Register(FFixedHW, 1, 2, 0x00, 1)},
  75                     1,
  76                     1,
  77                     1000
  78                   },
  79                   Package()
  80                   { // MWAIT C2, hardware coordinated with no bus master avoidance
  81                     ResourceTemplate(){Register(FFixedHW, 1, 2, 0x10, 1)},
  82                     2,
  83                     20,
  84                     500
  85                   },
  86                   Package()
  87                   { // MWAIT C4, hardware coordinated with bus master avoidance enabled
  88                     ResourceTemplate(){Register(FFixedHW, 1, 2, 0x30, 3)},
  89                     3,
  90                     100,
  91                     100
  92                   },
  93                   Package()
  94                   { // MWAIT C6, hardware coordinated with bus master avoidance enabled
  95                     ResourceTemplate(){Register(FFixedHW, 1, 2, 0x50, 3)},
  96                     3,
  97                     140,
  98                     10
  99                   }
 100                 })
 101               }
 102               //
 103               // If C4 is supported, we report MWAIT C1,C2,C4
 104               //
 105               If(And(CFGD,0x080))
 106               {
 107                 Return( Package()
 108                 {
 109                   3,
 110                   Package()
 111                   { // MWAIT C1, hardware coordinated with no bus master avoidance
 112                     ResourceTemplate(){Register(FFixedHW, 1, 2, 0x00, 1)},
 113                     1,
 114                     1,
 115                     1000
 116                   },
 117                   Package()
 118                   { // MWAIT C2, hardware coordinated with no bus master avoidance
 119                     ResourceTemplate(){Register(FFixedHW, 1, 2, 0x10, 1)},
 120                     2,
 121                     20,
 122                     500
 123                   },
 124                   Package()
 125                   { // MWAIT C4, hardware coordinated with bus master avoidance enabled
 126                     ResourceTemplate(){Register(FFixedHW, 1, 2, 0x30, 3)},
 127                     3,
 128                     100,
 129                     100
 130                   }
 131                 })
 132               }
 133               //
 134               // If C2 is supported, we report MWAIT C1,C2
 135               //
 136               If(And(CFGD,0x020))
 137               {
 138                 Return( Package()
 139                 {
 140                   2,
 141                   Package()
 142                   { // MWAIT C1, hardware coordinated with no bus master avoidance
 143                     ResourceTemplate(){Register(FFixedHW, 1, 2, 0x00, 1)},
 144                     1,
 145                     1,
 146                     1000
 147                   },
 148                   Package()
 149                   { // MWAIT C2, hardware coordinated with no bus master avoidance
 150                     ResourceTemplate(){Register(FFixedHW, 1, 2, 0x10, 1)},
 151                     2,
 152                     20,
 153                     500
 154                   }
 155                 })
 156               }
 157               //
 158               // Else we only report MWAIT C1.
 159               //
 160               Return(Package()
 161               {
 162                 1,
 163                 Package()
 164                 { // MWAIT C1, hardware coordinated with no bus master avoidance
 165                   ResourceTemplate () {Register(FFixedHW, 1, 2, 0x00, 1)},
 166                   1,
 167                   1,
 168                   1000
 169                 }
 170               })
 171             }
 172
 173             // If OSPM is only capable of performing native C state instructions for
 174             // the C1 in multi-processor configuration, we report C1 with MWAIT, other
 175             // C states with IO method.
 176             //
 177             // PDCx[8] = Indicates whether OSPM is capable of performing native C state instructions
 178             // for the C1 in multi-processor configuration
 179             //
 180             If(LAnd(And(CFGD, 0x200000), And(PDC0,0x100)))
 181             {
 182               //
 183               // If C6 is supported, we report MWAIT C1, IO C2,C4,C6
 184               //
 185               If(And(CFGD,0x200))
 186               {
 187                 Return( Package()
 188                 {
 189                   4,
 190                   Package()
 191                   { // MWAIT C1, hardware coordinated with no bus master avoidance
 192                     ResourceTemplate () {Register(FFixedHW, 1, 2, 0x00, 1)},
 193                     1,
 194                     1,
 195                     1000
 196                   },
 197                   Package()
 198                   { // IO C2 ("PMBALVL2" will be updated at runtime)
 199                     ResourceTemplate () {Register(SystemIO, 8, 0, 0x324C564C41424D50)},
 200                     2,
 201                     20,
 202                     500
 203                     },
 204                   Package()
 205                   { // IO C4 ("PMBALVL4" will be updated at runtime)
 206                     ResourceTemplate () {Register(SystemIO, 8, 0, 0x344C564C41424D50)},
 207                     3,
 208                     100,
 209                     100
 210                   },
 211                   Package()
 212                   { // IO C6 ("PMBALVL6" will be updated at runtime)
 213                     ResourceTemplate () {Register(SystemIO, 8, 0, 0x364C564C41424D50)},
 214                     3,
 215                     140,
 216                     10
 217                   }
 218                 })
 219               }
 220               //
 221               // If C4 is supported, we report MWAIT C1, IO C2,C4
 222               //
 223               If(And(CFGD,0x080))
 224               {
 225                 Return( Package()
 226                 {
 227                   3,
 228                   Package()
 229                   { // MWAIT C1, hardware coordinated with no bus master avoidance
 230                     ResourceTemplate () {Register(FFixedHW, 1, 2, 0x00, 1)},
 231                     1,
 232                     1,
 233                     1000
 234                   },
 235                   Package()
 236                   { // IO C2 ("PMBALVL2" will be updated at runtime)
 237                     ResourceTemplate () {Register(SystemIO, 8, 0, 0x324C564C41424D50)},
 238                     2,
 239                     20,
 240                     500
 241                     },
 242                   Package()
 243                   { // IO C4 ("PMBALVL4" will be updated at runtime)
 244                     ResourceTemplate () {Register(SystemIO, 8, 0, 0x344C564C41424D50)},
 245                     3,
 246                     100,
 247                     100
 248                   }
 249                 })
 250               }
 251               //
 252               // If C2 is supported, we report MWAIT C1, IO C2
 253               //
 254               If(And(CFGD,0x020))
 255               {
 256                 Return( Package()
 257                 {
 258                   2,
 259                   Package()
 260                   { // MWAIT C1, hardware coordinated with no bus master avoidance
 261                     ResourceTemplate () {Register(FFixedHW, 1, 2, 0x00, 1)},
 262                     1,
 263                     1,
 264                     1000
 265                   },
 266                   Package()
 267                   { // IO C2 ("PMBALVL2" will be updated at runtime)
 268                     ResourceTemplate () {Register(SystemIO, 8, 0, 0x324C564C41424D50)},
 269                     2,
 270                     20,
 271                     500
 272                   }
 273                 })
 274               }
 275               //
 276               // Else we only report MWAIT C1.
 277               //
 278               Return(Package()
 279               {
 280                 1,
 281                 Package()
 282                 { // MWAIT C1, hardware coordinated with no bus master avoidance
 283                   ResourceTemplate () {Register(FFixedHW, 1, 2, 0x00, 1)},
 284                   1,
 285                   1,
 286                   1000
 287                 }
 288               })
 289             }
 290
 291             //
 292             // If MWAIT is not supported, we report all the c states with IO method
 293             //
 294
 295             //
 296             // If C6 is supported, we report C1 halt, IO C2,C4,C6
 297             //
 298             If(And(CFGD,0x200))
 299             {
 300               Return(Package()
 301               {
 302                 4,
 303                 Package()
 304                 { // C1 Halt
 305                   ResourceTemplate () {Register(FFixedHW, 0, 0, 0)},
 306                   1,
 307                   1,
 308                   1000
 309                 },
 310                 Package()
 311                 { // IO C2 ("PMBALVL2" will be updated at runtime)
 312                   ResourceTemplate () {Register(SystemIO, 8, 0, 0x324C564C41424D50)},
 313                   2,
 314                   20,
 315                   500
 316                 },
 317                 Package()
 318                 { // IO C4 ("PMBALVL4" will be updated at runtime)
 319                   ResourceTemplate () {Register(SystemIO, 8, 0, 0x344C564C41424D50)},
 320                   3,
 321                   100,
 322                   100
 323                 },
 324                 Package()
 325                 { // IO C6 ("PMBALVL6" will be updated at runtime)
 326                   ResourceTemplate () {Register(SystemIO, 8, 0, 0x364C564C41424D50)},
 327                   3,
 328                   140,
 329                   10
 330                 }
 331               })
 332             }
 333             //
 334             // If C4 is supported, we report C1 halt, IO C2,C4
 335             //
 336             If(And(CFGD,0x080))
 337             {
 338               Return(Package()
 339               {
 340                 3,
 341                 Package()
 342                 { // C1 halt
 343                   ResourceTemplate () {Register(FFixedHW, 0, 0, 0)},
 344                   1,
 345                   1,
 346                   1000
 347                 },
 348                 Package()
 349                 { // IO C2 ("PMBALVL2" will be updated at runtime)
 350                   ResourceTemplate () {Register(SystemIO, 8, 0, 0x324C564C41424D50)},
 351                   2,
 352                   20,
 353                   500
 354                 },
 355                 Package()
 356                 { // IO C4 ("PMBALVL4" will be updated at runtime)
 357                   ResourceTemplate () {Register(SystemIO, 8, 0, 0x344C564C41424D50)},
 358                   3,
 359                   100,
 360                   100
 361                 }
 362               })
 363             }
 364
 365             //
 366             // If C2 is supported, we report C1 halt, IO C2
 367             //
 368             If(And(CFGD,0x020))
 369             {
 370               Return(Package()
 371               {
 372                 2,
 373                 Package()
 374                 { // C1 halt
 375                   ResourceTemplate () {Register(FFixedHW, 0, 0, 0)},
 376                   1,
 377                   1,
 378                   1000
 379                 },
 380                 Package()
 381                 { // IO C2 ("PMBALVL2" will be updated at runtime)
 382                   ResourceTemplate () {Register(SystemIO, 8, 0, 0x324C564C41424D50)},
 383                   2,
 384                   20,
 385                   500
 386                 }
 387               })
 388             }
 389             //
 390             // Else we only report C1 halt.
 391             //
 392             Return(Package()
 393             {
 394               1,
 395               Package()
 396               { // C1 halt
 397                 ResourceTemplate () {Register(FFixedHW, 0, 0, 0)},
 398                 1,
 399                 1,
 400                 1000
 401               }
 402             })
 403         }
 404     }
 405 }