src/ec/google/chromeec/acpi/ec.asl

   1 /* SPDX-License-Identifier: GPL-2.0-only */
   2
   3 /*
   4  * The mainboard must define a PNOT method to handle power
   5  * state notifications and Notify CPU device objects to
   6  * re-evaluate their _PPC and _CST tables.
   7  */
   8
   9 // DTT Power Participant Device Notification
  10 #define POWER_STATE_CHANGE_NOTIFICATION 0x81
  11 // DTT OEM variables change notification
  12 #define EC_OEM_VARIABLE_DATA_MASK       0x7
  13 #define INT3400_ODVP_CHANGED            0x88
  14
  15 #define ACPI_NOTIFY_CROS_EC_MKBP        0x80
  16 #define ACPI_NOTIFY_CROS_EC_PANIC       0xB0
  17
  18 // Mainboard specific throttle handler
  19 #ifdef DPTF_ENABLE_CHARGER
  20 External (\_SB.DPTF.TCHG, DeviceObj)
  21 #endif
  22 /* Enable DPTC interface with AMD ALIB */
  23 #if CONFIG(SOC_AMD_COMMON_BLOCK_ACPI_DPTC)
  24 External(\_SB.DPTC, MethodObj)
  25 #endif
  26
  27 External (\_SB.DPTF.TPWR, DeviceObj)
  28
  29 #ifdef DPTF_ENABLE_OEM_VARIABLES
  30 External (\_SB.DPTF.ODVP, MethodObj)
  31 External (\_SB.DPTF.ODGT, MethodObj)
  32 External (\_SB.DPTF.ODUP, MethodObj)
  33 #endif
  34
  35 Device (EC0)
  36 {
  37         Name (_HID, EISAID ("PNP0C09"))
  38         Name (_UID, 1)
  39         Name (_GPE, EC_SCI_GPI)
  40         Name (TOFS, EC_TEMP_SENSOR_OFFSET)
  41         Name (TNCA, EC_TEMP_SENSOR_NOT_CALIBRATED)
  42         Name (TNOP, EC_TEMP_SENSOR_NOT_POWERED)
  43         Name (TBAD, EC_TEMP_SENSOR_ERROR)
  44         Name (TNPR, EC_TEMP_SENSOR_NOT_PRESENT)
  45         Name (DWRN, 15)         // Battery capacity warning at 15%
  46         Name (DLOW, 10)         // Battery capacity low at 10%
  47
  48         OperationRegion (ERAM, EmbeddedControl, 0x00, EC_ACPI_MEM_MAPPED_BEGIN)
  49         Field (ERAM, ByteAcc, Lock, Preserve)
  50         {
  51                 RAMV, 8,        // EC RAM Version
  52                 TSTB, 8,        // Test Byte
  53                 TSTC, 8,        // Complement of Test Byte
  54                 KBLV, 8,        // Keyboard Backlight value
  55                 FAND, 8,        // Set Fan Duty Cycle
  56                 PATI, 8,        // Programmable Auxiliary Trip Sensor ID
  57                 PATT, 8,        // Programmable Auxiliary Trip Threshold
  58                 PATC, 8,        // Programmable Auxiliary Trip Commit
  59                 CHGL, 8,        // Charger Current Limit
  60                 TBMD, 1,        // Tablet mode
  61                 DDPN, 3,        // Device DPTF Profile Number
  62                 STTB, 1,        // Switch thermal table by body detection status
  63                 // DFUD must be 0 for the other 31 values to be valid
  64                 Offset (0x0a),
  65                 DFUD, 1,        // Device Features Undefined
  66                 FLSH, 1,        // Flash commands present
  67                 PFAN, 1,        // PWM Fan control present
  68                 KBLE, 1,        // Keyboard Backlight present
  69                 LTBR, 1,        // Lightbar present
  70                 LEDC, 1,        // LED control
  71                 MTNS, 1,        // Motion sensors present
  72                 KEYB, 1,        // EC is keyboard controller
  73                 PSTR, 1,        // Persistent storage
  74                 P80P, 1,        // EC serves I/O Port 80h
  75                 THRM, 1,        // EC supports thermal management
  76                 SBKL, 1,        // Screen backlight switch present
  77                 WIFI, 1,        // WIFI switch present
  78                 HOST, 1,        // EC monitors host events (eg SCI, SMI)
  79                 GPIO, 1,        // EC provides GPIO commands
  80                 I2CB, 1,        // EC provides I2C controller access
  81                 CHRG, 1,        // EC provides commands for charger control
  82                 BATT, 1,        // Simply Battery support
  83                 SBAT, 1,        // Smart Battery support
  84                 HANG, 1,        // EC can detect host hang
  85                 PMUI, 1,        // Power Information
  86                 DSEC, 1,        // another EC exists downstream
  87                 UPDC, 1,        // supports USB Power Delivery
  88                 UMUX, 1,        // supports USB Mux
  89                 MSFF, 1,        // Motion Sense has FIFO
  90                 TVST, 1,        // supports temporary secure vstore
  91                 TCMV, 1,        // USB Type C Muxing is virtual (host assisted)
  92                 RTCD, 1,        // EC provides an RTC device
  93                 FPRD, 1,        // EC provides a fingerprint reader device
  94                 TPAD, 1,        // EC provides a touchpad device
  95                 RWSG, 1,        // EC has RWSIG task enabled
  96                 DEVE, 1,        // EC supports device events
  97                 // make sure we're within our space envelope
  98                 Offset (0x0e),
  99                 Offset (0x12),
 100                 BTID, 8,        // Battery index that host wants to read
 101                 USPP, 8,        // USB Port Power
 102                 RFWU, 8,        // Retimer Firmware Update
 103                 PBOK, 8,        // Power source change count from dptf
 104                 BSRF, 8,        // Battery string readout FIFO
 105         }
 106
 107 #if CONFIG(EC_GOOGLE_CHROMEEC_ACPI_MEMMAP)
 108         OperationRegion (EMEM, EmbeddedControl,
 109                          EC_ACPI_MEM_MAPPED_BEGIN, EC_ACPI_MEM_MAPPED_SIZE)
 110         Field (EMEM, ByteAcc, Lock, Preserve)
 111 #elif CONFIG(EC_GOOGLE_CHROMEEC_LPC_GENERIC_MEMORY_RANGE)
 112         OperationRegion (EMEM, SystemMemory, \_SB.PCI0.LPCB.GLGM() + 0x100, EC_MEMMAP_SIZE)
 113         Field (EMEM, ByteAcc, NoLock, Preserve)
 114 #else
 115         OperationRegion (EMEM, SystemIO, EC_LPC_ADDR_MEMMAP, EC_MEMMAP_SIZE)
 116         Field (EMEM, ByteAcc, NoLock, Preserve)
 117 #endif
 118         {
 119                 #include "emem.asl"
 120         }
 121
 122 #ifdef EC_ENABLE_LID_SWITCH
 123         /* LID Switch */
 124         Device (LID0)
 125         {
 126                 Name (_HID, EisaId ("PNP0C0D"))
 127                 Method (_LID, 0)
 128                 {
 129                         Return (^^LIDS)
 130                 }
 131
 132 #ifdef EC_ENABLE_WAKE_PIN
 133                 Name (_PRW, Package () { EC_ENABLE_WAKE_PIN, 0x5 })
 134 #endif
 135         }
 136 #endif /* EC_ENABLE_LID_SWITCH */
 137
 138         Method (TINS, 1, Serialized)
 139         {
 140                 Switch (ToInteger (Arg0))
 141                 {
 142                         Case (0) { Return (TIN0) }
 143                         Case (1) { Return (TIN1) }
 144                         Case (2) { Return (TIN2) }
 145                         Case (3) { Return (TIN3) }
 146                         Case (4) { Return (TIN4) }
 147                         Case (5) { Return (TIN5) }
 148                         Case (6) { Return (TIN6) }
 149                         Case (7) { Return (TIN7) }
 150                         Case (8) { Return (TIN8) }
 151                         Case (9) { Return (TIN9) }
 152                         Default  { Return (TIN0) }
 153                 }
 154         }
 155
 156         Method (_CRS, 0, Serialized)
 157         {
 158                 Name (ECMD, ResourceTemplate()
 159                 {
 160                         IO (Decode16,
 161                             EC_LPC_ADDR_ACPI_DATA,
 162                             EC_LPC_ADDR_ACPI_DATA,
 163                             0, 1)
 164                         IO (Decode16,
 165                             EC_LPC_ADDR_ACPI_CMD,
 166                             EC_LPC_ADDR_ACPI_CMD,
 167                             0, 1)
 168                 })
 169                 Return (ECMD)
 170         }
 171
 172         Method (_REG, 2, NotSerialized)
 173         {
 174                 // Initialize AC power state
 175                 \PWRS = ACEX
 176                 /*
 177                  * Call PNOT (Platform Notify) to inform platform code
 178                  * about the current AC/battery state. This handles all cases,
 179                  * the battery transitioning into and out of having critically
 180                  * low charge.
 181                  * PWRS isn't valid before this point.
 182                  */
 183                 \PNOT ()
 184
 185 #ifndef EC_ENABLE_LID_SWITCH
 186                 // Initialize LID switch state
 187                 \LIDS = LIDS
 188 #endif
 189
 190 #if CONFIG(SOC_AMD_COMMON_BLOCK_ACPI_DPTC)
 191                 /*
 192                  * Per the device mode (clamshell or tablet) to initialize
 193                  * the thermal setting on OS startup.
 194                  */
 195                 If (CondRefOf (\_SB.DPTC)) {
 196                         \_SB.DPTC()
 197                 }
 198 #endif
 199         }
 200
 201         /* Read requested temperature and check against EC error values */
 202         Method (TSRD, 1, Serialized)
 203         {
 204                 Local0 = \_SB.PCI0.LPCB.EC0.TINS (Arg0)
 205
 206                 /* Check for sensor not calibrated */
 207                 If (Local0 == \_SB.PCI0.LPCB.EC0.TNCA) {
 208                         Return (0)
 209                 }
 210
 211                 /* Check for sensor not present */
 212                 If (Local0 == \_SB.PCI0.LPCB.EC0.TNPR) {
 213                         Return (0)
 214                 }
 215
 216                 /* Check for sensor not powered */
 217                 If (Local0 == \_SB.PCI0.LPCB.EC0.TNOP) {
 218                         Return (0)
 219                 }
 220
 221                 /* Check for sensor bad reading */
 222                 If (Local0 == \_SB.PCI0.LPCB.EC0.TBAD) {
 223                         Return (0)
 224                 }
 225
 226                 /* Adjust by offset to get Kelvin */
 227                 Local0 += \_SB.PCI0.LPCB.EC0.TOFS
 228
 229                 /* Convert to 1/10 Kelvin */
 230                 Local0 *= 10
 231
 232                 Return (Local0)
 233         }
 234
 235         // Lid Closed Event
 236         Method (_Q01, 0, NotSerialized)
 237         {
 238                 Printf ("EC: LID CLOSE")
 239 #if CONFIG(SOC_AMD_COMMON_BLOCK_ACPI_DPTC)
 240                 If (CondRefOf (\_SB.DPTC)) {
 241                         \_SB.DPTC()
 242                 }
 243 #endif
 244 #ifdef EC_ENABLE_LID_SWITCH
 245                 Notify (LID0, 0x80)
 246 #else
 247                 \LIDS = LIDS
 248 #endif
 249         }
 250
 251         // Lid Open Event
 252         Method (_Q02, 0, NotSerialized)
 253         {
 254                 Printf ("EC: LID OPEN")
 255 #if CONFIG(SOC_AMD_COMMON_BLOCK_ACPI_DPTC)
 256                 If (CondRefOf (\_SB.DPTC)) {
 257                         \_SB.DPTC()
 258                 }
 259 #endif
 260                 Notify (CREC, 0x2)
 261 #ifdef EC_ENABLE_LID_SWITCH
 262                 Notify (LID0, 0x80)
 263 #else
 264                 \LIDS = LIDS
 265 #endif
 266         }
 267
 268         // Power Button
 269         Method (_Q03, 0, NotSerialized)
 270         {
 271                 Printf ("EC: POWER BUTTON")
 272         }
 273
 274         // AC Connected
 275         Method (_Q04, 0, NotSerialized)
 276         {
 277                 Printf ("EC: AC CONNECTED")
 278                 \PWRS = ACEX
 279                 Notify (AC, 0x80)
 280 #ifdef DPTF_ENABLE_CHARGER
 281                 If (CondRefOf (\_SB.DPTF.TCHG)) {
 282                         Notify (\_SB.DPTF.TCHG, 0x80)
 283                 }
 284 #endif
 285                 /*
 286                  * Call PNOT (Platform Notify) to inform platform code
 287                  * about the current battery state. This handles all cases,
 288                  * the battery transitioning into and out of having critically
 289                  * low charge.
 290                  */
 291                 \PNOT ()
 292         }
 293
 294         // AC Disconnected
 295         Method (_Q05, 0, NotSerialized)
 296         {
 297                 Printf ("EC: AC DISCONNECTED")
 298                 \PWRS = ACEX
 299                 Notify (AC, 0x80)
 300 #ifdef DPTF_ENABLE_CHARGER
 301                 If (CondRefOf (\_SB.DPTF.TCHG)) {
 302                         Notify (\_SB.DPTF.TCHG, 0x80)
 303                 }
 304 #endif
 305                 /*
 306                  * Call PNOT (Platform Notify) to inform platform code
 307                  * about the current battery state. This handles all cases,
 308                  * the battery transitioning into and out of having critically
 309                  * low charge.
 310                  */
 311                 \PNOT ()
 312         }
 313
 314         // Battery Low Event
 315         Method (_Q06, 0, NotSerialized)
 316         {
 317                 Printf ("EC: BATTERY LOW")
 318                 Notify (BAT0, 0x80)
 319         }
 320
 321         // Battery Critical Event
 322         Method (_Q07, 0, NotSerialized)
 323         {
 324                 Printf ("EC: BATTERY CRITICAL")
 325                 Notify (BAT0, 0x80)
 326         }
 327
 328         // Battery Info Event
 329         Method (_Q08, 0, NotSerialized)
 330         {
 331                 Printf ("EC: BATTERY INFO")
 332                 Notify (BAT0, 0x81)
 333 #ifdef EC_ENABLE_SECOND_BATTERY_DEVICE
 334                 If (CondRefOf (BAT1)) {
 335                         Notify (BAT1, 0x81)
 336                 }
 337 #endif
 338         }
 339
 340         // Thermal Overload Event
 341         Method (_Q0A, 0, NotSerialized)
 342         {
 343                 Printf ("EC: THERMAL OVERLOAD")
 344                 Notify (\_TZ, 0x80)
 345         }
 346
 347         // Thermal Event
 348         Method (_Q0B, 0, NotSerialized)
 349         {
 350                 Printf ("EC: THERMAL")
 351                 Notify (\_TZ, 0x80)
 352         }
 353
 354         // Key Pressed
 355         Method (_Q0D, 0, NotSerialized)
 356         {
 357                 Printf ("EC: KEY PRESSED")
 358                 Notify (CREC, 0x2)
 359         }
 360
 361         // Thermal Shutdown Imminent
 362         Method (_Q10, 0, NotSerialized)
 363         {
 364                 Printf ("EC: THERMAL SHUTDOWN")
 365                 Notify (\_TZ, 0x80)
 366         }
 367
 368         // Battery Shutdown Imminent
 369         Method (_Q11, 0, NotSerialized)
 370         {
 371                 Printf ("EC: BATTERY SHUTDOWN")
 372                 Notify (BAT0, 0x80)
 373         }
 374
 375         // Throttle Start
 376         Method (_Q12, 0, NotSerialized)
 377         {
 378 #ifdef EC_ENABLE_THROTTLING_HANDLER
 379                 Printf ("EC: THROTTLE START")
 380                 \_TZ.THRT (1)
 381 #endif
 382
 383 #ifdef DPTF_ENABLE_OEM_VARIABLES
 384                 Local0 = ToInteger(EOVD) & EC_OEM_VARIABLE_DATA_MASK
 385                 \_SB.DPTF.ODUP(0, Local0)
 386                 Local0 = \_SB.DPTF.ODGT(0)
 387                 \_SB.DPTF.ODVP()
 388                 Notify (\_SB.DPTF, INT3400_ODVP_CHANGED)
 389 #endif
 390         }
 391
 392         // Throttle Stop
 393         Method (_Q13, 0, NotSerialized)
 394         {
 395 #ifdef EC_ENABLE_THROTTLING_HANDLER
 396                 Printf ("EC: THROTTLE STOP")
 397                 \_TZ.THRT (0)
 398 #endif
 399         }
 400
 401 #ifdef EC_ENABLE_PD_MCU_DEVICE
 402         // PD event
 403         Method (_Q16, 0, NotSerialized)
 404         {
 405                 Printf ("EC: GOT PD EVENT")
 406                 Notify (\_SB.PCI0.LPCB.EC0.CREC.ECPD, 0x80)
 407                 If (CondRefOf (\_SB.DPTF.TPWR)) {
 408                         Notify (\_SB.DPTF.TPWR, POWER_STATE_CHANGE_NOTIFICATION)
 409                 }
 410         }
 411 #endif
 412
 413         // Battery Status
 414         Method (_Q17, 0, NotSerialized)
 415         {
 416                 Printf ("EC: BATTERY STATUS")
 417                 Notify (BAT0, 0x80)
 418 #ifdef EC_ENABLE_SECOND_BATTERY_DEVICE
 419                 If (CondRefOf (BAT1)) {
 420                         Notify (BAT1, 0x80)
 421                 }
 422 #endif
 423
 424                 /*
 425                  * Call PNOT (Platform Notify) to inform platform code
 426                  * about the current battery state. This handles all cases,
 427                  * the battery transitioning into and out of having critically
 428                  * low charge.
 429                  */
 430                 \PNOT ()
 431         }
 432
 433         // EC Panic
 434         Method (_Q18, 0, NotSerialized)
 435         {
 436                 Printf ("EC: PANIC")
 437                 Notify (CREC, ACPI_NOTIFY_CROS_EC_PANIC)
 438         }
 439
 440         // MKBP interrupt.
 441         Method (_Q1B, 0, NotSerialized)
 442         {
 443                 Printf ("EC: MKBP")
 444                 Notify (CREC, ACPI_NOTIFY_CROS_EC_MKBP)
 445         }
 446
 447 #ifdef EC_ENABLE_PD_MCU_DEVICE
 448         // USB MUX Interrupt
 449         Method (_Q1C, 0, NotSerialized)
 450         {
 451                 Printf ("EC: USB MUX")
 452                 Notify (\_SB.PCI0.LPCB.EC0.CREC.ECPD, 0x80)
 453         }
 454 #endif
 455
 456         // TABLET mode switch Event
 457         Method (_Q1D, 0, NotSerialized)
 458         {
 459                 Printf ("EC: TABLET mode switch Event")
 460                 Notify (CREC, 0x2)
 461 #ifdef EC_ENABLE_MULTIPLE_DPTF_PROFILES
 462                 \_SB.DPTF.TPET()
 463 #endif
 464 #ifdef EC_ENABLE_TBMC_DEVICE
 465                 Notify (^CREC.TBMC, 0x80)
 466 #endif
 467 #if CONFIG(SOC_AMD_COMMON_BLOCK_ACPI_DPTC)
 468                 If (CondRefOf (\_SB.DPTC)) {
 469                         \_SB.DPTC()
 470                 }
 471 #endif
 472         }
 473
 474         // Body Detect Change Event
 475         Method (_Q21, 0, NotSerialized)
 476         {
 477                 Printf ("EC: Body Detect Change Event")
 478 #if CONFIG(SOC_AMD_COMMON_BLOCK_ACPI_DPTC)
 479                 If (CondRefOf (\_SB.DPTC)) {
 480                         \_SB.DPTC()
 481                 }
 482 #endif
 483         }
 484
 485         /*
 486          * Dynamic Platform Thermal Framework support
 487          */
 488
 489         /* Mutex for EC PAT interface */
 490         Mutex (PATM, 1)
 491
 492         /*
 493          * Set Aux Trip Point 0
 494          *   Arg0 = Temp Sensor ID
 495          *   Arg1 = Value to set
 496          */
 497         Method (PAT0, 2, Serialized)
 498         {
 499                 If (Acquire (^PATM, 1000)) {
 500                         Return (0)
 501                 }
 502
 503                 /* Set sensor ID */
 504                 ^PATI = ToInteger (Arg0)
 505
 506                 /* Temperature is passed in 1/10 Kelvin */
 507                 Local1 = ToInteger (Arg1) / 10
 508
 509                 /* Adjust by EC temperature offset */
 510                 ^PATT = Local1 - ^TOFS
 511
 512                 /* Set commit value with SELECT=0 and ENABLE=1 */
 513                 ^PATC = 0x02
 514
 515                 Release (^PATM)
 516                 Return (1)
 517         }
 518
 519         /*
 520          * Set Aux Trip Point 1
 521          *   Arg0 = Temp Sensor ID
 522          *   Arg1 = Value to set
 523          */
 524         Method (PAT1, 2, Serialized)
 525         {
 526                 If (Acquire (^PATM, 1000)) {
 527                         Return (0)
 528                 }
 529
 530                 /* Set sensor ID */
 531                 ^PATI = ToInteger (Arg0)
 532
 533                 /* Temperature is passed in 1/10 Kelvin */
 534                 Local1 = ToInteger (Arg1) / 10
 535
 536                 /* Adjust by EC temperature offset */
 537                 ^PATT = Local1 - ^TOFS
 538
 539                 /* Set commit value with SELECT=1 and ENABLE=1 */
 540                 ^PATC = 0x03
 541
 542                 Release (^PATM)
 543                 Return (1)
 544         }
 545
 546         /* Disable Aux Trip Points
 547          *   Arg0 = Temp Sensor ID
 548          */
 549         Method (PATD, 1, Serialized)
 550         {
 551                 If (Acquire (^PATM, 1000)) {
 552                         Return (0)
 553                 }
 554
 555                 ^PATI = ToInteger (Arg0)
 556                 ^PATT = 0x00
 557
 558                 /* Disable PAT0 */
 559                 ^PATC = 0x00
 560
 561                 /* Disable PAT1 */
 562                 ^PATC = 0x01
 563
 564                 Release (^PATM)
 565                 Return (1)
 566         }
 567
 568         /*
 569          * Thermal Threshold Event
 570          */
 571         Method (_Q09, 0, NotSerialized)
 572         {
 573
 574 #if CONFIG(SOC_AMD_COMMON_BLOCK_ACPI_DPTC)
 575                 If (CondRefOf (\_SB.DPTC)) {
 576                         \_SB.DPTC()
 577                 }
 578 #endif
 579                 If (!Acquire (^PATM, 1000)) {
 580                         /* Read sensor ID for event */
 581                         Local0 = ^PATI
 582
 583                         /* When sensor ID returns 0xFF then no more events */
 584                         While (Local0 != EC_TEMP_SENSOR_NOT_PRESENT)
 585                         {
 586 #ifdef HAVE_THERM_EVENT_HANDLER
 587                                 \_SB.DPTF.TEVT (Local0)
 588 #endif
 589
 590                                 /* Keep reaading sensor ID for event */
 591                                 Local0 = ^PATI
 592                         }
 593
 594                         Release (^PATM)
 595                 }
 596         }
 597
 598         /*
 599          * Set Charger Current Limit
 600          *   Arg0 = Current Limit in 64mA steps
 601          */
 602         Method (CHGS, 1, Serialized)
 603         {
 604                 ^CHGL = ToInteger (Arg0)
 605         }
 606
 607         /*
 608          * Disable Charger Current Limit
 609          */
 610         Method (CHGD, 0, Serialized)
 611         {
 612                 ^CHGL = 0xFF
 613         }
 614
 615         /* Read current Tablet mode */
 616         Method (RCTM, 0, NotSerialized)
 617         {
 618                 Return (^TBMD)
 619         }
 620
 621 #ifdef EC_ENABLE_MULTIPLE_DPTF_PROFILES
 622         /* Read current Device DPTF Profile Number */
 623         Method (RCDP, 0, NotSerialized)
 624         {
 625                 /*
 626                  * DDPN = 0 is reserved for backwards compatibility.
 627                  * If DDPN == 0 use TBMD to load appropriate DPTF table.
 628                  */
 629                 If (^DDPN == 0) {
 630                         Return (^TBMD)
 631                 } Else {
 632                         Local0 = ^DDPN - 1
 633                         Return (Local0)
 634                 }
 635         }
 636 #endif
 637 #if CONFIG(EC_GOOGLE_CHROMEEC_ACPI_USB_PORT_POWER)
 638         /*
 639          * Enable USB Port Power
 640          *   Arg0 = USB port ID
 641          */
 642         Method (UPPS, 1, Serialized)
 643         {
 644                 USPP |= 1 << Arg0
 645         }
 646
 647         /*
 648          * Disable USB Port Power
 649          *   Arg0 = USB port ID
 650          */
 651         Method (UPPC, 1, Serialized)
 652         {
 653                 USPP &= ~(1 << Arg0)
 654         }
 655 #endif
 656
 657         #include "ac.asl"
 658         #include "battery.asl"
 659         #include "cros_ec.asl"
 660
 661 #ifdef EC_ENABLE_ALS_DEVICE
 662         #include "als.asl"
 663 #endif
 664
 665 #ifdef EC_ENABLE_KEYBOARD_BACKLIGHT
 666         #include "keyboard_backlight.asl"
 667 #endif
 668 }