src/mainboard/getac/p470/acpi/battery.asl

   1 /*
   2  * This file is part of the coreboot project.
   3  *
   4  * Copyright (C) 2009 coresystems GmbH
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License as
   8  * published by the Free Software Foundation; version 2 of
   9  * the License.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
  19  * MA 02110-1301 USA
  20  */
  21
  22 Scope(\_SB) {
  23
  24         Name(NIMH, "NiMH")
  25         Name(LION, "Lion")
  26
  27         Device (BAT0)
  28         {
  29                 Name(_HID, EisaId("PNP0C0A"))
  30                 Name(_UID, 1)
  31
  32                 Name(_PCL, Package(){ \_SB })
  33
  34                 Name(PBST, Package() { 0x00, 0x04b0, 0x0bb8, 0x03e8 })
  35
  36                 /* Status */
  37                 Method(_STA, 0)
  38                 {
  39                         Sleep(120)
  40                         If(\_SB.PCI0.LPCB.EC0.BAT) {
  41                                 Return(0x1f)
  42                         } Else {
  43                                 Return(0x0f)
  44                         }
  45                 }
  46
  47                 /* Battery Info */
  48                 Method(_BIF, 0)
  49                 {
  50                         Name(PBIF, Package() {
  51                                 0x01,
  52                                 0x0fa0,
  53                                 0x0fa0,
  54                                 0x01,
  55                                 0x2ee0, // Capacity?
  56                                 0x012c,
  57                                 0x96,
  58                                 0x01,
  59                                 0x01,
  60                                 "Battery",      // Name
  61                                 "",             // Number
  62                                 "LIon",         // Type
  63                                 "Generic"       // Vendor
  64                         })
  65
  66                         // Is battery there?
  67                         Store(_STA(), Local0)
  68                         And(Local0, 0x10, Local0)
  69                         If(LNot(Local0)) {
  70                                 Return (PBIF)
  71                         }
  72
  73                         Store(\_SB.PCI0.LPCB.EC0.BDC0, Index(PBIF, 1))
  74                         Store(\_SB.PCI0.LPCB.EC0.BDV0, Index(PBIF, 4))
  75
  76                         Store(\_SB.PCI0.LPCB.EC0.BFC0, Local0)
  77                         Store(Local0, Index(PBIF, 2))
  78
  79                         Divide(Local0, 10, Local1, Local2)
  80                         Store(Local2, Index(PBIF, 5))
  81
  82                         Divide(Local0, 20, Local1, Local2)
  83                         Store(Local2, Index(PBIF, 6))
  84
  85                         If(\_SB.PCI0.LPCB.EC0.BTYP) {
  86                                 Store(NIMH, Index(PBIF, 11))
  87                         } Else {
  88                                 Store(LION, Index(PBIF, 11))
  89                         }
  90
  91                         Return(PBIF)
  92                 }
  93
  94                 /* Battery Status */
  95                 Method(_BST, 0)
  96                 {
  97                         If(\_SB.PCI0.LPCB.EC0.BAT) {
  98                                 Store(\_SB.PCI0.LPCB.EC0.BPV0, Index(PBST, 3))
  99
 100                                 Multiply(\_SB.PCI0.LPCB.EC0.BRC0, 100, Local3)
 101                                 Divide(Local3, \_SB.PCI0.LPCB.EC0.BFC0, Local3, Local0)
 102                                 Multiply(\_SB.PCI0.LPCB.EC0.BFC0, Local0, Local3)
 103                                 Divide(Local3, 0x64, Local3, Local0)
 104                                 Increment(Local0)
 105                                 Store(Local0, Index(PBST, 2))
 106
 107                                 Store (\_SB.PCI0.LPCB.EC0.BRC0, Local3)
 108                                 Store (\_SB.PCI0.LPCB.EC0.BPR0, Local0)
 109                                 And (Not (Local0), 0xFFFF, Local0)
 110                                 Store (Local0, Index(PBST,1))
 111
 112                                 // AC Power connected?
 113                                 If(\_SB.PCI0.LPCB.EC0.ADP) {
 114                                         If(\_SB.PCI0.LPCB.EC0.CHRG) {
 115                                                 Store(2, Index(PBST, 0))
 116                                         } Else {
 117                                                 Store(0, Index(PBST, 0))
 118                                         }
 119                                 } Else {
 120                                         If(LLess(Local3, 25)) {
 121                                                 Store(5, Index(PBST, 0))
 122                                         } Else {
 123                                                 Store(1, Index(PBST, 0))
 124                                         }
 125                                 }
 126                         }
 127                         Return(PBST)
 128                 }
 129         }
 130
 131
 132         Device (BAT1)
 133         {
 134                 Name(_HID, EisaId("PNP0C0A"))
 135                 Name(_UID, 1)
 136
 137                 Name(_PCL, Package(){ \_SB })
 138
 139                 Name(PBST, Package() { 0x00, 0x04b0, 0x0bb8, 0x03e8 })
 140
 141                 /* Status */
 142                 Method(_STA, 0)
 143                 {
 144                         Sleep(120)
 145                         If(\_SB.PCI0.LPCB.EC0.BAT2) {
 146                                 Return(0x1f)
 147                         } Else {
 148                                 Return(0x0f)
 149                         }
 150                 }
 151
 152                 /* Battery Info */
 153                 Method(_BIF, 0)
 154                 {
 155                         Name(PBIF, Package() {
 156                                 0x01,
 157                                 0x0fa0,
 158                                 0x0fa0,
 159                                 0x01,
 160                                 0x2ee0, // Capacity?
 161                                 0x012c,
 162                                 0x96,
 163                                 0x01,
 164                                 0x01,
 165                                 "Battery",      // Name
 166                                 "",             // Number
 167                                 "LIon",         // Type
 168                                 "Generic"       // Vendor
 169                         })
 170
 171                         // Is battery there?
 172                         Store(_STA(), Local0)
 173                         And(Local0, 0x10, Local0)
 174                         If(LNot(Local0)) {
 175                                 Return (PBIF)
 176                         }
 177
 178                         Store(\_SB.PCI0.LPCB.EC0.BDC2, Index(PBIF, 1))
 179                         Store(\_SB.PCI0.LPCB.EC0.BDV2, Index(PBIF, 4))
 180
 181                         Store(\_SB.PCI0.LPCB.EC0.BFC2, Local0)
 182                         Store(Local0, Index(PBIF, 2))
 183
 184                         Divide(Local0, 10, Local1, Local2)
 185                         Store(Local2, Index(PBIF, 5))
 186
 187                         Divide(Local0, 20, Local1, Local2)
 188                         Store(Local2, Index(PBIF, 6))
 189
 190                         If(\_SB.PCI0.LPCB.EC0.BTY2) {
 191                                 Store(NIMH, Index(PBIF, 11))
 192                         } Else {
 193                                 Store(LION, Index(PBIF, 11))
 194                         }
 195
 196                         Return(PBIF)
 197                 }
 198
 199                 /* Battery Status */
 200                 Method(_BST, 0)
 201                 {
 202                         If(\_SB.PCI0.LPCB.EC0.BAT2) {
 203                                 Store(\_SB.PCI0.LPCB.EC0.BPV2, Index(PBST, 3))
 204
 205                                 Multiply(\_SB.PCI0.LPCB.EC0.BRC2, 100, Local3)
 206                                 Divide(Local3, \_SB.PCI0.LPCB.EC0.BFC2, Local3, Local0)
 207                                 Multiply(\_SB.PCI0.LPCB.EC0.BFC2, Local0, Local3)
 208                                 Divide(Local3, 0x64, Local3, Local0)
 209                                 Increment(Local0)
 210                                 Store(Local0, Index(PBST, 2))
 211
 212                                 Store (\_SB.PCI0.LPCB.EC0.BRC2, Local3)
 213                                 Store (\_SB.PCI0.LPCB.EC0.BPR2, Local0)
 214                                 And (Not (Local0), 0xFFFF, Local0)
 215                                 Store (Local0, Index(PBST,1))
 216
 217                                 // AC Power connected?
 218                                 If(\_SB.PCI0.LPCB.EC0.ADP) {
 219                                         If(\_SB.PCI0.LPCB.EC0.CRG2) {
 220                                                 Store(2, Index(PBST, 0))
 221                                         } Else {
 222                                                 Store(0, Index(PBST, 0))
 223                                         }
 224                                 } Else {
 225                                         If(LLess(Local3, 25)) {
 226                                                 Store(5, Index(PBST, 0))
 227                                         } Else {
 228                                                 Store(1, Index(PBST, 0))
 229                                         }
 230                                 }
 231                         }
 232                         Return(PBST)
 233                 }
 234         }
 235
 236         Name (PWRS, 0)
 237         Name (ACFG, 0)
 238
 239         Device (AC)
 240         {
 241                 Name (_HID, "ACPI0003")
 242                 Name (ACST, 0x00)
 243                 Method (_PSR, 0)
 244                 {
 245                         If(ACFG) {
 246                                 Store(ACST, Local0)
 247                         } Else {
 248                                 Store(\_SB.PCI0.LPCB.EC0.ADP, Local0)
 249                                 Store(Local0, ACST)
 250                                 Store(1, ACFG)
 251                         }
 252                         Sleep(120)
 253                         Return (Local0)
 254                 }
 255
 256                 Name(_PCL, Package(){
 257                         \_SB,
 258                         BAT0,
 259                         BAT1
 260                 })
 261         }
 262 }