1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 Copyright (c) 1998 - 2002 Frodo Looijaard <frodol@dds.nl>, 4 Philip Edelbrock <phil@netroedge.com>, and Mark D. Studebaker 5 <mdsxyz123@yahoo.com> 6 Copyright (C) 2007 - 2014 Jean Delvare <jdelvare@suse.de> 7 Copyright (C) 2010 Intel Corporation, 8 David Woodhouse <dwmw2@infradead.org> 9 10 */ 11 12 /* 13 * Supports the following Intel I/O Controller Hubs (ICH): 14 * 15 * I/O Block I2C 16 * region SMBus Block proc. block 17 * Chip name PCI ID size PEC buffer call read 18 * --------------------------------------------------------------------------- 19 * 82801AA (ICH) 0x2413 16 no no no no 20 * 82801AB (ICH0) 0x2423 16 no no no no 21 * 82801BA (ICH2) 0x2443 16 no no no no 22 * 82801CA (ICH3) 0x2483 32 soft no no no 23 * 82801DB (ICH4) 0x24c3 32 hard yes no no 24 * 82801E (ICH5) 0x24d3 32 hard yes yes yes 25 * 6300ESB 0x25a4 32 hard yes yes yes 26 * 82801F (ICH6) 0x266a 32 hard yes yes yes 27 * 6310ESB/6320ESB 0x269b 32 hard yes yes yes 28 * 82801G (ICH7) 0x27da 32 hard yes yes yes 29 * 82801H (ICH8) 0x283e 32 hard yes yes yes 30 * 82801I (ICH9) 0x2930 32 hard yes yes yes 31 * EP80579 (Tolapai) 0x5032 32 hard yes yes yes 32 * ICH10 0x3a30 32 hard yes yes yes 33 * ICH10 0x3a60 32 hard yes yes yes 34 * 5/3400 Series (PCH) 0x3b30 32 hard yes yes yes 35 * 6 Series (PCH) 0x1c22 32 hard yes yes yes 36 * Patsburg (PCH) 0x1d22 32 hard yes yes yes 37 * Patsburg (PCH) IDF 0x1d70 32 hard yes yes yes 38 * Patsburg (PCH) IDF 0x1d71 32 hard yes yes yes 39 * Patsburg (PCH) IDF 0x1d72 32 hard yes yes yes 40 * DH89xxCC (PCH) 0x2330 32 hard yes yes yes 41 * Panther Point (PCH) 0x1e22 32 hard yes yes yes 42 * Lynx Point (PCH) 0x8c22 32 hard yes yes yes 43 * Lynx Point-LP (PCH) 0x9c22 32 hard yes yes yes 44 * Avoton (SOC) 0x1f3c 32 hard yes yes yes 45 * Wellsburg (PCH) 0x8d22 32 hard yes yes yes 46 * Wellsburg (PCH) MS 0x8d7d 32 hard yes yes yes 47 * Wellsburg (PCH) MS 0x8d7e 32 hard yes yes yes 48 * Wellsburg (PCH) MS 0x8d7f 32 hard yes yes yes 49 * Coleto Creek (PCH) 0x23b0 32 hard yes yes yes 50 * Wildcat Point (PCH) 0x8ca2 32 hard yes yes yes 51 * Wildcat Point-LP (PCH) 0x9ca2 32 hard yes yes yes 52 * BayTrail (SOC) 0x0f12 32 hard yes yes yes 53 * Braswell (SOC) 0x2292 32 hard yes yes yes 54 * Sunrise Point-H (PCH) 0xa123 32 hard yes yes yes 55 * Sunrise Point-LP (PCH) 0x9d23 32 hard yes yes yes 56 * DNV (SOC) 0x19df 32 hard yes yes yes 57 * Emmitsburg (PCH) 0x1bc9 32 hard yes yes yes 58 * Broxton (SOC) 0x5ad4 32 hard yes yes yes 59 * Lewisburg (PCH) 0xa1a3 32 hard yes yes yes 60 * Lewisburg Supersku (PCH) 0xa223 32 hard yes yes yes 61 * Kaby Lake PCH-H (PCH) 0xa2a3 32 hard yes yes yes 62 * Gemini Lake (SOC) 0x31d4 32 hard yes yes yes 63 * Cannon Lake-H (PCH) 0xa323 32 hard yes yes yes 64 * Cannon Lake-LP (PCH) 0x9da3 32 hard yes yes yes 65 * Cedar Fork (PCH) 0x18df 32 hard yes yes yes 66 * Ice Lake-LP (PCH) 0x34a3 32 hard yes yes yes 67 * Comet Lake (PCH) 0x02a3 32 hard yes yes yes 68 * Comet Lake-H (PCH) 0x06a3 32 hard yes yes yes 69 * Elkhart Lake (PCH) 0x4b23 32 hard yes yes yes 70 * Tiger Lake-LP (PCH) 0xa0a3 32 hard yes yes yes 71 * Tiger Lake-H (PCH) 0x43a3 32 hard yes yes yes 72 * Jasper Lake (SOC) 0x4da3 32 hard yes yes yes 73 * Comet Lake-V (PCH) 0xa3a3 32 hard yes yes yes 74 * Alder Lake-S (PCH) 0x7aa3 32 hard yes yes yes 75 * Alder Lake-P (PCH) 0x51a3 32 hard yes yes yes 76 * Alder Lake-M (PCH) 0x54a3 32 hard yes yes yes 77 * 78 * Features supported by this driver: 79 * Software PEC no 80 * Hardware PEC yes 81 * Block buffer yes 82 * Block process call transaction yes 83 * I2C block read transaction yes (doesn't use the block buffer) 84 * Slave mode no 85 * SMBus Host Notify yes 86 * Interrupt processing yes 87 * 88 * See the file Documentation/i2c/busses/i2c-i801.rst for details. 89 */ 90 91 #include <linux/interrupt.h> 92 #include <linux/module.h> 93 #include <linux/pci.h> 94 #include <linux/kernel.h> 95 #include <linux/stddef.h> 96 #include <linux/delay.h> 97 #include <linux/ioport.h> 98 #include <linux/init.h> 99 #include <linux/i2c.h> 100 #include <linux/i2c-smbus.h> 101 #include <linux/acpi.h> 102 #include <linux/io.h> 103 #include <linux/dmi.h> 104 #include <linux/slab.h> 105 #include <linux/string.h> 106 #include <linux/wait.h> 107 #include <linux/err.h> 108 #include <linux/platform_device.h> 109 #include <linux/platform_data/itco_wdt.h> 110 #include <linux/pm_runtime.h> 111 112 #if IS_ENABLED(CONFIG_I2C_MUX_GPIO) && defined CONFIG_DMI 113 #include <linux/gpio/machine.h> 114 #include <linux/platform_data/i2c-mux-gpio.h> 115 #endif 116 117 /* I801 SMBus address offsets */ 118 #define SMBHSTSTS(p) (0 + (p)->smba) 119 #define SMBHSTCNT(p) (2 + (p)->smba) 120 #define SMBHSTCMD(p) (3 + (p)->smba) 121 #define SMBHSTADD(p) (4 + (p)->smba) 122 #define SMBHSTDAT0(p) (5 + (p)->smba) 123 #define SMBHSTDAT1(p) (6 + (p)->smba) 124 #define SMBBLKDAT(p) (7 + (p)->smba) 125 #define SMBPEC(p) (8 + (p)->smba) /* ICH3 and later */ 126 #define SMBAUXSTS(p) (12 + (p)->smba) /* ICH4 and later */ 127 #define SMBAUXCTL(p) (13 + (p)->smba) /* ICH4 and later */ 128 #define SMBSLVSTS(p) (16 + (p)->smba) /* ICH3 and later */ 129 #define SMBSLVCMD(p) (17 + (p)->smba) /* ICH3 and later */ 130 #define SMBNTFDADD(p) (20 + (p)->smba) /* ICH3 and later */ 131 132 /* PCI Address Constants */ 133 #define SMBBAR 4 134 #define SMBPCICTL 0x004 135 #define SMBPCISTS 0x006 136 #define SMBHSTCFG 0x040 137 #define TCOBASE 0x050 138 #define TCOCTL 0x054 139 140 #define SBREG_BAR 0x10 141 #define SBREG_SMBCTRL 0xc6000c 142 #define SBREG_SMBCTRL_DNV 0xcf000c 143 144 /* Host status bits for SMBPCISTS */ 145 #define SMBPCISTS_INTS BIT(3) 146 147 /* Control bits for SMBPCICTL */ 148 #define SMBPCICTL_INTDIS BIT(10) 149 150 /* Host configuration bits for SMBHSTCFG */ 151 #define SMBHSTCFG_HST_EN BIT(0) 152 #define SMBHSTCFG_SMB_SMI_EN BIT(1) 153 #define SMBHSTCFG_I2C_EN BIT(2) 154 #define SMBHSTCFG_SPD_WD BIT(4) 155 156 /* TCO configuration bits for TCOCTL */ 157 #define TCOCTL_EN BIT(8) 158 159 /* Auxiliary status register bits, ICH4+ only */ 160 #define SMBAUXSTS_CRCE BIT(0) 161 #define SMBAUXSTS_STCO BIT(1) 162 163 /* Auxiliary control register bits, ICH4+ only */ 164 #define SMBAUXCTL_CRC BIT(0) 165 #define SMBAUXCTL_E32B BIT(1) 166 167 /* Other settings */ 168 #define MAX_RETRIES 400 169 170 /* I801 command constants */ 171 #define I801_QUICK 0x00 172 #define I801_BYTE 0x04 173 #define I801_BYTE_DATA 0x08 174 #define I801_WORD_DATA 0x0C 175 #define I801_PROC_CALL 0x10 /* unimplemented */ 176 #define I801_BLOCK_DATA 0x14 177 #define I801_I2C_BLOCK_DATA 0x18 /* ICH5 and later */ 178 #define I801_BLOCK_PROC_CALL 0x1C 179 180 /* I801 Host Control register bits */ 181 #define SMBHSTCNT_INTREN BIT(0) 182 #define SMBHSTCNT_KILL BIT(1) 183 #define SMBHSTCNT_LAST_BYTE BIT(5) 184 #define SMBHSTCNT_START BIT(6) 185 #define SMBHSTCNT_PEC_EN BIT(7) /* ICH3 and later */ 186 187 /* I801 Hosts Status register bits */ 188 #define SMBHSTSTS_BYTE_DONE BIT(7) 189 #define SMBHSTSTS_INUSE_STS BIT(6) 190 #define SMBHSTSTS_SMBALERT_STS BIT(5) 191 #define SMBHSTSTS_FAILED BIT(4) 192 #define SMBHSTSTS_BUS_ERR BIT(3) 193 #define SMBHSTSTS_DEV_ERR BIT(2) 194 #define SMBHSTSTS_INTR BIT(1) 195 #define SMBHSTSTS_HOST_BUSY BIT(0) 196 197 /* Host Notify Status register bits */ 198 #define SMBSLVSTS_HST_NTFY_STS BIT(0) 199 200 /* Host Notify Command register bits */ 201 #define SMBSLVCMD_HST_NTFY_INTREN BIT(0) 202 203 #define STATUS_ERROR_FLAGS (SMBHSTSTS_FAILED | SMBHSTSTS_BUS_ERR | \ 204 SMBHSTSTS_DEV_ERR) 205 206 #define STATUS_FLAGS (SMBHSTSTS_BYTE_DONE | SMBHSTSTS_INTR | \ 207 STATUS_ERROR_FLAGS) 208 209 /* Older devices have their ID defined in <linux/pci_ids.h> */ 210 #define PCI_DEVICE_ID_INTEL_COMETLAKE_SMBUS 0x02a3 211 #define PCI_DEVICE_ID_INTEL_COMETLAKE_H_SMBUS 0x06a3 212 #define PCI_DEVICE_ID_INTEL_BAYTRAIL_SMBUS 0x0f12 213 #define PCI_DEVICE_ID_INTEL_CDF_SMBUS 0x18df 214 #define PCI_DEVICE_ID_INTEL_DNV_SMBUS 0x19df 215 #define PCI_DEVICE_ID_INTEL_EBG_SMBUS 0x1bc9 216 #define PCI_DEVICE_ID_INTEL_COUGARPOINT_SMBUS 0x1c22 217 #define PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS 0x1d22 218 /* Patsburg also has three 'Integrated Device Function' SMBus controllers */ 219 #define PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS_IDF0 0x1d70 220 #define PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS_IDF1 0x1d71 221 #define PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS_IDF2 0x1d72 222 #define PCI_DEVICE_ID_INTEL_PANTHERPOINT_SMBUS 0x1e22 223 #define PCI_DEVICE_ID_INTEL_AVOTON_SMBUS 0x1f3c 224 #define PCI_DEVICE_ID_INTEL_BRASWELL_SMBUS 0x2292 225 #define PCI_DEVICE_ID_INTEL_DH89XXCC_SMBUS 0x2330 226 #define PCI_DEVICE_ID_INTEL_COLETOCREEK_SMBUS 0x23b0 227 #define PCI_DEVICE_ID_INTEL_GEMINILAKE_SMBUS 0x31d4 228 #define PCI_DEVICE_ID_INTEL_ICELAKE_LP_SMBUS 0x34a3 229 #define PCI_DEVICE_ID_INTEL_5_3400_SERIES_SMBUS 0x3b30 230 #define PCI_DEVICE_ID_INTEL_TIGERLAKE_H_SMBUS 0x43a3 231 #define PCI_DEVICE_ID_INTEL_ELKHART_LAKE_SMBUS 0x4b23 232 #define PCI_DEVICE_ID_INTEL_JASPER_LAKE_SMBUS 0x4da3 233 #define PCI_DEVICE_ID_INTEL_ALDER_LAKE_P_SMBUS 0x51a3 234 #define PCI_DEVICE_ID_INTEL_ALDER_LAKE_M_SMBUS 0x54a3 235 #define PCI_DEVICE_ID_INTEL_BROXTON_SMBUS 0x5ad4 236 #define PCI_DEVICE_ID_INTEL_ALDER_LAKE_S_SMBUS 0x7aa3 237 #define PCI_DEVICE_ID_INTEL_LYNXPOINT_SMBUS 0x8c22 238 #define PCI_DEVICE_ID_INTEL_WILDCATPOINT_SMBUS 0x8ca2 239 #define PCI_DEVICE_ID_INTEL_WELLSBURG_SMBUS 0x8d22 240 #define PCI_DEVICE_ID_INTEL_WELLSBURG_SMBUS_MS0 0x8d7d 241 #define PCI_DEVICE_ID_INTEL_WELLSBURG_SMBUS_MS1 0x8d7e 242 #define PCI_DEVICE_ID_INTEL_WELLSBURG_SMBUS_MS2 0x8d7f 243 #define PCI_DEVICE_ID_INTEL_LYNXPOINT_LP_SMBUS 0x9c22 244 #define PCI_DEVICE_ID_INTEL_WILDCATPOINT_LP_SMBUS 0x9ca2 245 #define PCI_DEVICE_ID_INTEL_SUNRISEPOINT_LP_SMBUS 0x9d23 246 #define PCI_DEVICE_ID_INTEL_CANNONLAKE_LP_SMBUS 0x9da3 247 #define PCI_DEVICE_ID_INTEL_TIGERLAKE_LP_SMBUS 0xa0a3 248 #define PCI_DEVICE_ID_INTEL_SUNRISEPOINT_H_SMBUS 0xa123 249 #define PCI_DEVICE_ID_INTEL_LEWISBURG_SMBUS 0xa1a3 250 #define PCI_DEVICE_ID_INTEL_LEWISBURG_SSKU_SMBUS 0xa223 251 #define PCI_DEVICE_ID_INTEL_KABYLAKE_PCH_H_SMBUS 0xa2a3 252 #define PCI_DEVICE_ID_INTEL_CANNONLAKE_H_SMBUS 0xa323 253 #define PCI_DEVICE_ID_INTEL_COMETLAKE_V_SMBUS 0xa3a3 254 255 struct i801_mux_config { 256 char *gpio_chip; 257 unsigned values[3]; 258 int n_values; 259 unsigned classes[3]; 260 unsigned gpios[2]; /* Relative to gpio_chip->base */ 261 int n_gpios; 262 }; 263 264 struct i801_priv { 265 struct i2c_adapter adapter; 266 unsigned long smba; 267 unsigned char original_hstcfg; 268 unsigned char original_slvcmd; 269 struct pci_dev *pci_dev; 270 unsigned int features; 271 272 /* isr processing */ 273 wait_queue_head_t waitq; 274 u8 status; 275 276 /* Command state used by isr for byte-by-byte block transactions */ 277 u8 cmd; 278 bool is_read; 279 int count; 280 int len; 281 u8 *data; 282 283 #if IS_ENABLED(CONFIG_I2C_MUX_GPIO) && defined CONFIG_DMI 284 const struct i801_mux_config *mux_drvdata; 285 struct platform_device *mux_pdev; 286 struct gpiod_lookup_table *lookup; 287 #endif 288 struct platform_device *tco_pdev; 289 290 /* 291 * If set to true the host controller registers are reserved for 292 * ACPI AML use. Protected by acpi_lock. 293 */ 294 bool acpi_reserved; 295 struct mutex acpi_lock; 296 }; 297 298 #define FEATURE_SMBUS_PEC BIT(0) 299 #define FEATURE_BLOCK_BUFFER BIT(1) 300 #define FEATURE_BLOCK_PROC BIT(2) 301 #define FEATURE_I2C_BLOCK_READ BIT(3) 302 #define FEATURE_IRQ BIT(4) 303 #define FEATURE_HOST_NOTIFY BIT(5) 304 /* Not really a feature, but it's convenient to handle it as such */ 305 #define FEATURE_IDF BIT(15) 306 #define FEATURE_TCO_SPT BIT(16) 307 #define FEATURE_TCO_CNL BIT(17) 308 309 static const char *i801_feature_names[] = { 310 "SMBus PEC", 311 "Block buffer", 312 "Block process call", 313 "I2C block read", 314 "Interrupt", 315 "SMBus Host Notify", 316 }; 317 318 static unsigned int disable_features; 319 module_param(disable_features, uint, S_IRUGO | S_IWUSR); 320 MODULE_PARM_DESC(disable_features, "Disable selected driver features:\n" 321 "\t\t 0x01 disable SMBus PEC\n" 322 "\t\t 0x02 disable the block buffer\n" 323 "\t\t 0x08 disable the I2C block read functionality\n" 324 "\t\t 0x10 don't use interrupts\n" 325 "\t\t 0x20 disable SMBus Host Notify "); 326 327 /* Make sure the SMBus host is ready to start transmitting. 328 Return 0 if it is, -EBUSY if it is not. */ 329 static int i801_check_pre(struct i801_priv *priv) 330 { 331 int status; 332 333 status = inb_p(SMBHSTSTS(priv)); 334 if (status & SMBHSTSTS_HOST_BUSY) { 335 dev_err(&priv->pci_dev->dev, "SMBus is busy, can't use it!\n"); 336 return -EBUSY; 337 } 338 339 status &= STATUS_FLAGS; 340 if (status) { 341 dev_dbg(&priv->pci_dev->dev, "Clearing status flags (%02x)\n", 342 status); 343 outb_p(status, SMBHSTSTS(priv)); 344 status = inb_p(SMBHSTSTS(priv)) & STATUS_FLAGS; 345 if (status) { 346 dev_err(&priv->pci_dev->dev, 347 "Failed clearing status flags (%02x)\n", 348 status); 349 return -EBUSY; 350 } 351 } 352 353 /* 354 * Clear CRC status if needed. 355 * During normal operation, i801_check_post() takes care 356 * of it after every operation. We do it here only in case 357 * the hardware was already in this state when the driver 358 * started. 359 */ 360 if (priv->features & FEATURE_SMBUS_PEC) { 361 status = inb_p(SMBAUXSTS(priv)) & SMBAUXSTS_CRCE; 362 if (status) { 363 dev_dbg(&priv->pci_dev->dev, 364 "Clearing aux status flags (%02x)\n", status); 365 outb_p(status, SMBAUXSTS(priv)); 366 status = inb_p(SMBAUXSTS(priv)) & SMBAUXSTS_CRCE; 367 if (status) { 368 dev_err(&priv->pci_dev->dev, 369 "Failed clearing aux status flags (%02x)\n", 370 status); 371 return -EBUSY; 372 } 373 } 374 } 375 376 return 0; 377 } 378 379 /* 380 * Convert the status register to an error code, and clear it. 381 * Note that status only contains the bits we want to clear, not the 382 * actual register value. 383 */ 384 static int i801_check_post(struct i801_priv *priv, int status) 385 { 386 int result = 0; 387 388 /* 389 * If the SMBus is still busy, we give up 390 * Note: This timeout condition only happens when using polling 391 * transactions. For interrupt operation, NAK/timeout is indicated by 392 * DEV_ERR. 393 */ 394 if (unlikely(status < 0)) { 395 dev_err(&priv->pci_dev->dev, "Transaction timeout\n"); 396 /* try to stop the current command */ 397 dev_dbg(&priv->pci_dev->dev, "Terminating the current operation\n"); 398 outb_p(SMBHSTCNT_KILL, SMBHSTCNT(priv)); 399 usleep_range(1000, 2000); 400 outb_p(0, SMBHSTCNT(priv)); 401 402 /* Check if it worked */ 403 status = inb_p(SMBHSTSTS(priv)); 404 if ((status & SMBHSTSTS_HOST_BUSY) || 405 !(status & SMBHSTSTS_FAILED)) 406 dev_err(&priv->pci_dev->dev, 407 "Failed terminating the transaction\n"); 408 outb_p(STATUS_FLAGS, SMBHSTSTS(priv)); 409 return -ETIMEDOUT; 410 } 411 412 if (status & SMBHSTSTS_FAILED) { 413 result = -EIO; 414 dev_err(&priv->pci_dev->dev, "Transaction failed\n"); 415 } 416 if (status & SMBHSTSTS_DEV_ERR) { 417 /* 418 * This may be a PEC error, check and clear it. 419 * 420 * AUXSTS is handled differently from HSTSTS. 421 * For HSTSTS, i801_isr() or i801_wait_intr() 422 * has already cleared the error bits in hardware, 423 * and we are passed a copy of the original value 424 * in "status". 425 * For AUXSTS, the hardware register is left 426 * for us to handle here. 427 * This is asymmetric, slightly iffy, but safe, 428 * since all this code is serialized and the CRCE 429 * bit is harmless as long as it's cleared before 430 * the next operation. 431 */ 432 if ((priv->features & FEATURE_SMBUS_PEC) && 433 (inb_p(SMBAUXSTS(priv)) & SMBAUXSTS_CRCE)) { 434 outb_p(SMBAUXSTS_CRCE, SMBAUXSTS(priv)); 435 result = -EBADMSG; 436 dev_dbg(&priv->pci_dev->dev, "PEC error\n"); 437 } else { 438 result = -ENXIO; 439 dev_dbg(&priv->pci_dev->dev, "No response\n"); 440 } 441 } 442 if (status & SMBHSTSTS_BUS_ERR) { 443 result = -EAGAIN; 444 dev_dbg(&priv->pci_dev->dev, "Lost arbitration\n"); 445 } 446 447 /* Clear status flags except BYTE_DONE, to be cleared by caller */ 448 outb_p(status, SMBHSTSTS(priv)); 449 450 return result; 451 } 452 453 /* Wait for BUSY being cleared and either INTR or an error flag being set */ 454 static int i801_wait_intr(struct i801_priv *priv) 455 { 456 int timeout = 0; 457 int status; 458 459 /* We will always wait for a fraction of a second! */ 460 do { 461 usleep_range(250, 500); 462 status = inb_p(SMBHSTSTS(priv)); 463 } while (((status & SMBHSTSTS_HOST_BUSY) || 464 !(status & (STATUS_ERROR_FLAGS | SMBHSTSTS_INTR))) && 465 (timeout++ < MAX_RETRIES)); 466 467 if (timeout > MAX_RETRIES) { 468 dev_dbg(&priv->pci_dev->dev, "INTR Timeout!\n"); 469 return -ETIMEDOUT; 470 } 471 return status & (STATUS_ERROR_FLAGS | SMBHSTSTS_INTR); 472 } 473 474 /* Wait for either BYTE_DONE or an error flag being set */ 475 static int i801_wait_byte_done(struct i801_priv *priv) 476 { 477 int timeout = 0; 478 int status; 479 480 /* We will always wait for a fraction of a second! */ 481 do { 482 usleep_range(250, 500); 483 status = inb_p(SMBHSTSTS(priv)); 484 } while (!(status & (STATUS_ERROR_FLAGS | SMBHSTSTS_BYTE_DONE)) && 485 (timeout++ < MAX_RETRIES)); 486 487 if (timeout > MAX_RETRIES) { 488 dev_dbg(&priv->pci_dev->dev, "BYTE_DONE Timeout!\n"); 489 return -ETIMEDOUT; 490 } 491 return status & STATUS_ERROR_FLAGS; 492 } 493 494 static int i801_transaction(struct i801_priv *priv, int xact) 495 { 496 int status; 497 int result; 498 const struct i2c_adapter *adap = &priv->adapter; 499 500 result = i801_check_pre(priv); 501 if (result < 0) 502 return result; 503 504 if (priv->features & FEATURE_IRQ) { 505 outb_p(xact | SMBHSTCNT_INTREN | SMBHSTCNT_START, 506 SMBHSTCNT(priv)); 507 result = wait_event_timeout(priv->waitq, 508 (status = priv->status), 509 adap->timeout); 510 if (!result) { 511 status = -ETIMEDOUT; 512 dev_warn(&priv->pci_dev->dev, 513 "Timeout waiting for interrupt!\n"); 514 } 515 priv->status = 0; 516 return i801_check_post(priv, status); 517 } 518 519 /* the current contents of SMBHSTCNT can be overwritten, since PEC, 520 * SMBSCMD are passed in xact */ 521 outb_p(xact | SMBHSTCNT_START, SMBHSTCNT(priv)); 522 523 status = i801_wait_intr(priv); 524 return i801_check_post(priv, status); 525 } 526 527 static int i801_block_transaction_by_block(struct i801_priv *priv, 528 union i2c_smbus_data *data, 529 char read_write, int command, 530 int hwpec) 531 { 532 int i, len; 533 int status; 534 int xact = hwpec ? SMBHSTCNT_PEC_EN : 0; 535 536 switch (command) { 537 case I2C_SMBUS_BLOCK_PROC_CALL: 538 xact |= I801_BLOCK_PROC_CALL; 539 break; 540 case I2C_SMBUS_BLOCK_DATA: 541 xact |= I801_BLOCK_DATA; 542 break; 543 default: 544 return -EOPNOTSUPP; 545 } 546 547 inb_p(SMBHSTCNT(priv)); /* reset the data buffer index */ 548 549 /* Use 32-byte buffer to process this transaction */ 550 if (read_write == I2C_SMBUS_WRITE) { 551 len = data->block[0]; 552 outb_p(len, SMBHSTDAT0(priv)); 553 for (i = 0; i < len; i++) 554 outb_p(data->block[i+1], SMBBLKDAT(priv)); 555 } 556 557 status = i801_transaction(priv, xact); 558 if (status) 559 return status; 560 561 if (read_write == I2C_SMBUS_READ || 562 command == I2C_SMBUS_BLOCK_PROC_CALL) { 563 len = inb_p(SMBHSTDAT0(priv)); 564 if (len < 1 || len > I2C_SMBUS_BLOCK_MAX) 565 return -EPROTO; 566 567 data->block[0] = len; 568 for (i = 0; i < len; i++) 569 data->block[i + 1] = inb_p(SMBBLKDAT(priv)); 570 } 571 return 0; 572 } 573 574 static void i801_isr_byte_done(struct i801_priv *priv) 575 { 576 if (priv->is_read) { 577 /* For SMBus block reads, length is received with first byte */ 578 if (((priv->cmd & 0x1c) == I801_BLOCK_DATA) && 579 (priv->count == 0)) { 580 priv->len = inb_p(SMBHSTDAT0(priv)); 581 if (priv->len < 1 || priv->len > I2C_SMBUS_BLOCK_MAX) { 582 dev_err(&priv->pci_dev->dev, 583 "Illegal SMBus block read size %d\n", 584 priv->len); 585 /* FIXME: Recover */ 586 priv->len = I2C_SMBUS_BLOCK_MAX; 587 } else { 588 dev_dbg(&priv->pci_dev->dev, 589 "SMBus block read size is %d\n", 590 priv->len); 591 } 592 priv->data[-1] = priv->len; 593 } 594 595 /* Read next byte */ 596 if (priv->count < priv->len) 597 priv->data[priv->count++] = inb(SMBBLKDAT(priv)); 598 else 599 dev_dbg(&priv->pci_dev->dev, 600 "Discarding extra byte on block read\n"); 601 602 /* Set LAST_BYTE for last byte of read transaction */ 603 if (priv->count == priv->len - 1) 604 outb_p(priv->cmd | SMBHSTCNT_LAST_BYTE, 605 SMBHSTCNT(priv)); 606 } else if (priv->count < priv->len - 1) { 607 /* Write next byte, except for IRQ after last byte */ 608 outb_p(priv->data[++priv->count], SMBBLKDAT(priv)); 609 } 610 611 /* Clear BYTE_DONE to continue with next byte */ 612 outb_p(SMBHSTSTS_BYTE_DONE, SMBHSTSTS(priv)); 613 } 614 615 static irqreturn_t i801_host_notify_isr(struct i801_priv *priv) 616 { 617 unsigned short addr; 618 619 addr = inb_p(SMBNTFDADD(priv)) >> 1; 620 621 /* 622 * With the tested platforms, reading SMBNTFDDAT (22 + (p)->smba) 623 * always returns 0. Our current implementation doesn't provide 624 * data, so we just ignore it. 625 */ 626 i2c_handle_smbus_host_notify(&priv->adapter, addr); 627 628 /* clear Host Notify bit and return */ 629 outb_p(SMBSLVSTS_HST_NTFY_STS, SMBSLVSTS(priv)); 630 return IRQ_HANDLED; 631 } 632 633 /* 634 * There are three kinds of interrupts: 635 * 636 * 1) i801 signals transaction completion with one of these interrupts: 637 * INTR - Success 638 * DEV_ERR - Invalid command, NAK or communication timeout 639 * BUS_ERR - SMI# transaction collision 640 * FAILED - transaction was canceled due to a KILL request 641 * When any of these occur, update ->status and wake up the waitq. 642 * ->status must be cleared before kicking off the next transaction. 643 * 644 * 2) For byte-by-byte (I2C read/write) transactions, one BYTE_DONE interrupt 645 * occurs for each byte of a byte-by-byte to prepare the next byte. 646 * 647 * 3) Host Notify interrupts 648 */ 649 static irqreturn_t i801_isr(int irq, void *dev_id) 650 { 651 struct i801_priv *priv = dev_id; 652 u16 pcists; 653 u8 status; 654 655 /* Confirm this is our interrupt */ 656 pci_read_config_word(priv->pci_dev, SMBPCISTS, &pcists); 657 if (!(pcists & SMBPCISTS_INTS)) 658 return IRQ_NONE; 659 660 if (priv->features & FEATURE_HOST_NOTIFY) { 661 status = inb_p(SMBSLVSTS(priv)); 662 if (status & SMBSLVSTS_HST_NTFY_STS) 663 return i801_host_notify_isr(priv); 664 } 665 666 status = inb_p(SMBHSTSTS(priv)); 667 if (status & SMBHSTSTS_BYTE_DONE) 668 i801_isr_byte_done(priv); 669 670 /* 671 * Clear irq sources and report transaction result. 672 * ->status must be cleared before the next transaction is started. 673 */ 674 status &= SMBHSTSTS_INTR | STATUS_ERROR_FLAGS; 675 if (status) { 676 outb_p(status, SMBHSTSTS(priv)); 677 priv->status = status; 678 wake_up(&priv->waitq); 679 } 680 681 return IRQ_HANDLED; 682 } 683 684 /* 685 * For "byte-by-byte" block transactions: 686 * I2C write uses cmd=I801_BLOCK_DATA, I2C_EN=1 687 * I2C read uses cmd=I801_I2C_BLOCK_DATA 688 */ 689 static int i801_block_transaction_byte_by_byte(struct i801_priv *priv, 690 union i2c_smbus_data *data, 691 char read_write, int command, 692 int hwpec) 693 { 694 int i, len; 695 int smbcmd; 696 int status; 697 int result; 698 const struct i2c_adapter *adap = &priv->adapter; 699 700 if (command == I2C_SMBUS_BLOCK_PROC_CALL) 701 return -EOPNOTSUPP; 702 703 result = i801_check_pre(priv); 704 if (result < 0) 705 return result; 706 707 len = data->block[0]; 708 709 if (read_write == I2C_SMBUS_WRITE) { 710 outb_p(len, SMBHSTDAT0(priv)); 711 outb_p(data->block[1], SMBBLKDAT(priv)); 712 } 713 714 if (command == I2C_SMBUS_I2C_BLOCK_DATA && 715 read_write == I2C_SMBUS_READ) 716 smbcmd = I801_I2C_BLOCK_DATA; 717 else 718 smbcmd = I801_BLOCK_DATA; 719 720 if (priv->features & FEATURE_IRQ) { 721 priv->is_read = (read_write == I2C_SMBUS_READ); 722 if (len == 1 && priv->is_read) 723 smbcmd |= SMBHSTCNT_LAST_BYTE; 724 priv->cmd = smbcmd | SMBHSTCNT_INTREN; 725 priv->len = len; 726 priv->count = 0; 727 priv->data = &data->block[1]; 728 729 outb_p(priv->cmd | SMBHSTCNT_START, SMBHSTCNT(priv)); 730 result = wait_event_timeout(priv->waitq, 731 (status = priv->status), 732 adap->timeout); 733 if (!result) { 734 status = -ETIMEDOUT; 735 dev_warn(&priv->pci_dev->dev, 736 "Timeout waiting for interrupt!\n"); 737 } 738 priv->status = 0; 739 return i801_check_post(priv, status); 740 } 741 742 for (i = 1; i <= len; i++) { 743 if (i == len && read_write == I2C_SMBUS_READ) 744 smbcmd |= SMBHSTCNT_LAST_BYTE; 745 outb_p(smbcmd, SMBHSTCNT(priv)); 746 747 if (i == 1) 748 outb_p(inb(SMBHSTCNT(priv)) | SMBHSTCNT_START, 749 SMBHSTCNT(priv)); 750 751 status = i801_wait_byte_done(priv); 752 if (status) 753 goto exit; 754 755 if (i == 1 && read_write == I2C_SMBUS_READ 756 && command != I2C_SMBUS_I2C_BLOCK_DATA) { 757 len = inb_p(SMBHSTDAT0(priv)); 758 if (len < 1 || len > I2C_SMBUS_BLOCK_MAX) { 759 dev_err(&priv->pci_dev->dev, 760 "Illegal SMBus block read size %d\n", 761 len); 762 /* Recover */ 763 while (inb_p(SMBHSTSTS(priv)) & 764 SMBHSTSTS_HOST_BUSY) 765 outb_p(SMBHSTSTS_BYTE_DONE, 766 SMBHSTSTS(priv)); 767 outb_p(SMBHSTSTS_INTR, SMBHSTSTS(priv)); 768 return -EPROTO; 769 } 770 data->block[0] = len; 771 } 772 773 /* Retrieve/store value in SMBBLKDAT */ 774 if (read_write == I2C_SMBUS_READ) 775 data->block[i] = inb_p(SMBBLKDAT(priv)); 776 if (read_write == I2C_SMBUS_WRITE && i+1 <= len) 777 outb_p(data->block[i+1], SMBBLKDAT(priv)); 778 779 /* signals SMBBLKDAT ready */ 780 outb_p(SMBHSTSTS_BYTE_DONE, SMBHSTSTS(priv)); 781 } 782 783 status = i801_wait_intr(priv); 784 exit: 785 return i801_check_post(priv, status); 786 } 787 788 static int i801_set_block_buffer_mode(struct i801_priv *priv) 789 { 790 outb_p(inb_p(SMBAUXCTL(priv)) | SMBAUXCTL_E32B, SMBAUXCTL(priv)); 791 if ((inb_p(SMBAUXCTL(priv)) & SMBAUXCTL_E32B) == 0) 792 return -EIO; 793 return 0; 794 } 795 796 /* Block transaction function */ 797 static int i801_block_transaction(struct i801_priv *priv, 798 union i2c_smbus_data *data, char read_write, 799 int command, int hwpec) 800 { 801 int result = 0; 802 unsigned char hostc; 803 804 if (command == I2C_SMBUS_I2C_BLOCK_DATA) { 805 if (read_write == I2C_SMBUS_WRITE) { 806 /* set I2C_EN bit in configuration register */ 807 pci_read_config_byte(priv->pci_dev, SMBHSTCFG, &hostc); 808 pci_write_config_byte(priv->pci_dev, SMBHSTCFG, 809 hostc | SMBHSTCFG_I2C_EN); 810 } else if (!(priv->features & FEATURE_I2C_BLOCK_READ)) { 811 dev_err(&priv->pci_dev->dev, 812 "I2C block read is unsupported!\n"); 813 return -EOPNOTSUPP; 814 } 815 } 816 817 if (read_write == I2C_SMBUS_WRITE 818 || command == I2C_SMBUS_I2C_BLOCK_DATA) { 819 if (data->block[0] < 1) 820 data->block[0] = 1; 821 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) 822 data->block[0] = I2C_SMBUS_BLOCK_MAX; 823 } else { 824 data->block[0] = 32; /* max for SMBus block reads */ 825 } 826 827 /* Experience has shown that the block buffer can only be used for 828 SMBus (not I2C) block transactions, even though the datasheet 829 doesn't mention this limitation. */ 830 if ((priv->features & FEATURE_BLOCK_BUFFER) 831 && command != I2C_SMBUS_I2C_BLOCK_DATA 832 && i801_set_block_buffer_mode(priv) == 0) 833 result = i801_block_transaction_by_block(priv, data, 834 read_write, 835 command, hwpec); 836 else 837 result = i801_block_transaction_byte_by_byte(priv, data, 838 read_write, 839 command, hwpec); 840 841 if (command == I2C_SMBUS_I2C_BLOCK_DATA 842 && read_write == I2C_SMBUS_WRITE) { 843 /* restore saved configuration register value */ 844 pci_write_config_byte(priv->pci_dev, SMBHSTCFG, hostc); 845 } 846 return result; 847 } 848 849 /* Return negative errno on error. */ 850 static s32 i801_access(struct i2c_adapter *adap, u16 addr, 851 unsigned short flags, char read_write, u8 command, 852 int size, union i2c_smbus_data *data) 853 { 854 int hwpec; 855 int block = 0; 856 int ret = 0, xact = 0; 857 struct i801_priv *priv = i2c_get_adapdata(adap); 858 859 mutex_lock(&priv->acpi_lock); 860 if (priv->acpi_reserved) { 861 mutex_unlock(&priv->acpi_lock); 862 return -EBUSY; 863 } 864 865 pm_runtime_get_sync(&priv->pci_dev->dev); 866 867 hwpec = (priv->features & FEATURE_SMBUS_PEC) && (flags & I2C_CLIENT_PEC) 868 && size != I2C_SMBUS_QUICK 869 && size != I2C_SMBUS_I2C_BLOCK_DATA; 870 871 switch (size) { 872 case I2C_SMBUS_QUICK: 873 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01), 874 SMBHSTADD(priv)); 875 xact = I801_QUICK; 876 break; 877 case I2C_SMBUS_BYTE: 878 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01), 879 SMBHSTADD(priv)); 880 if (read_write == I2C_SMBUS_WRITE) 881 outb_p(command, SMBHSTCMD(priv)); 882 xact = I801_BYTE; 883 break; 884 case I2C_SMBUS_BYTE_DATA: 885 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01), 886 SMBHSTADD(priv)); 887 outb_p(command, SMBHSTCMD(priv)); 888 if (read_write == I2C_SMBUS_WRITE) 889 outb_p(data->byte, SMBHSTDAT0(priv)); 890 xact = I801_BYTE_DATA; 891 break; 892 case I2C_SMBUS_WORD_DATA: 893 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01), 894 SMBHSTADD(priv)); 895 outb_p(command, SMBHSTCMD(priv)); 896 if (read_write == I2C_SMBUS_WRITE) { 897 outb_p(data->word & 0xff, SMBHSTDAT0(priv)); 898 outb_p((data->word & 0xff00) >> 8, SMBHSTDAT1(priv)); 899 } 900 xact = I801_WORD_DATA; 901 break; 902 case I2C_SMBUS_BLOCK_DATA: 903 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01), 904 SMBHSTADD(priv)); 905 outb_p(command, SMBHSTCMD(priv)); 906 block = 1; 907 break; 908 case I2C_SMBUS_I2C_BLOCK_DATA: 909 /* 910 * NB: page 240 of ICH5 datasheet shows that the R/#W 911 * bit should be cleared here, even when reading. 912 * However if SPD Write Disable is set (Lynx Point and later), 913 * the read will fail if we don't set the R/#W bit. 914 */ 915 outb_p(((addr & 0x7f) << 1) | 916 ((priv->original_hstcfg & SMBHSTCFG_SPD_WD) ? 917 (read_write & 0x01) : 0), 918 SMBHSTADD(priv)); 919 if (read_write == I2C_SMBUS_READ) { 920 /* NB: page 240 of ICH5 datasheet also shows 921 * that DATA1 is the cmd field when reading */ 922 outb_p(command, SMBHSTDAT1(priv)); 923 } else 924 outb_p(command, SMBHSTCMD(priv)); 925 block = 1; 926 break; 927 case I2C_SMBUS_BLOCK_PROC_CALL: 928 /* 929 * Bit 0 of the slave address register always indicate a write 930 * command. 931 */ 932 outb_p((addr & 0x7f) << 1, SMBHSTADD(priv)); 933 outb_p(command, SMBHSTCMD(priv)); 934 block = 1; 935 break; 936 default: 937 dev_err(&priv->pci_dev->dev, "Unsupported transaction %d\n", 938 size); 939 ret = -EOPNOTSUPP; 940 goto out; 941 } 942 943 if (hwpec) /* enable/disable hardware PEC */ 944 outb_p(inb_p(SMBAUXCTL(priv)) | SMBAUXCTL_CRC, SMBAUXCTL(priv)); 945 else 946 outb_p(inb_p(SMBAUXCTL(priv)) & (~SMBAUXCTL_CRC), 947 SMBAUXCTL(priv)); 948 949 if (block) 950 ret = i801_block_transaction(priv, data, read_write, size, 951 hwpec); 952 else 953 ret = i801_transaction(priv, xact); 954 955 /* Some BIOSes don't like it when PEC is enabled at reboot or resume 956 time, so we forcibly disable it after every transaction. Turn off 957 E32B for the same reason. */ 958 if (hwpec || block) 959 outb_p(inb_p(SMBAUXCTL(priv)) & 960 ~(SMBAUXCTL_CRC | SMBAUXCTL_E32B), SMBAUXCTL(priv)); 961 962 if (block) 963 goto out; 964 if (ret) 965 goto out; 966 if ((read_write == I2C_SMBUS_WRITE) || (xact == I801_QUICK)) 967 goto out; 968 969 switch (xact & 0x7f) { 970 case I801_BYTE: /* Result put in SMBHSTDAT0 */ 971 case I801_BYTE_DATA: 972 data->byte = inb_p(SMBHSTDAT0(priv)); 973 break; 974 case I801_WORD_DATA: 975 data->word = inb_p(SMBHSTDAT0(priv)) + 976 (inb_p(SMBHSTDAT1(priv)) << 8); 977 break; 978 } 979 980 out: 981 /* Unlock the SMBus device for use by BIOS/ACPI */ 982 outb_p(SMBHSTSTS_INUSE_STS, SMBHSTSTS(priv)); 983 984 pm_runtime_mark_last_busy(&priv->pci_dev->dev); 985 pm_runtime_put_autosuspend(&priv->pci_dev->dev); 986 mutex_unlock(&priv->acpi_lock); 987 return ret; 988 } 989 990 991 static u32 i801_func(struct i2c_adapter *adapter) 992 { 993 struct i801_priv *priv = i2c_get_adapdata(adapter); 994 995 return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE | 996 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA | 997 I2C_FUNC_SMBUS_BLOCK_DATA | I2C_FUNC_SMBUS_WRITE_I2C_BLOCK | 998 ((priv->features & FEATURE_SMBUS_PEC) ? I2C_FUNC_SMBUS_PEC : 0) | 999 ((priv->features & FEATURE_BLOCK_PROC) ? 1000 I2C_FUNC_SMBUS_BLOCK_PROC_CALL : 0) | 1001 ((priv->features & FEATURE_I2C_BLOCK_READ) ? 1002 I2C_FUNC_SMBUS_READ_I2C_BLOCK : 0) | 1003 ((priv->features & FEATURE_HOST_NOTIFY) ? 1004 I2C_FUNC_SMBUS_HOST_NOTIFY : 0); 1005 } 1006 1007 static void i801_enable_host_notify(struct i2c_adapter *adapter) 1008 { 1009 struct i801_priv *priv = i2c_get_adapdata(adapter); 1010 1011 if (!(priv->features & FEATURE_HOST_NOTIFY)) 1012 return; 1013 1014 if (!(SMBSLVCMD_HST_NTFY_INTREN & priv->original_slvcmd)) 1015 outb_p(SMBSLVCMD_HST_NTFY_INTREN | priv->original_slvcmd, 1016 SMBSLVCMD(priv)); 1017 1018 /* clear Host Notify bit to allow a new notification */ 1019 outb_p(SMBSLVSTS_HST_NTFY_STS, SMBSLVSTS(priv)); 1020 } 1021 1022 static void i801_disable_host_notify(struct i801_priv *priv) 1023 { 1024 if (!(priv->features & FEATURE_HOST_NOTIFY)) 1025 return; 1026 1027 outb_p(priv->original_slvcmd, SMBSLVCMD(priv)); 1028 } 1029 1030 static const struct i2c_algorithm smbus_algorithm = { 1031 .smbus_xfer = i801_access, 1032 .functionality = i801_func, 1033 }; 1034 1035 static const struct pci_device_id i801_ids[] = { 1036 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801AA_3) }, 1037 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801AB_3) }, 1038 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801BA_2) }, 1039 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801CA_3) }, 1040 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_3) }, 1041 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801EB_3) }, 1042 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ESB_4) }, 1043 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_16) }, 1044 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH7_17) }, 1045 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ESB2_17) }, 1046 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH8_5) }, 1047 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH9_6) }, 1048 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_EP80579_1) }, 1049 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH10_4) }, 1050 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH10_5) }, 1051 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_5_3400_SERIES_SMBUS) }, 1052 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_COUGARPOINT_SMBUS) }, 1053 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS) }, 1054 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS_IDF0) }, 1055 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS_IDF1) }, 1056 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS_IDF2) }, 1057 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_DH89XXCC_SMBUS) }, 1058 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_PANTHERPOINT_SMBUS) }, 1059 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_LYNXPOINT_SMBUS) }, 1060 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_LYNXPOINT_LP_SMBUS) }, 1061 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_AVOTON_SMBUS) }, 1062 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_WELLSBURG_SMBUS) }, 1063 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_WELLSBURG_SMBUS_MS0) }, 1064 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_WELLSBURG_SMBUS_MS1) }, 1065 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_WELLSBURG_SMBUS_MS2) }, 1066 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_COLETOCREEK_SMBUS) }, 1067 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_GEMINILAKE_SMBUS) }, 1068 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_WILDCATPOINT_SMBUS) }, 1069 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_WILDCATPOINT_LP_SMBUS) }, 1070 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_BAYTRAIL_SMBUS) }, 1071 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_BRASWELL_SMBUS) }, 1072 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_SUNRISEPOINT_H_SMBUS) }, 1073 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_SUNRISEPOINT_LP_SMBUS) }, 1074 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_CDF_SMBUS) }, 1075 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_DNV_SMBUS) }, 1076 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_EBG_SMBUS) }, 1077 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_BROXTON_SMBUS) }, 1078 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_LEWISBURG_SMBUS) }, 1079 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_LEWISBURG_SSKU_SMBUS) }, 1080 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_KABYLAKE_PCH_H_SMBUS) }, 1081 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_CANNONLAKE_H_SMBUS) }, 1082 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_CANNONLAKE_LP_SMBUS) }, 1083 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICELAKE_LP_SMBUS) }, 1084 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_COMETLAKE_SMBUS) }, 1085 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_COMETLAKE_H_SMBUS) }, 1086 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_COMETLAKE_V_SMBUS) }, 1087 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ELKHART_LAKE_SMBUS) }, 1088 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_TIGERLAKE_LP_SMBUS) }, 1089 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_TIGERLAKE_H_SMBUS) }, 1090 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_JASPER_LAKE_SMBUS) }, 1091 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ALDER_LAKE_S_SMBUS) }, 1092 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ALDER_LAKE_P_SMBUS) }, 1093 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ALDER_LAKE_M_SMBUS) }, 1094 { 0, } 1095 }; 1096 1097 MODULE_DEVICE_TABLE(pci, i801_ids); 1098 1099 #if defined CONFIG_X86 && defined CONFIG_DMI 1100 static unsigned char apanel_addr; 1101 1102 /* Scan the system ROM for the signature "FJKEYINF" */ 1103 static __init const void __iomem *bios_signature(const void __iomem *bios) 1104 { 1105 ssize_t offset; 1106 const unsigned char signature[] = "FJKEYINF"; 1107 1108 for (offset = 0; offset < 0x10000; offset += 0x10) { 1109 if (check_signature(bios + offset, signature, 1110 sizeof(signature)-1)) 1111 return bios + offset; 1112 } 1113 return NULL; 1114 } 1115 1116 static void __init input_apanel_init(void) 1117 { 1118 void __iomem *bios; 1119 const void __iomem *p; 1120 1121 bios = ioremap(0xF0000, 0x10000); /* Can't fail */ 1122 p = bios_signature(bios); 1123 if (p) { 1124 /* just use the first address */ 1125 apanel_addr = readb(p + 8 + 3) >> 1; 1126 } 1127 iounmap(bios); 1128 } 1129 1130 struct dmi_onboard_device_info { 1131 const char *name; 1132 u8 type; 1133 unsigned short i2c_addr; 1134 const char *i2c_type; 1135 }; 1136 1137 static const struct dmi_onboard_device_info dmi_devices[] = { 1138 { "Syleus", DMI_DEV_TYPE_OTHER, 0x73, "fscsyl" }, 1139 { "Hermes", DMI_DEV_TYPE_OTHER, 0x73, "fscher" }, 1140 { "Hades", DMI_DEV_TYPE_OTHER, 0x73, "fschds" }, 1141 }; 1142 1143 static void dmi_check_onboard_device(u8 type, const char *name, 1144 struct i2c_adapter *adap) 1145 { 1146 int i; 1147 struct i2c_board_info info; 1148 1149 for (i = 0; i < ARRAY_SIZE(dmi_devices); i++) { 1150 /* & ~0x80, ignore enabled/disabled bit */ 1151 if ((type & ~0x80) != dmi_devices[i].type) 1152 continue; 1153 if (strcasecmp(name, dmi_devices[i].name)) 1154 continue; 1155 1156 memset(&info, 0, sizeof(struct i2c_board_info)); 1157 info.addr = dmi_devices[i].i2c_addr; 1158 strlcpy(info.type, dmi_devices[i].i2c_type, I2C_NAME_SIZE); 1159 i2c_new_client_device(adap, &info); 1160 break; 1161 } 1162 } 1163 1164 /* We use our own function to check for onboard devices instead of 1165 dmi_find_device() as some buggy BIOS's have the devices we are interested 1166 in marked as disabled */ 1167 static void dmi_check_onboard_devices(const struct dmi_header *dm, void *adap) 1168 { 1169 int i, count; 1170 1171 if (dm->type != 10) 1172 return; 1173 1174 count = (dm->length - sizeof(struct dmi_header)) / 2; 1175 for (i = 0; i < count; i++) { 1176 const u8 *d = (char *)(dm + 1) + (i * 2); 1177 const char *name = ((char *) dm) + dm->length; 1178 u8 type = d[0]; 1179 u8 s = d[1]; 1180 1181 if (!s) 1182 continue; 1183 s--; 1184 while (s > 0 && name[0]) { 1185 name += strlen(name) + 1; 1186 s--; 1187 } 1188 if (name[0] == 0) /* Bogus string reference */ 1189 continue; 1190 1191 dmi_check_onboard_device(type, name, adap); 1192 } 1193 } 1194 1195 /* NOTE: Keep this list in sync with drivers/platform/x86/dell-smo8800.c */ 1196 static const char *const acpi_smo8800_ids[] = { 1197 "SMO8800", 1198 "SMO8801", 1199 "SMO8810", 1200 "SMO8811", 1201 "SMO8820", 1202 "SMO8821", 1203 "SMO8830", 1204 "SMO8831", 1205 }; 1206 1207 static acpi_status check_acpi_smo88xx_device(acpi_handle obj_handle, 1208 u32 nesting_level, 1209 void *context, 1210 void **return_value) 1211 { 1212 struct acpi_device_info *info; 1213 acpi_status status; 1214 char *hid; 1215 int i; 1216 1217 status = acpi_get_object_info(obj_handle, &info); 1218 if (ACPI_FAILURE(status)) 1219 return AE_OK; 1220 1221 if (!(info->valid & ACPI_VALID_HID)) 1222 goto smo88xx_not_found; 1223 1224 hid = info->hardware_id.string; 1225 if (!hid) 1226 goto smo88xx_not_found; 1227 1228 i = match_string(acpi_smo8800_ids, ARRAY_SIZE(acpi_smo8800_ids), hid); 1229 if (i < 0) 1230 goto smo88xx_not_found; 1231 1232 kfree(info); 1233 1234 *((bool *)return_value) = true; 1235 return AE_CTRL_TERMINATE; 1236 1237 smo88xx_not_found: 1238 kfree(info); 1239 return AE_OK; 1240 } 1241 1242 static bool is_dell_system_with_lis3lv02d(void) 1243 { 1244 bool found; 1245 const char *vendor; 1246 1247 vendor = dmi_get_system_info(DMI_SYS_VENDOR); 1248 if (!vendor || strcmp(vendor, "Dell Inc.")) 1249 return false; 1250 1251 /* 1252 * Check that ACPI device SMO88xx is present and is functioning. 1253 * Function acpi_get_devices() already filters all ACPI devices 1254 * which are not present or are not functioning. 1255 * ACPI device SMO88xx represents our ST microelectronics lis3lv02d 1256 * accelerometer but unfortunately ACPI does not provide any other 1257 * information (like I2C address). 1258 */ 1259 found = false; 1260 acpi_get_devices(NULL, check_acpi_smo88xx_device, NULL, 1261 (void **)&found); 1262 1263 return found; 1264 } 1265 1266 /* 1267 * Accelerometer's I2C address is not specified in DMI nor ACPI, 1268 * so it is needed to define mapping table based on DMI product names. 1269 */ 1270 static const struct { 1271 const char *dmi_product_name; 1272 unsigned short i2c_addr; 1273 } dell_lis3lv02d_devices[] = { 1274 /* 1275 * Dell platform team told us that these Latitude devices have 1276 * ST microelectronics accelerometer at I2C address 0x29. 1277 */ 1278 { "Latitude E5250", 0x29 }, 1279 { "Latitude E5450", 0x29 }, 1280 { "Latitude E5550", 0x29 }, 1281 { "Latitude E6440", 0x29 }, 1282 { "Latitude E6440 ATG", 0x29 }, 1283 { "Latitude E6540", 0x29 }, 1284 /* 1285 * Additional individual entries were added after verification. 1286 */ 1287 { "Latitude 5480", 0x29 }, 1288 { "Vostro V131", 0x1d }, 1289 }; 1290 1291 static void register_dell_lis3lv02d_i2c_device(struct i801_priv *priv) 1292 { 1293 struct i2c_board_info info; 1294 const char *dmi_product_name; 1295 int i; 1296 1297 dmi_product_name = dmi_get_system_info(DMI_PRODUCT_NAME); 1298 for (i = 0; i < ARRAY_SIZE(dell_lis3lv02d_devices); ++i) { 1299 if (strcmp(dmi_product_name, 1300 dell_lis3lv02d_devices[i].dmi_product_name) == 0) 1301 break; 1302 } 1303 1304 if (i == ARRAY_SIZE(dell_lis3lv02d_devices)) { 1305 dev_warn(&priv->pci_dev->dev, 1306 "Accelerometer lis3lv02d is present on SMBus but its" 1307 " address is unknown, skipping registration\n"); 1308 return; 1309 } 1310 1311 memset(&info, 0, sizeof(struct i2c_board_info)); 1312 info.addr = dell_lis3lv02d_devices[i].i2c_addr; 1313 strlcpy(info.type, "lis3lv02d", I2C_NAME_SIZE); 1314 i2c_new_client_device(&priv->adapter, &info); 1315 } 1316 1317 /* Register optional slaves */ 1318 static void i801_probe_optional_slaves(struct i801_priv *priv) 1319 { 1320 /* Only register slaves on main SMBus channel */ 1321 if (priv->features & FEATURE_IDF) 1322 return; 1323 1324 if (apanel_addr) { 1325 struct i2c_board_info info; 1326 1327 memset(&info, 0, sizeof(struct i2c_board_info)); 1328 info.addr = apanel_addr; 1329 strlcpy(info.type, "fujitsu_apanel", I2C_NAME_SIZE); 1330 i2c_new_client_device(&priv->adapter, &info); 1331 } 1332 1333 if (dmi_name_in_vendors("FUJITSU")) 1334 dmi_walk(dmi_check_onboard_devices, &priv->adapter); 1335 1336 if (is_dell_system_with_lis3lv02d()) 1337 register_dell_lis3lv02d_i2c_device(priv); 1338 1339 /* Instantiate SPD EEPROMs unless the SMBus is multiplexed */ 1340 #if IS_ENABLED(CONFIG_I2C_MUX_GPIO) 1341 if (!priv->mux_drvdata) 1342 #endif 1343 i2c_register_spd(&priv->adapter); 1344 } 1345 #else 1346 static void __init input_apanel_init(void) {} 1347 static void i801_probe_optional_slaves(struct i801_priv *priv) {} 1348 #endif /* CONFIG_X86 && CONFIG_DMI */ 1349 1350 #if IS_ENABLED(CONFIG_I2C_MUX_GPIO) && defined CONFIG_DMI 1351 static struct i801_mux_config i801_mux_config_asus_z8_d12 = { 1352 .gpio_chip = "gpio_ich", 1353 .values = { 0x02, 0x03 }, 1354 .n_values = 2, 1355 .classes = { I2C_CLASS_SPD, I2C_CLASS_SPD }, 1356 .gpios = { 52, 53 }, 1357 .n_gpios = 2, 1358 }; 1359 1360 static struct i801_mux_config i801_mux_config_asus_z8_d18 = { 1361 .gpio_chip = "gpio_ich", 1362 .values = { 0x02, 0x03, 0x01 }, 1363 .n_values = 3, 1364 .classes = { I2C_CLASS_SPD, I2C_CLASS_SPD, I2C_CLASS_SPD }, 1365 .gpios = { 52, 53 }, 1366 .n_gpios = 2, 1367 }; 1368 1369 static const struct dmi_system_id mux_dmi_table[] = { 1370 { 1371 .matches = { 1372 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."), 1373 DMI_MATCH(DMI_BOARD_NAME, "Z8NA-D6(C)"), 1374 }, 1375 .driver_data = &i801_mux_config_asus_z8_d12, 1376 }, 1377 { 1378 .matches = { 1379 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."), 1380 DMI_MATCH(DMI_BOARD_NAME, "Z8P(N)E-D12(X)"), 1381 }, 1382 .driver_data = &i801_mux_config_asus_z8_d12, 1383 }, 1384 { 1385 .matches = { 1386 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."), 1387 DMI_MATCH(DMI_BOARD_NAME, "Z8NH-D12"), 1388 }, 1389 .driver_data = &i801_mux_config_asus_z8_d12, 1390 }, 1391 { 1392 .matches = { 1393 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."), 1394 DMI_MATCH(DMI_BOARD_NAME, "Z8PH-D12/IFB"), 1395 }, 1396 .driver_data = &i801_mux_config_asus_z8_d12, 1397 }, 1398 { 1399 .matches = { 1400 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."), 1401 DMI_MATCH(DMI_BOARD_NAME, "Z8NR-D12"), 1402 }, 1403 .driver_data = &i801_mux_config_asus_z8_d12, 1404 }, 1405 { 1406 .matches = { 1407 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."), 1408 DMI_MATCH(DMI_BOARD_NAME, "Z8P(N)H-D12"), 1409 }, 1410 .driver_data = &i801_mux_config_asus_z8_d12, 1411 }, 1412 { 1413 .matches = { 1414 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."), 1415 DMI_MATCH(DMI_BOARD_NAME, "Z8PG-D18"), 1416 }, 1417 .driver_data = &i801_mux_config_asus_z8_d18, 1418 }, 1419 { 1420 .matches = { 1421 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."), 1422 DMI_MATCH(DMI_BOARD_NAME, "Z8PE-D18"), 1423 }, 1424 .driver_data = &i801_mux_config_asus_z8_d18, 1425 }, 1426 { 1427 .matches = { 1428 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."), 1429 DMI_MATCH(DMI_BOARD_NAME, "Z8PS-D12"), 1430 }, 1431 .driver_data = &i801_mux_config_asus_z8_d12, 1432 }, 1433 { } 1434 }; 1435 1436 /* Setup multiplexing if needed */ 1437 static int i801_add_mux(struct i801_priv *priv) 1438 { 1439 struct device *dev = &priv->adapter.dev; 1440 const struct i801_mux_config *mux_config; 1441 struct i2c_mux_gpio_platform_data gpio_data; 1442 struct gpiod_lookup_table *lookup; 1443 int i; 1444 1445 if (!priv->mux_drvdata) 1446 return 0; 1447 mux_config = priv->mux_drvdata; 1448 1449 /* Prepare the platform data */ 1450 memset(&gpio_data, 0, sizeof(struct i2c_mux_gpio_platform_data)); 1451 gpio_data.parent = priv->adapter.nr; 1452 gpio_data.values = mux_config->values; 1453 gpio_data.n_values = mux_config->n_values; 1454 gpio_data.classes = mux_config->classes; 1455 gpio_data.idle = I2C_MUX_GPIO_NO_IDLE; 1456 1457 /* Register GPIO descriptor lookup table */ 1458 lookup = devm_kzalloc(dev, 1459 struct_size(lookup, table, mux_config->n_gpios + 1), 1460 GFP_KERNEL); 1461 if (!lookup) 1462 return -ENOMEM; 1463 lookup->dev_id = "i2c-mux-gpio"; 1464 for (i = 0; i < mux_config->n_gpios; i++) { 1465 lookup->table[i] = (struct gpiod_lookup) 1466 GPIO_LOOKUP(mux_config->gpio_chip, 1467 mux_config->gpios[i], "mux", 0); 1468 } 1469 gpiod_add_lookup_table(lookup); 1470 priv->lookup = lookup; 1471 1472 /* 1473 * Register the mux device, we use PLATFORM_DEVID_NONE here 1474 * because since we are referring to the GPIO chip by name we are 1475 * anyways in deep trouble if there is more than one of these 1476 * devices, and there should likely only be one platform controller 1477 * hub. 1478 */ 1479 priv->mux_pdev = platform_device_register_data(dev, "i2c-mux-gpio", 1480 PLATFORM_DEVID_NONE, &gpio_data, 1481 sizeof(struct i2c_mux_gpio_platform_data)); 1482 if (IS_ERR(priv->mux_pdev)) { 1483 gpiod_remove_lookup_table(lookup); 1484 dev_err(dev, "Failed to register i2c-mux-gpio device\n"); 1485 } 1486 1487 return PTR_ERR_OR_ZERO(priv->mux_pdev); 1488 } 1489 1490 static void i801_del_mux(struct i801_priv *priv) 1491 { 1492 platform_device_unregister(priv->mux_pdev); 1493 gpiod_remove_lookup_table(priv->lookup); 1494 } 1495 1496 static unsigned int i801_get_adapter_class(struct i801_priv *priv) 1497 { 1498 const struct dmi_system_id *id; 1499 const struct i801_mux_config *mux_config; 1500 unsigned int class = I2C_CLASS_HWMON | I2C_CLASS_SPD; 1501 int i; 1502 1503 id = dmi_first_match(mux_dmi_table); 1504 if (id) { 1505 /* Remove branch classes from trunk */ 1506 mux_config = id->driver_data; 1507 for (i = 0; i < mux_config->n_values; i++) 1508 class &= ~mux_config->classes[i]; 1509 1510 /* Remember for later */ 1511 priv->mux_drvdata = mux_config; 1512 } 1513 1514 return class; 1515 } 1516 #else 1517 static inline int i801_add_mux(struct i801_priv *priv) { return 0; } 1518 static inline void i801_del_mux(struct i801_priv *priv) { } 1519 1520 static inline unsigned int i801_get_adapter_class(struct i801_priv *priv) 1521 { 1522 return I2C_CLASS_HWMON | I2C_CLASS_SPD; 1523 } 1524 #endif 1525 1526 static const struct itco_wdt_platform_data spt_tco_platform_data = { 1527 .name = "Intel PCH", 1528 .version = 4, 1529 }; 1530 1531 static DEFINE_SPINLOCK(p2sb_spinlock); 1532 1533 static struct platform_device * 1534 i801_add_tco_spt(struct i801_priv *priv, struct pci_dev *pci_dev, 1535 struct resource *tco_res) 1536 { 1537 struct resource *res; 1538 unsigned int devfn; 1539 u64 base64_addr; 1540 u32 base_addr; 1541 u8 hidden; 1542 1543 /* 1544 * We must access the NO_REBOOT bit over the Primary to Sideband 1545 * bridge (P2SB). The BIOS prevents the P2SB device from being 1546 * enumerated by the PCI subsystem, so we need to unhide/hide it 1547 * to lookup the P2SB BAR. 1548 */ 1549 spin_lock(&p2sb_spinlock); 1550 1551 devfn = PCI_DEVFN(PCI_SLOT(pci_dev->devfn), 1); 1552 1553 /* Unhide the P2SB device, if it is hidden */ 1554 pci_bus_read_config_byte(pci_dev->bus, devfn, 0xe1, &hidden); 1555 if (hidden) 1556 pci_bus_write_config_byte(pci_dev->bus, devfn, 0xe1, 0x0); 1557 1558 pci_bus_read_config_dword(pci_dev->bus, devfn, SBREG_BAR, &base_addr); 1559 base64_addr = base_addr & 0xfffffff0; 1560 1561 pci_bus_read_config_dword(pci_dev->bus, devfn, SBREG_BAR + 0x4, &base_addr); 1562 base64_addr |= (u64)base_addr << 32; 1563 1564 /* Hide the P2SB device, if it was hidden before */ 1565 if (hidden) 1566 pci_bus_write_config_byte(pci_dev->bus, devfn, 0xe1, hidden); 1567 spin_unlock(&p2sb_spinlock); 1568 1569 res = &tco_res[1]; 1570 if (pci_dev->device == PCI_DEVICE_ID_INTEL_DNV_SMBUS) 1571 res->start = (resource_size_t)base64_addr + SBREG_SMBCTRL_DNV; 1572 else 1573 res->start = (resource_size_t)base64_addr + SBREG_SMBCTRL; 1574 1575 res->end = res->start + 3; 1576 res->flags = IORESOURCE_MEM; 1577 1578 return platform_device_register_resndata(&pci_dev->dev, "iTCO_wdt", -1, 1579 tco_res, 2, &spt_tco_platform_data, 1580 sizeof(spt_tco_platform_data)); 1581 } 1582 1583 static const struct itco_wdt_platform_data cnl_tco_platform_data = { 1584 .name = "Intel PCH", 1585 .version = 6, 1586 }; 1587 1588 static struct platform_device * 1589 i801_add_tco_cnl(struct i801_priv *priv, struct pci_dev *pci_dev, 1590 struct resource *tco_res) 1591 { 1592 return platform_device_register_resndata(&pci_dev->dev, 1593 "iTCO_wdt", -1, tco_res, 1, &cnl_tco_platform_data, 1594 sizeof(cnl_tco_platform_data)); 1595 } 1596 1597 static void i801_add_tco(struct i801_priv *priv) 1598 { 1599 struct pci_dev *pci_dev = priv->pci_dev; 1600 struct resource tco_res[2], *res; 1601 u32 tco_base, tco_ctl; 1602 1603 /* If we have ACPI based watchdog use that instead */ 1604 if (acpi_has_watchdog()) 1605 return; 1606 1607 if (!(priv->features & (FEATURE_TCO_SPT | FEATURE_TCO_CNL))) 1608 return; 1609 1610 pci_read_config_dword(pci_dev, TCOBASE, &tco_base); 1611 pci_read_config_dword(pci_dev, TCOCTL, &tco_ctl); 1612 if (!(tco_ctl & TCOCTL_EN)) 1613 return; 1614 1615 memset(tco_res, 0, sizeof(tco_res)); 1616 /* 1617 * Always populate the main iTCO IO resource here. The second entry 1618 * for NO_REBOOT MMIO is filled by the SPT specific function. 1619 */ 1620 res = &tco_res[0]; 1621 res->start = tco_base & ~1; 1622 res->end = res->start + 32 - 1; 1623 res->flags = IORESOURCE_IO; 1624 1625 if (priv->features & FEATURE_TCO_CNL) 1626 priv->tco_pdev = i801_add_tco_cnl(priv, pci_dev, tco_res); 1627 else 1628 priv->tco_pdev = i801_add_tco_spt(priv, pci_dev, tco_res); 1629 1630 if (IS_ERR(priv->tco_pdev)) 1631 dev_warn(&pci_dev->dev, "failed to create iTCO device\n"); 1632 } 1633 1634 #ifdef CONFIG_ACPI 1635 static bool i801_acpi_is_smbus_ioport(const struct i801_priv *priv, 1636 acpi_physical_address address) 1637 { 1638 return address >= priv->smba && 1639 address <= pci_resource_end(priv->pci_dev, SMBBAR); 1640 } 1641 1642 static acpi_status 1643 i801_acpi_io_handler(u32 function, acpi_physical_address address, u32 bits, 1644 u64 *value, void *handler_context, void *region_context) 1645 { 1646 struct i801_priv *priv = handler_context; 1647 struct pci_dev *pdev = priv->pci_dev; 1648 acpi_status status; 1649 1650 /* 1651 * Once BIOS AML code touches the OpRegion we warn and inhibit any 1652 * further access from the driver itself. This device is now owned 1653 * by the system firmware. 1654 */ 1655 mutex_lock(&priv->acpi_lock); 1656 1657 if (!priv->acpi_reserved && i801_acpi_is_smbus_ioport(priv, address)) { 1658 priv->acpi_reserved = true; 1659 1660 dev_warn(&pdev->dev, "BIOS is accessing SMBus registers\n"); 1661 dev_warn(&pdev->dev, "Driver SMBus register access inhibited\n"); 1662 1663 /* 1664 * BIOS is accessing the host controller so prevent it from 1665 * suspending automatically from now on. 1666 */ 1667 pm_runtime_get_sync(&pdev->dev); 1668 } 1669 1670 if ((function & ACPI_IO_MASK) == ACPI_READ) 1671 status = acpi_os_read_port(address, (u32 *)value, bits); 1672 else 1673 status = acpi_os_write_port(address, (u32)*value, bits); 1674 1675 mutex_unlock(&priv->acpi_lock); 1676 1677 return status; 1678 } 1679 1680 static int i801_acpi_probe(struct i801_priv *priv) 1681 { 1682 struct acpi_device *adev; 1683 acpi_status status; 1684 1685 adev = ACPI_COMPANION(&priv->pci_dev->dev); 1686 if (adev) { 1687 status = acpi_install_address_space_handler(adev->handle, 1688 ACPI_ADR_SPACE_SYSTEM_IO, i801_acpi_io_handler, 1689 NULL, priv); 1690 if (ACPI_SUCCESS(status)) 1691 return 0; 1692 } 1693 1694 return acpi_check_resource_conflict(&priv->pci_dev->resource[SMBBAR]); 1695 } 1696 1697 static void i801_acpi_remove(struct i801_priv *priv) 1698 { 1699 struct acpi_device *adev; 1700 1701 adev = ACPI_COMPANION(&priv->pci_dev->dev); 1702 if (!adev) 1703 return; 1704 1705 acpi_remove_address_space_handler(adev->handle, 1706 ACPI_ADR_SPACE_SYSTEM_IO, i801_acpi_io_handler); 1707 1708 mutex_lock(&priv->acpi_lock); 1709 if (priv->acpi_reserved) 1710 pm_runtime_put(&priv->pci_dev->dev); 1711 mutex_unlock(&priv->acpi_lock); 1712 } 1713 #else 1714 static inline int i801_acpi_probe(struct i801_priv *priv) { return 0; } 1715 static inline void i801_acpi_remove(struct i801_priv *priv) { } 1716 #endif 1717 1718 static unsigned char i801_setup_hstcfg(struct i801_priv *priv) 1719 { 1720 unsigned char hstcfg = priv->original_hstcfg; 1721 1722 hstcfg &= ~SMBHSTCFG_I2C_EN; /* SMBus timing */ 1723 hstcfg |= SMBHSTCFG_HST_EN; 1724 pci_write_config_byte(priv->pci_dev, SMBHSTCFG, hstcfg); 1725 return hstcfg; 1726 } 1727 1728 static int i801_probe(struct pci_dev *dev, const struct pci_device_id *id) 1729 { 1730 unsigned char temp; 1731 int err, i; 1732 struct i801_priv *priv; 1733 1734 priv = devm_kzalloc(&dev->dev, sizeof(*priv), GFP_KERNEL); 1735 if (!priv) 1736 return -ENOMEM; 1737 1738 i2c_set_adapdata(&priv->adapter, priv); 1739 priv->adapter.owner = THIS_MODULE; 1740 priv->adapter.class = i801_get_adapter_class(priv); 1741 priv->adapter.algo = &smbus_algorithm; 1742 priv->adapter.dev.parent = &dev->dev; 1743 ACPI_COMPANION_SET(&priv->adapter.dev, ACPI_COMPANION(&dev->dev)); 1744 priv->adapter.retries = 3; 1745 mutex_init(&priv->acpi_lock); 1746 1747 priv->pci_dev = dev; 1748 switch (dev->device) { 1749 case PCI_DEVICE_ID_INTEL_SUNRISEPOINT_H_SMBUS: 1750 case PCI_DEVICE_ID_INTEL_SUNRISEPOINT_LP_SMBUS: 1751 case PCI_DEVICE_ID_INTEL_LEWISBURG_SMBUS: 1752 case PCI_DEVICE_ID_INTEL_LEWISBURG_SSKU_SMBUS: 1753 case PCI_DEVICE_ID_INTEL_DNV_SMBUS: 1754 case PCI_DEVICE_ID_INTEL_KABYLAKE_PCH_H_SMBUS: 1755 case PCI_DEVICE_ID_INTEL_COMETLAKE_V_SMBUS: 1756 priv->features |= FEATURE_BLOCK_PROC; 1757 priv->features |= FEATURE_I2C_BLOCK_READ; 1758 priv->features |= FEATURE_IRQ; 1759 priv->features |= FEATURE_SMBUS_PEC; 1760 priv->features |= FEATURE_BLOCK_BUFFER; 1761 priv->features |= FEATURE_TCO_SPT; 1762 priv->features |= FEATURE_HOST_NOTIFY; 1763 break; 1764 1765 case PCI_DEVICE_ID_INTEL_CANNONLAKE_H_SMBUS: 1766 case PCI_DEVICE_ID_INTEL_CANNONLAKE_LP_SMBUS: 1767 case PCI_DEVICE_ID_INTEL_CDF_SMBUS: 1768 case PCI_DEVICE_ID_INTEL_ICELAKE_LP_SMBUS: 1769 case PCI_DEVICE_ID_INTEL_COMETLAKE_SMBUS: 1770 case PCI_DEVICE_ID_INTEL_COMETLAKE_H_SMBUS: 1771 case PCI_DEVICE_ID_INTEL_ELKHART_LAKE_SMBUS: 1772 case PCI_DEVICE_ID_INTEL_TIGERLAKE_LP_SMBUS: 1773 case PCI_DEVICE_ID_INTEL_TIGERLAKE_H_SMBUS: 1774 case PCI_DEVICE_ID_INTEL_JASPER_LAKE_SMBUS: 1775 case PCI_DEVICE_ID_INTEL_EBG_SMBUS: 1776 case PCI_DEVICE_ID_INTEL_ALDER_LAKE_S_SMBUS: 1777 case PCI_DEVICE_ID_INTEL_ALDER_LAKE_P_SMBUS: 1778 case PCI_DEVICE_ID_INTEL_ALDER_LAKE_M_SMBUS: 1779 priv->features |= FEATURE_BLOCK_PROC; 1780 priv->features |= FEATURE_I2C_BLOCK_READ; 1781 priv->features |= FEATURE_IRQ; 1782 priv->features |= FEATURE_SMBUS_PEC; 1783 priv->features |= FEATURE_BLOCK_BUFFER; 1784 priv->features |= FEATURE_TCO_CNL; 1785 priv->features |= FEATURE_HOST_NOTIFY; 1786 break; 1787 1788 case PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS_IDF0: 1789 case PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS_IDF1: 1790 case PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS_IDF2: 1791 case PCI_DEVICE_ID_INTEL_WELLSBURG_SMBUS_MS0: 1792 case PCI_DEVICE_ID_INTEL_WELLSBURG_SMBUS_MS1: 1793 case PCI_DEVICE_ID_INTEL_WELLSBURG_SMBUS_MS2: 1794 priv->features |= FEATURE_IDF; 1795 fallthrough; 1796 default: 1797 priv->features |= FEATURE_BLOCK_PROC; 1798 priv->features |= FEATURE_I2C_BLOCK_READ; 1799 priv->features |= FEATURE_IRQ; 1800 fallthrough; 1801 case PCI_DEVICE_ID_INTEL_82801DB_3: 1802 priv->features |= FEATURE_SMBUS_PEC; 1803 priv->features |= FEATURE_BLOCK_BUFFER; 1804 fallthrough; 1805 case PCI_DEVICE_ID_INTEL_82801CA_3: 1806 priv->features |= FEATURE_HOST_NOTIFY; 1807 fallthrough; 1808 case PCI_DEVICE_ID_INTEL_82801BA_2: 1809 case PCI_DEVICE_ID_INTEL_82801AB_3: 1810 case PCI_DEVICE_ID_INTEL_82801AA_3: 1811 break; 1812 } 1813 1814 /* Disable features on user request */ 1815 for (i = 0; i < ARRAY_SIZE(i801_feature_names); i++) { 1816 if (priv->features & disable_features & (1 << i)) 1817 dev_notice(&dev->dev, "%s disabled by user\n", 1818 i801_feature_names[i]); 1819 } 1820 priv->features &= ~disable_features; 1821 1822 err = pcim_enable_device(dev); 1823 if (err) { 1824 dev_err(&dev->dev, "Failed to enable SMBus PCI device (%d)\n", 1825 err); 1826 return err; 1827 } 1828 pcim_pin_device(dev); 1829 1830 /* Determine the address of the SMBus area */ 1831 priv->smba = pci_resource_start(dev, SMBBAR); 1832 if (!priv->smba) { 1833 dev_err(&dev->dev, 1834 "SMBus base address uninitialized, upgrade BIOS\n"); 1835 return -ENODEV; 1836 } 1837 1838 if (i801_acpi_probe(priv)) 1839 return -ENODEV; 1840 1841 err = pcim_iomap_regions(dev, 1 << SMBBAR, 1842 dev_driver_string(&dev->dev)); 1843 if (err) { 1844 dev_err(&dev->dev, 1845 "Failed to request SMBus region 0x%lx-0x%Lx\n", 1846 priv->smba, 1847 (unsigned long long)pci_resource_end(dev, SMBBAR)); 1848 i801_acpi_remove(priv); 1849 return err; 1850 } 1851 1852 pci_read_config_byte(priv->pci_dev, SMBHSTCFG, &priv->original_hstcfg); 1853 temp = i801_setup_hstcfg(priv); 1854 if (!(priv->original_hstcfg & SMBHSTCFG_HST_EN)) 1855 dev_info(&dev->dev, "Enabling SMBus device\n"); 1856 1857 if (temp & SMBHSTCFG_SMB_SMI_EN) { 1858 dev_dbg(&dev->dev, "SMBus using interrupt SMI#\n"); 1859 /* Disable SMBus interrupt feature if SMBus using SMI# */ 1860 priv->features &= ~FEATURE_IRQ; 1861 } 1862 if (temp & SMBHSTCFG_SPD_WD) 1863 dev_info(&dev->dev, "SPD Write Disable is set\n"); 1864 1865 /* Clear special mode bits */ 1866 if (priv->features & (FEATURE_SMBUS_PEC | FEATURE_BLOCK_BUFFER)) 1867 outb_p(inb_p(SMBAUXCTL(priv)) & 1868 ~(SMBAUXCTL_CRC | SMBAUXCTL_E32B), SMBAUXCTL(priv)); 1869 1870 /* Remember original Host Notify setting */ 1871 if (priv->features & FEATURE_HOST_NOTIFY) 1872 priv->original_slvcmd = inb_p(SMBSLVCMD(priv)); 1873 1874 /* Default timeout in interrupt mode: 200 ms */ 1875 priv->adapter.timeout = HZ / 5; 1876 1877 if (dev->irq == IRQ_NOTCONNECTED) 1878 priv->features &= ~FEATURE_IRQ; 1879 1880 if (priv->features & FEATURE_IRQ) { 1881 u16 pcictl, pcists; 1882 1883 /* Complain if an interrupt is already pending */ 1884 pci_read_config_word(priv->pci_dev, SMBPCISTS, &pcists); 1885 if (pcists & SMBPCISTS_INTS) 1886 dev_warn(&dev->dev, "An interrupt is pending!\n"); 1887 1888 /* Check if interrupts have been disabled */ 1889 pci_read_config_word(priv->pci_dev, SMBPCICTL, &pcictl); 1890 if (pcictl & SMBPCICTL_INTDIS) { 1891 dev_info(&dev->dev, "Interrupts are disabled\n"); 1892 priv->features &= ~FEATURE_IRQ; 1893 } 1894 } 1895 1896 if (priv->features & FEATURE_IRQ) { 1897 init_waitqueue_head(&priv->waitq); 1898 1899 err = devm_request_irq(&dev->dev, dev->irq, i801_isr, 1900 IRQF_SHARED, 1901 dev_driver_string(&dev->dev), priv); 1902 if (err) { 1903 dev_err(&dev->dev, "Failed to allocate irq %d: %d\n", 1904 dev->irq, err); 1905 priv->features &= ~FEATURE_IRQ; 1906 } 1907 } 1908 dev_info(&dev->dev, "SMBus using %s\n", 1909 priv->features & FEATURE_IRQ ? "PCI interrupt" : "polling"); 1910 1911 i801_add_tco(priv); 1912 1913 snprintf(priv->adapter.name, sizeof(priv->adapter.name), 1914 "SMBus I801 adapter at %04lx", priv->smba); 1915 err = i2c_add_adapter(&priv->adapter); 1916 if (err) { 1917 i801_acpi_remove(priv); 1918 return err; 1919 } 1920 1921 i801_enable_host_notify(&priv->adapter); 1922 1923 i801_probe_optional_slaves(priv); 1924 /* We ignore errors - multiplexing is optional */ 1925 i801_add_mux(priv); 1926 1927 pci_set_drvdata(dev, priv); 1928 1929 dev_pm_set_driver_flags(&dev->dev, DPM_FLAG_NO_DIRECT_COMPLETE); 1930 pm_runtime_set_autosuspend_delay(&dev->dev, 1000); 1931 pm_runtime_use_autosuspend(&dev->dev); 1932 pm_runtime_put_autosuspend(&dev->dev); 1933 pm_runtime_allow(&dev->dev); 1934 1935 return 0; 1936 } 1937 1938 static void i801_remove(struct pci_dev *dev) 1939 { 1940 struct i801_priv *priv = pci_get_drvdata(dev); 1941 1942 pm_runtime_forbid(&dev->dev); 1943 pm_runtime_get_noresume(&dev->dev); 1944 1945 i801_disable_host_notify(priv); 1946 i801_del_mux(priv); 1947 i2c_del_adapter(&priv->adapter); 1948 i801_acpi_remove(priv); 1949 pci_write_config_byte(dev, SMBHSTCFG, priv->original_hstcfg); 1950 1951 platform_device_unregister(priv->tco_pdev); 1952 1953 /* 1954 * do not call pci_disable_device(dev) since it can cause hard hangs on 1955 * some systems during power-off (eg. Fujitsu-Siemens Lifebook E8010) 1956 */ 1957 } 1958 1959 static void i801_shutdown(struct pci_dev *dev) 1960 { 1961 struct i801_priv *priv = pci_get_drvdata(dev); 1962 1963 /* Restore config registers to avoid hard hang on some systems */ 1964 i801_disable_host_notify(priv); 1965 pci_write_config_byte(dev, SMBHSTCFG, priv->original_hstcfg); 1966 } 1967 1968 #ifdef CONFIG_PM_SLEEP 1969 static int i801_suspend(struct device *dev) 1970 { 1971 struct i801_priv *priv = dev_get_drvdata(dev); 1972 1973 pci_write_config_byte(priv->pci_dev, SMBHSTCFG, priv->original_hstcfg); 1974 return 0; 1975 } 1976 1977 static int i801_resume(struct device *dev) 1978 { 1979 struct i801_priv *priv = dev_get_drvdata(dev); 1980 1981 i801_setup_hstcfg(priv); 1982 i801_enable_host_notify(&priv->adapter); 1983 1984 return 0; 1985 } 1986 #endif 1987 1988 static SIMPLE_DEV_PM_OPS(i801_pm_ops, i801_suspend, i801_resume); 1989 1990 static struct pci_driver i801_driver = { 1991 .name = "i801_smbus", 1992 .id_table = i801_ids, 1993 .probe = i801_probe, 1994 .remove = i801_remove, 1995 .shutdown = i801_shutdown, 1996 .driver = { 1997 .pm = &i801_pm_ops, 1998 }, 1999 }; 2000 2001 static int __init i2c_i801_init(void) 2002 { 2003 if (dmi_name_in_vendors("FUJITSU")) 2004 input_apanel_init(); 2005 return pci_register_driver(&i801_driver); 2006 } 2007 2008 static void __exit i2c_i801_exit(void) 2009 { 2010 pci_unregister_driver(&i801_driver); 2011 } 2012 2013 MODULE_AUTHOR("Mark D. Studebaker <mdsxyz123@yahoo.com>"); 2014 MODULE_AUTHOR("Jean Delvare <jdelvare@suse.de>"); 2015 MODULE_DESCRIPTION("I801 SMBus driver"); 2016 MODULE_LICENSE("GPL"); 2017 2018 module_init(i2c_i801_init); 2019 module_exit(i2c_i801_exit); 2020