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