src/soc/intel/broadwell/acpi/smbus.asl

   1 /*
   2  * This file is part of the coreboot project.
   3  *
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; version 2 of the License.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  */
  14
  15 // Intel SMBus Controller 0:1f.3
  16
  17 Device (SBUS)
  18 {
  19         Name (_ADR, 0x001f0003)
  20
  21 #ifdef ENABLE_SMBUS_METHODS
  22         OperationRegion (SMBP, PCI_Config, 0x00, 0x100)
  23         Field(SMBP, DWordAcc, NoLock, Preserve)
  24         {
  25                 Offset(0x40),
  26                 ,       2,
  27                 I2CE,   1
  28         }
  29
  30         OperationRegion (SMBI, SystemIO, SMBUS_IO_BASE, 0x20)
  31         Field (SMBI, ByteAcc, NoLock, Preserve)
  32         {
  33                 HSTS,   8,      // Host Status
  34                 ,       8,
  35                 HCNT,   8,      // Host Control
  36                 HCMD,   8,      // Host Command
  37                 TXSA,   8,      // Transmit Slave Address
  38                 DAT0,   8,      // Host Data 0
  39                 DAT1,   8,      // Host Data 1
  40                 HBDB,   8,      // Host Block Data Byte
  41                 PECK,   8,      // Packet Error Check
  42                 RXSA,   8,      // Receive Slave Address
  43                 RXDA,   16,     // Receive Slave Data
  44                 AUXS,   8,      // Auxiliary Status
  45                 AUXC,   8,      // Auxiliary Control
  46                 SLPC,   8,      // SMLink Pin Control
  47                 SBPC,   8,      // SMBus Pin Control
  48                 SSTS,   8,      // Slave Status
  49                 SCMD,   8,      // Slave Command
  50                 NADR,   8,      // Notify Device Address
  51                 NDLB,   8,      // Notify Data Low Byte
  52                 NDLH,   8,      // Notify Data High Byte
  53         }
  54
  55         // Kill all SMBus communication
  56         Method (KILL, 0, Serialized)
  57         {
  58                 Or (HCNT, 0x02, HCNT)   // Send Kill
  59                 Or (HSTS, 0xff, HSTS)   // Clean Status
  60         }
  61
  62         // Check if last operation completed
  63         // return       Failure = 0, Success = 1
  64         Method (CMPL, 0, Serialized)
  65         {
  66                 Store (4000, Local0)            // Timeout 200ms in 50us steps
  67                 While (Local0) {
  68                         If (And(HSTS, 0x02)) {  // Completion Status?
  69                                 Return (1)      // Operation Completed
  70                         } Else {
  71                                 Stall (50)
  72                                 Decrement (Local0)
  73                                 If (LEqual(Local0, 0)) {
  74                                         KILL()
  75                                 }
  76                         }
  77                 }
  78
  79                 Return (0)              //  Failure
  80         }
  81
  82
  83         // Wait for SMBus to become ready
  84         Method (SRDY, 0, Serialized)
  85         {
  86                 Store (200, Local0)     // Timeout 200ms
  87                 While (Local0) {
  88                         If (And(HSTS, 0x40)) {          // IN_USE?
  89                                 Sleep(1)                // Wait 1ms
  90                                 Decrement(Local0)       // timeout--
  91                                 If (LEqual(Local0, 0)) {
  92                                         Return (1)
  93                                 }
  94                         } Else {
  95                                 Store (0, Local0)       // We're ready
  96                         }
  97                 }
  98
  99                 Store (4000, Local0)    // Timeout 200ms (50us * 4000)
 100                 While (Local0) {
 101                         If (And (HSTS, 0x01)) {         // Host Busy?
 102                                 Stall(50)               // Wait 50us
 103                                 Decrement(Local0)       // timeout--
 104                                 If (LEqual(Local0, 0)) {
 105                                         KILL()
 106                                 }
 107                         } Else {
 108                                 Return (0)              // Success
 109                         }
 110                 }
 111
 112                 Return (1)              // Failure
 113         }
 114
 115         // SMBus Send Byte
 116         // Arg0:        Address
 117         // Arg1:        Data
 118         // Return:      1 = Success, 0=Failure
 119
 120         Method (SSXB, 2, Serialized)
 121         {
 122
 123                 // Is the SMBus Controller Ready?
 124                 If (SRDY()) {
 125                         Return (0)
 126                 }
 127
 128                 // Send Byte
 129                 Store (0, I2CE)         // SMBus Enable
 130                 Store (0xbf, HSTS)
 131                 Store (Arg0, TXSA)      // Write Address
 132                 Store (Arg1, HCMD)      // Write Data
 133
 134                 Store (0x48, HCNT)      // Start + Byte Data Protocol
 135
 136                 If (CMPL()) {
 137                         Or (HSTS, 0xff, HSTS)   // Clean up
 138                         Return (1)              // Success
 139                 }
 140
 141                 Return (0)
 142         }
 143
 144
 145         // SMBus Receive Byte
 146         // Arg0:        Address
 147         // Return:      0xffff = Failure, Data (8bit) = Success
 148
 149         Method (SRXB, 2, Serialized)
 150         {
 151
 152                 // Is the SMBus Controller Ready?
 153                 If (SRDY()) {
 154                         Return (0xffff)
 155                 }
 156
 157                 // Receive Byte
 158                 Store (0, I2CE)         // SMBus Enable
 159                 Store (0xbf, HSTS)
 160                 Store (Or (Arg0, 1), TXSA)      // Write Address
 161
 162                 Store (0x44, HCNT)      // Start
 163
 164                 If (CMPL()) {
 165                         Or (HSTS, 0xff, HSTS)   // Clean up
 166                         Return (DAT0)           // Success
 167                 }
 168
 169                 Return (0xffff)
 170         }
 171
 172
 173         // SMBus Write Byte
 174         // Arg0:        Address
 175         // Arg1:        Command
 176         // Arg2:        Data
 177         // Return:      1 = Success, 0=Failure
 178
 179         Method (SWRB, 3, Serialized)
 180         {
 181
 182                 // Is the SMBus Controller Ready?
 183                 If (SRDY()) {
 184                         Return (0)
 185                 }
 186
 187                 // Send Byte
 188                 Store (0, I2CE)         // SMBus Enable
 189                 Store (0xbf, HSTS)
 190                 Store (Arg0, TXSA)      // Write Address
 191                 Store (Arg1, HCMD)      // Write Command
 192                 Store (Arg2, DAT0)      // Write Data
 193
 194                 Store (0x48, HCNT)      // Start + Byte Protocol
 195
 196                 If (CMPL()) {
 197                         Or (HSTS, 0xff, HSTS)   // Clean up
 198                         Return (1)              // Success
 199                 }
 200
 201                 Return (0)
 202         }
 203
 204
 205         // SMBus Read Byte
 206         // Arg0:        Address
 207         // Arg1:        Command
 208         // Return:      0xffff = Failure, Data (8bit) = Success
 209
 210         Method (SRDB, 2, Serialized)
 211         {
 212
 213                 // Is the SMBus Controller Ready?
 214                 If (SRDY()) {
 215                         Return (0xffff)
 216                 }
 217
 218                 // Receive Byte
 219                 Store (0, I2CE)                 // SMBus Enable
 220                 Store (0xbf, HSTS)
 221                 Store (Or (Arg0, 1), TXSA)      // Write Address
 222                 Store (Arg1, HCMD)              // Command
 223
 224                 Store (0x48, HCNT)              // Start
 225
 226                 If (CMPL()) {
 227                         Or (HSTS, 0xff, HSTS)   // Clean up
 228                         Return (DAT0)           // Success
 229                 }
 230
 231                 Return (0xffff)
 232         }
 233 #endif
 234 }