drivers/i2c/busses/i2c-i801.c

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