2 Copyright (c) 1998 - 2002 Frodo Looijaard <frodol@dds.nl>,
3 Philip Edelbrock <phil@netroedge.com>, and Mark D. Studebaker
5 Copyright (C) 2007 - 2012 Jean Delvare <khali@linux-fr.org>
6 Copyright (C) 2010 Intel Corporation,
7 David Woodhouse <dwmw2@infradead.org>
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 Supports the following Intel I/O Controller Hubs (ICH):
28 region SMBus Block proc. block
29 Chip name PCI ID size PEC buffer call read
30 ----------------------------------------------------------------------
31 82801AA (ICH) 0x2413 16 no no no no
32 82801AB (ICH0) 0x2423 16 no no no no
33 82801BA (ICH2) 0x2443 16 no no no no
34 82801CA (ICH3) 0x2483 32 soft no no no
35 82801DB (ICH4) 0x24c3 32 hard yes no no
36 82801E (ICH5) 0x24d3 32 hard yes yes yes
37 6300ESB 0x25a4 32 hard yes yes yes
38 82801F (ICH6) 0x266a 32 hard yes yes yes
39 6310ESB/6320ESB 0x269b 32 hard yes yes yes
40 82801G (ICH7) 0x27da 32 hard yes yes yes
41 82801H (ICH8) 0x283e 32 hard yes yes yes
42 82801I (ICH9) 0x2930 32 hard yes yes yes
43 EP80579 (Tolapai) 0x5032 32 hard yes yes yes
44 ICH10 0x3a30 32 hard yes yes yes
45 ICH10 0x3a60 32 hard yes yes yes
46 5/3400 Series (PCH) 0x3b30 32 hard yes yes yes
47 6 Series (PCH) 0x1c22 32 hard yes yes yes
48 Patsburg (PCH) 0x1d22 32 hard yes yes yes
49 Patsburg (PCH) IDF 0x1d70 32 hard yes yes yes
50 Patsburg (PCH) IDF 0x1d71 32 hard yes yes yes
51 Patsburg (PCH) IDF 0x1d72 32 hard yes yes yes
52 DH89xxCC (PCH) 0x2330 32 hard yes yes yes
53 Panther Point (PCH) 0x1e22 32 hard yes yes yes
54 Lynx Point (PCH) 0x8c22 32 hard yes yes yes
56 Features supported by this driver:
60 Block process call transaction no
61 I2C block read transaction yes (doesn't use the block buffer)
64 See the file Documentation/i2c/busses/i2c-i801 for details.
67 #include <linux/module.h>
68 #include <linux/pci.h>
69 #include <linux/kernel.h>
70 #include <linux/stddef.h>
71 #include <linux/delay.h>
72 #include <linux/ioport.h>
73 #include <linux/init.h>
74 #include <linux/i2c.h>
75 #include <linux/acpi.h>
77 #include <linux/dmi.h>
78 #include <linux/slab.h>
80 /* I801 SMBus address offsets */
81 #define SMBHSTSTS(p) (0 + (p)->smba)
82 #define SMBHSTCNT(p) (2 + (p)->smba)
83 #define SMBHSTCMD(p) (3 + (p)->smba)
84 #define SMBHSTADD(p) (4 + (p)->smba)
85 #define SMBHSTDAT0(p) (5 + (p)->smba)
86 #define SMBHSTDAT1(p) (6 + (p)->smba)
87 #define SMBBLKDAT(p) (7 + (p)->smba)
88 #define SMBPEC(p) (8 + (p)->smba) /* ICH3 and later */
89 #define SMBAUXSTS(p) (12 + (p)->smba) /* ICH4 and later */
90 #define SMBAUXCTL(p) (13 + (p)->smba) /* ICH4 and later */
92 /* PCI Address Constants */
94 #define SMBHSTCFG 0x040
96 /* Host configuration bits for SMBHSTCFG */
97 #define SMBHSTCFG_HST_EN 1
98 #define SMBHSTCFG_SMB_SMI_EN 2
99 #define SMBHSTCFG_I2C_EN 4
101 /* Auxiliary control register bits, ICH4+ only */
102 #define SMBAUXCTL_CRC 1
103 #define SMBAUXCTL_E32B 2
105 /* kill bit for SMBHSTCNT */
106 #define SMBHSTCNT_KILL 2
109 #define MAX_RETRIES 400
110 #define ENABLE_INT9 0 /* set to 0x01 to enable - untested */
112 /* I801 command constants */
113 #define I801_QUICK 0x00
114 #define I801_BYTE 0x04
115 #define I801_BYTE_DATA 0x08
116 #define I801_WORD_DATA 0x0C
117 #define I801_PROC_CALL 0x10 /* unimplemented */
118 #define I801_BLOCK_DATA 0x14
119 #define I801_I2C_BLOCK_DATA 0x18 /* ICH5 and later */
120 #define I801_BLOCK_LAST 0x34
121 #define I801_I2C_BLOCK_LAST 0x38 /* ICH5 and later */
122 #define I801_START 0x40
123 #define I801_PEC_EN 0x80 /* ICH3 and later */
125 /* I801 Hosts Status register bits */
126 #define SMBHSTSTS_BYTE_DONE 0x80
127 #define SMBHSTSTS_INUSE_STS 0x40
128 #define SMBHSTSTS_SMBALERT_STS 0x20
129 #define SMBHSTSTS_FAILED 0x10
130 #define SMBHSTSTS_BUS_ERR 0x08
131 #define SMBHSTSTS_DEV_ERR 0x04
132 #define SMBHSTSTS_INTR 0x02
133 #define SMBHSTSTS_HOST_BUSY 0x01
135 #define STATUS_FLAGS (SMBHSTSTS_BYTE_DONE | SMBHSTSTS_FAILED | \
136 SMBHSTSTS_BUS_ERR | SMBHSTSTS_DEV_ERR | \
139 /* Older devices have their ID defined in <linux/pci_ids.h> */
140 #define PCI_DEVICE_ID_INTEL_COUGARPOINT_SMBUS 0x1c22
141 #define PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS 0x1d22
142 /* Patsburg also has three 'Integrated Device Function' SMBus controllers */
143 #define PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS_IDF0 0x1d70
144 #define PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS_IDF1 0x1d71
145 #define PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS_IDF2 0x1d72
146 #define PCI_DEVICE_ID_INTEL_PANTHERPOINT_SMBUS 0x1e22
147 #define PCI_DEVICE_ID_INTEL_DH89XXCC_SMBUS 0x2330
148 #define PCI_DEVICE_ID_INTEL_5_3400_SERIES_SMBUS 0x3b30
149 #define PCI_DEVICE_ID_INTEL_LYNXPOINT_SMBUS 0x8c22
152 struct i2c_adapter adapter
;
154 unsigned char original_hstcfg
;
155 struct pci_dev
*pci_dev
;
156 unsigned int features
;
159 static struct pci_driver i801_driver
;
161 #define FEATURE_SMBUS_PEC (1 << 0)
162 #define FEATURE_BLOCK_BUFFER (1 << 1)
163 #define FEATURE_BLOCK_PROC (1 << 2)
164 #define FEATURE_I2C_BLOCK_READ (1 << 3)
165 /* Not really a feature, but it's convenient to handle it as such */
166 #define FEATURE_IDF (1 << 15)
168 static const char *i801_feature_names
[] = {
171 "Block process call",
175 static unsigned int disable_features
;
176 module_param(disable_features
, uint
, S_IRUGO
| S_IWUSR
);
177 MODULE_PARM_DESC(disable_features
, "Disable selected driver features");
179 /* Make sure the SMBus host is ready to start transmitting.
180 Return 0 if it is, -EBUSY if it is not. */
181 static int i801_check_pre(struct i801_priv
*priv
)
185 status
= inb_p(SMBHSTSTS(priv
));
186 if (status
& SMBHSTSTS_HOST_BUSY
) {
187 dev_err(&priv
->pci_dev
->dev
, "SMBus is busy, can't use it!\n");
191 status
&= STATUS_FLAGS
;
193 dev_dbg(&priv
->pci_dev
->dev
, "Clearing status flags (%02x)\n",
195 outb_p(status
, SMBHSTSTS(priv
));
196 status
= inb_p(SMBHSTSTS(priv
)) & STATUS_FLAGS
;
198 dev_err(&priv
->pci_dev
->dev
,
199 "Failed clearing status flags (%02x)\n",
208 /* Convert the status register to an error code, and clear it. */
209 static int i801_check_post(struct i801_priv
*priv
, int status
, int timeout
)
213 /* If the SMBus is still busy, we give up */
215 dev_err(&priv
->pci_dev
->dev
, "Transaction timeout\n");
216 /* try to stop the current command */
217 dev_dbg(&priv
->pci_dev
->dev
, "Terminating the current operation\n");
218 outb_p(inb_p(SMBHSTCNT(priv
)) | SMBHSTCNT_KILL
,
220 usleep_range(1000, 2000);
221 outb_p(inb_p(SMBHSTCNT(priv
)) & (~SMBHSTCNT_KILL
),
224 /* Check if it worked */
225 status
= inb_p(SMBHSTSTS(priv
));
226 if ((status
& SMBHSTSTS_HOST_BUSY
) ||
227 !(status
& SMBHSTSTS_FAILED
))
228 dev_err(&priv
->pci_dev
->dev
,
229 "Failed terminating the transaction\n");
230 outb_p(STATUS_FLAGS
, SMBHSTSTS(priv
));
234 if (status
& SMBHSTSTS_FAILED
) {
236 dev_err(&priv
->pci_dev
->dev
, "Transaction failed\n");
238 if (status
& SMBHSTSTS_DEV_ERR
) {
240 dev_dbg(&priv
->pci_dev
->dev
, "No response\n");
242 if (status
& SMBHSTSTS_BUS_ERR
) {
244 dev_dbg(&priv
->pci_dev
->dev
, "Lost arbitration\n");
248 /* Clear error flags */
249 outb_p(status
& STATUS_FLAGS
, SMBHSTSTS(priv
));
250 status
= inb_p(SMBHSTSTS(priv
)) & STATUS_FLAGS
;
252 dev_warn(&priv
->pci_dev
->dev
, "Failed clearing status "
253 "flags at end of transaction (%02x)\n",
261 static int i801_transaction(struct i801_priv
*priv
, int xact
)
267 result
= i801_check_pre(priv
);
271 /* the current contents of SMBHSTCNT can be overwritten, since PEC,
272 * INTREN, SMBSCMD are passed in xact */
273 outb_p(xact
| I801_START
, SMBHSTCNT(priv
));
275 /* We will always wait for a fraction of a second! */
277 usleep_range(250, 500);
278 status
= inb_p(SMBHSTSTS(priv
));
279 } while ((status
& SMBHSTSTS_HOST_BUSY
) && (timeout
++ < MAX_RETRIES
));
281 result
= i801_check_post(priv
, status
, timeout
> MAX_RETRIES
);
285 outb_p(SMBHSTSTS_INTR
, SMBHSTSTS(priv
));
289 /* wait for INTR bit as advised by Intel */
290 static void i801_wait_hwpec(struct i801_priv
*priv
)
296 usleep_range(250, 500);
297 status
= inb_p(SMBHSTSTS(priv
));
298 } while ((!(status
& SMBHSTSTS_INTR
))
299 && (timeout
++ < MAX_RETRIES
));
301 if (timeout
> MAX_RETRIES
)
302 dev_dbg(&priv
->pci_dev
->dev
, "PEC Timeout!\n");
304 outb_p(status
, SMBHSTSTS(priv
));
307 static int i801_block_transaction_by_block(struct i801_priv
*priv
,
308 union i2c_smbus_data
*data
,
309 char read_write
, int hwpec
)
314 inb_p(SMBHSTCNT(priv
)); /* reset the data buffer index */
316 /* Use 32-byte buffer to process this transaction */
317 if (read_write
== I2C_SMBUS_WRITE
) {
318 len
= data
->block
[0];
319 outb_p(len
, SMBHSTDAT0(priv
));
320 for (i
= 0; i
< len
; i
++)
321 outb_p(data
->block
[i
+1], SMBBLKDAT(priv
));
324 status
= i801_transaction(priv
, I801_BLOCK_DATA
| ENABLE_INT9
|
325 I801_PEC_EN
* hwpec
);
329 if (read_write
== I2C_SMBUS_READ
) {
330 len
= inb_p(SMBHSTDAT0(priv
));
331 if (len
< 1 || len
> I2C_SMBUS_BLOCK_MAX
)
334 data
->block
[0] = len
;
335 for (i
= 0; i
< len
; i
++)
336 data
->block
[i
+ 1] = inb_p(SMBBLKDAT(priv
));
341 static int i801_block_transaction_byte_by_byte(struct i801_priv
*priv
,
342 union i2c_smbus_data
*data
,
343 char read_write
, int command
,
352 result
= i801_check_pre(priv
);
356 len
= data
->block
[0];
358 if (read_write
== I2C_SMBUS_WRITE
) {
359 outb_p(len
, SMBHSTDAT0(priv
));
360 outb_p(data
->block
[1], SMBBLKDAT(priv
));
363 for (i
= 1; i
<= len
; i
++) {
364 if (i
== len
&& read_write
== I2C_SMBUS_READ
) {
365 if (command
== I2C_SMBUS_I2C_BLOCK_DATA
)
366 smbcmd
= I801_I2C_BLOCK_LAST
;
368 smbcmd
= I801_BLOCK_LAST
;
370 if (command
== I2C_SMBUS_I2C_BLOCK_DATA
371 && read_write
== I2C_SMBUS_READ
)
372 smbcmd
= I801_I2C_BLOCK_DATA
;
374 smbcmd
= I801_BLOCK_DATA
;
376 outb_p(smbcmd
| ENABLE_INT9
, SMBHSTCNT(priv
));
379 outb_p(inb(SMBHSTCNT(priv
)) | I801_START
,
382 /* We will always wait for a fraction of a second! */
385 usleep_range(250, 500);
386 status
= inb_p(SMBHSTSTS(priv
));
387 } while ((!(status
& SMBHSTSTS_BYTE_DONE
))
388 && (timeout
++ < MAX_RETRIES
));
390 result
= i801_check_post(priv
, status
, timeout
> MAX_RETRIES
);
394 if (i
== 1 && read_write
== I2C_SMBUS_READ
395 && command
!= I2C_SMBUS_I2C_BLOCK_DATA
) {
396 len
= inb_p(SMBHSTDAT0(priv
));
397 if (len
< 1 || len
> I2C_SMBUS_BLOCK_MAX
) {
398 dev_err(&priv
->pci_dev
->dev
,
399 "Illegal SMBus block read size %d\n",
402 while (inb_p(SMBHSTSTS(priv
)) &
404 outb_p(SMBHSTSTS_BYTE_DONE
,
406 outb_p(SMBHSTSTS_INTR
, SMBHSTSTS(priv
));
409 data
->block
[0] = len
;
412 /* Retrieve/store value in SMBBLKDAT */
413 if (read_write
== I2C_SMBUS_READ
)
414 data
->block
[i
] = inb_p(SMBBLKDAT(priv
));
415 if (read_write
== I2C_SMBUS_WRITE
&& i
+1 <= len
)
416 outb_p(data
->block
[i
+1], SMBBLKDAT(priv
));
418 /* signals SMBBLKDAT ready */
419 outb_p(SMBHSTSTS_BYTE_DONE
| SMBHSTSTS_INTR
, SMBHSTSTS(priv
));
425 static int i801_set_block_buffer_mode(struct i801_priv
*priv
)
427 outb_p(inb_p(SMBAUXCTL(priv
)) | SMBAUXCTL_E32B
, SMBAUXCTL(priv
));
428 if ((inb_p(SMBAUXCTL(priv
)) & SMBAUXCTL_E32B
) == 0)
433 /* Block transaction function */
434 static int i801_block_transaction(struct i801_priv
*priv
,
435 union i2c_smbus_data
*data
, char read_write
,
436 int command
, int hwpec
)
441 if (command
== I2C_SMBUS_I2C_BLOCK_DATA
) {
442 if (read_write
== I2C_SMBUS_WRITE
) {
443 /* set I2C_EN bit in configuration register */
444 pci_read_config_byte(priv
->pci_dev
, SMBHSTCFG
, &hostc
);
445 pci_write_config_byte(priv
->pci_dev
, SMBHSTCFG
,
446 hostc
| SMBHSTCFG_I2C_EN
);
447 } else if (!(priv
->features
& FEATURE_I2C_BLOCK_READ
)) {
448 dev_err(&priv
->pci_dev
->dev
,
449 "I2C block read is unsupported!\n");
454 if (read_write
== I2C_SMBUS_WRITE
455 || command
== I2C_SMBUS_I2C_BLOCK_DATA
) {
456 if (data
->block
[0] < 1)
458 if (data
->block
[0] > I2C_SMBUS_BLOCK_MAX
)
459 data
->block
[0] = I2C_SMBUS_BLOCK_MAX
;
461 data
->block
[0] = 32; /* max for SMBus block reads */
464 /* Experience has shown that the block buffer can only be used for
465 SMBus (not I2C) block transactions, even though the datasheet
466 doesn't mention this limitation. */
467 if ((priv
->features
& FEATURE_BLOCK_BUFFER
)
468 && command
!= I2C_SMBUS_I2C_BLOCK_DATA
469 && i801_set_block_buffer_mode(priv
) == 0)
470 result
= i801_block_transaction_by_block(priv
, data
,
473 result
= i801_block_transaction_byte_by_byte(priv
, data
,
477 if (result
== 0 && hwpec
)
478 i801_wait_hwpec(priv
);
480 if (command
== I2C_SMBUS_I2C_BLOCK_DATA
481 && read_write
== I2C_SMBUS_WRITE
) {
482 /* restore saved configuration register value */
483 pci_write_config_byte(priv
->pci_dev
, SMBHSTCFG
, hostc
);
488 /* Return negative errno on error. */
489 static s32
i801_access(struct i2c_adapter
*adap
, u16 addr
,
490 unsigned short flags
, char read_write
, u8 command
,
491 int size
, union i2c_smbus_data
*data
)
496 struct i801_priv
*priv
= i2c_get_adapdata(adap
);
498 hwpec
= (priv
->features
& FEATURE_SMBUS_PEC
) && (flags
& I2C_CLIENT_PEC
)
499 && size
!= I2C_SMBUS_QUICK
500 && size
!= I2C_SMBUS_I2C_BLOCK_DATA
;
503 case I2C_SMBUS_QUICK
:
504 outb_p(((addr
& 0x7f) << 1) | (read_write
& 0x01),
509 outb_p(((addr
& 0x7f) << 1) | (read_write
& 0x01),
511 if (read_write
== I2C_SMBUS_WRITE
)
512 outb_p(command
, SMBHSTCMD(priv
));
515 case I2C_SMBUS_BYTE_DATA
:
516 outb_p(((addr
& 0x7f) << 1) | (read_write
& 0x01),
518 outb_p(command
, SMBHSTCMD(priv
));
519 if (read_write
== I2C_SMBUS_WRITE
)
520 outb_p(data
->byte
, SMBHSTDAT0(priv
));
521 xact
= I801_BYTE_DATA
;
523 case I2C_SMBUS_WORD_DATA
:
524 outb_p(((addr
& 0x7f) << 1) | (read_write
& 0x01),
526 outb_p(command
, SMBHSTCMD(priv
));
527 if (read_write
== I2C_SMBUS_WRITE
) {
528 outb_p(data
->word
& 0xff, SMBHSTDAT0(priv
));
529 outb_p((data
->word
& 0xff00) >> 8, SMBHSTDAT1(priv
));
531 xact
= I801_WORD_DATA
;
533 case I2C_SMBUS_BLOCK_DATA
:
534 outb_p(((addr
& 0x7f) << 1) | (read_write
& 0x01),
536 outb_p(command
, SMBHSTCMD(priv
));
539 case I2C_SMBUS_I2C_BLOCK_DATA
:
540 /* NB: page 240 of ICH5 datasheet shows that the R/#W
541 * bit should be cleared here, even when reading */
542 outb_p((addr
& 0x7f) << 1, SMBHSTADD(priv
));
543 if (read_write
== I2C_SMBUS_READ
) {
544 /* NB: page 240 of ICH5 datasheet also shows
545 * that DATA1 is the cmd field when reading */
546 outb_p(command
, SMBHSTDAT1(priv
));
548 outb_p(command
, SMBHSTCMD(priv
));
552 dev_err(&priv
->pci_dev
->dev
, "Unsupported transaction %d\n",
557 if (hwpec
) /* enable/disable hardware PEC */
558 outb_p(inb_p(SMBAUXCTL(priv
)) | SMBAUXCTL_CRC
, SMBAUXCTL(priv
));
560 outb_p(inb_p(SMBAUXCTL(priv
)) & (~SMBAUXCTL_CRC
),
564 ret
= i801_block_transaction(priv
, data
, read_write
, size
,
567 ret
= i801_transaction(priv
, xact
| ENABLE_INT9
);
569 /* Some BIOSes don't like it when PEC is enabled at reboot or resume
570 time, so we forcibly disable it after every transaction. Turn off
571 E32B for the same reason. */
573 outb_p(inb_p(SMBAUXCTL(priv
)) &
574 ~(SMBAUXCTL_CRC
| SMBAUXCTL_E32B
), SMBAUXCTL(priv
));
580 if ((read_write
== I2C_SMBUS_WRITE
) || (xact
== I801_QUICK
))
583 switch (xact
& 0x7f) {
584 case I801_BYTE
: /* Result put in SMBHSTDAT0 */
586 data
->byte
= inb_p(SMBHSTDAT0(priv
));
589 data
->word
= inb_p(SMBHSTDAT0(priv
)) +
590 (inb_p(SMBHSTDAT1(priv
)) << 8);
597 static u32
i801_func(struct i2c_adapter
*adapter
)
599 struct i801_priv
*priv
= i2c_get_adapdata(adapter
);
601 return I2C_FUNC_SMBUS_QUICK
| I2C_FUNC_SMBUS_BYTE
|
602 I2C_FUNC_SMBUS_BYTE_DATA
| I2C_FUNC_SMBUS_WORD_DATA
|
603 I2C_FUNC_SMBUS_BLOCK_DATA
| I2C_FUNC_SMBUS_WRITE_I2C_BLOCK
|
604 ((priv
->features
& FEATURE_SMBUS_PEC
) ? I2C_FUNC_SMBUS_PEC
: 0) |
605 ((priv
->features
& FEATURE_I2C_BLOCK_READ
) ?
606 I2C_FUNC_SMBUS_READ_I2C_BLOCK
: 0);
609 static const struct i2c_algorithm smbus_algorithm
= {
610 .smbus_xfer
= i801_access
,
611 .functionality
= i801_func
,
614 static DEFINE_PCI_DEVICE_TABLE(i801_ids
) = {
615 { PCI_DEVICE(PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_INTEL_82801AA_3
) },
616 { PCI_DEVICE(PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_INTEL_82801AB_3
) },
617 { PCI_DEVICE(PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_INTEL_82801BA_2
) },
618 { PCI_DEVICE(PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_INTEL_82801CA_3
) },
619 { PCI_DEVICE(PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_INTEL_82801DB_3
) },
620 { PCI_DEVICE(PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_INTEL_82801EB_3
) },
621 { PCI_DEVICE(PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_INTEL_ESB_4
) },
622 { PCI_DEVICE(PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_INTEL_ICH6_16
) },
623 { PCI_DEVICE(PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_INTEL_ICH7_17
) },
624 { PCI_DEVICE(PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_INTEL_ESB2_17
) },
625 { PCI_DEVICE(PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_INTEL_ICH8_5
) },
626 { PCI_DEVICE(PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_INTEL_ICH9_6
) },
627 { PCI_DEVICE(PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_INTEL_EP80579_1
) },
628 { PCI_DEVICE(PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_INTEL_ICH10_4
) },
629 { PCI_DEVICE(PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_INTEL_ICH10_5
) },
630 { PCI_DEVICE(PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_INTEL_5_3400_SERIES_SMBUS
) },
631 { PCI_DEVICE(PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_INTEL_COUGARPOINT_SMBUS
) },
632 { PCI_DEVICE(PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS
) },
633 { PCI_DEVICE(PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS_IDF0
) },
634 { PCI_DEVICE(PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS_IDF1
) },
635 { PCI_DEVICE(PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS_IDF2
) },
636 { PCI_DEVICE(PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_INTEL_DH89XXCC_SMBUS
) },
637 { PCI_DEVICE(PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_INTEL_PANTHERPOINT_SMBUS
) },
638 { PCI_DEVICE(PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_INTEL_LYNXPOINT_SMBUS
) },
642 MODULE_DEVICE_TABLE(pci
, i801_ids
);
644 #if defined CONFIG_X86 && defined CONFIG_DMI
645 static unsigned char apanel_addr
;
647 /* Scan the system ROM for the signature "FJKEYINF" */
648 static __init
const void __iomem
*bios_signature(const void __iomem
*bios
)
651 const unsigned char signature
[] = "FJKEYINF";
653 for (offset
= 0; offset
< 0x10000; offset
+= 0x10) {
654 if (check_signature(bios
+ offset
, signature
,
655 sizeof(signature
)-1))
656 return bios
+ offset
;
661 static void __init
input_apanel_init(void)
664 const void __iomem
*p
;
666 bios
= ioremap(0xF0000, 0x10000); /* Can't fail */
667 p
= bios_signature(bios
);
669 /* just use the first address */
670 apanel_addr
= readb(p
+ 8 + 3) >> 1;
675 struct dmi_onboard_device_info
{
678 unsigned short i2c_addr
;
679 const char *i2c_type
;
682 static struct dmi_onboard_device_info __devinitdata dmi_devices
[] = {
683 { "Syleus", DMI_DEV_TYPE_OTHER
, 0x73, "fscsyl" },
684 { "Hermes", DMI_DEV_TYPE_OTHER
, 0x73, "fscher" },
685 { "Hades", DMI_DEV_TYPE_OTHER
, 0x73, "fschds" },
688 static void __devinit
dmi_check_onboard_device(u8 type
, const char *name
,
689 struct i2c_adapter
*adap
)
692 struct i2c_board_info info
;
694 for (i
= 0; i
< ARRAY_SIZE(dmi_devices
); i
++) {
695 /* & ~0x80, ignore enabled/disabled bit */
696 if ((type
& ~0x80) != dmi_devices
[i
].type
)
698 if (strcasecmp(name
, dmi_devices
[i
].name
))
701 memset(&info
, 0, sizeof(struct i2c_board_info
));
702 info
.addr
= dmi_devices
[i
].i2c_addr
;
703 strlcpy(info
.type
, dmi_devices
[i
].i2c_type
, I2C_NAME_SIZE
);
704 i2c_new_device(adap
, &info
);
709 /* We use our own function to check for onboard devices instead of
710 dmi_find_device() as some buggy BIOS's have the devices we are interested
711 in marked as disabled */
712 static void __devinit
dmi_check_onboard_devices(const struct dmi_header
*dm
,
720 count
= (dm
->length
- sizeof(struct dmi_header
)) / 2;
721 for (i
= 0; i
< count
; i
++) {
722 const u8
*d
= (char *)(dm
+ 1) + (i
* 2);
723 const char *name
= ((char *) dm
) + dm
->length
;
730 while (s
> 0 && name
[0]) {
731 name
+= strlen(name
) + 1;
734 if (name
[0] == 0) /* Bogus string reference */
737 dmi_check_onboard_device(type
, name
, adap
);
741 /* Register optional slaves */
742 static void __devinit
i801_probe_optional_slaves(struct i801_priv
*priv
)
744 /* Only register slaves on main SMBus channel */
745 if (priv
->features
& FEATURE_IDF
)
749 struct i2c_board_info info
;
751 memset(&info
, 0, sizeof(struct i2c_board_info
));
752 info
.addr
= apanel_addr
;
753 strlcpy(info
.type
, "fujitsu_apanel", I2C_NAME_SIZE
);
754 i2c_new_device(&priv
->adapter
, &info
);
757 if (dmi_name_in_vendors("FUJITSU"))
758 dmi_walk(dmi_check_onboard_devices
, &priv
->adapter
);
761 static void __init
input_apanel_init(void) {}
762 static void __devinit
i801_probe_optional_slaves(struct i801_priv
*priv
) {}
763 #endif /* CONFIG_X86 && CONFIG_DMI */
765 static int __devinit
i801_probe(struct pci_dev
*dev
,
766 const struct pci_device_id
*id
)
770 struct i801_priv
*priv
;
772 priv
= kzalloc(sizeof(*priv
), GFP_KERNEL
);
776 i2c_set_adapdata(&priv
->adapter
, priv
);
777 priv
->adapter
.owner
= THIS_MODULE
;
778 priv
->adapter
.class = I2C_CLASS_HWMON
| I2C_CLASS_SPD
;
779 priv
->adapter
.algo
= &smbus_algorithm
;
782 switch (dev
->device
) {
783 case PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS_IDF0
:
784 case PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS_IDF1
:
785 case PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS_IDF2
:
786 priv
->features
|= FEATURE_IDF
;
789 priv
->features
|= FEATURE_I2C_BLOCK_READ
;
791 case PCI_DEVICE_ID_INTEL_82801DB_3
:
792 priv
->features
|= FEATURE_SMBUS_PEC
;
793 priv
->features
|= FEATURE_BLOCK_BUFFER
;
795 case PCI_DEVICE_ID_INTEL_82801CA_3
:
796 case PCI_DEVICE_ID_INTEL_82801BA_2
:
797 case PCI_DEVICE_ID_INTEL_82801AB_3
:
798 case PCI_DEVICE_ID_INTEL_82801AA_3
:
802 /* Disable features on user request */
803 for (i
= 0; i
< ARRAY_SIZE(i801_feature_names
); i
++) {
804 if (priv
->features
& disable_features
& (1 << i
))
805 dev_notice(&dev
->dev
, "%s disabled by user\n",
806 i801_feature_names
[i
]);
808 priv
->features
&= ~disable_features
;
810 err
= pci_enable_device(dev
);
812 dev_err(&dev
->dev
, "Failed to enable SMBus PCI device (%d)\n",
817 /* Determine the address of the SMBus area */
818 priv
->smba
= pci_resource_start(dev
, SMBBAR
);
820 dev_err(&dev
->dev
, "SMBus base address uninitialized, "
826 err
= acpi_check_resource_conflict(&dev
->resource
[SMBBAR
]);
832 err
= pci_request_region(dev
, SMBBAR
, i801_driver
.name
);
834 dev_err(&dev
->dev
, "Failed to request SMBus region "
835 "0x%lx-0x%Lx\n", priv
->smba
,
836 (unsigned long long)pci_resource_end(dev
, SMBBAR
));
840 pci_read_config_byte(priv
->pci_dev
, SMBHSTCFG
, &temp
);
841 priv
->original_hstcfg
= temp
;
842 temp
&= ~SMBHSTCFG_I2C_EN
; /* SMBus timing */
843 if (!(temp
& SMBHSTCFG_HST_EN
)) {
844 dev_info(&dev
->dev
, "Enabling SMBus device\n");
845 temp
|= SMBHSTCFG_HST_EN
;
847 pci_write_config_byte(priv
->pci_dev
, SMBHSTCFG
, temp
);
849 if (temp
& SMBHSTCFG_SMB_SMI_EN
)
850 dev_dbg(&dev
->dev
, "SMBus using interrupt SMI#\n");
852 dev_dbg(&dev
->dev
, "SMBus using PCI Interrupt\n");
854 /* Clear special mode bits */
855 if (priv
->features
& (FEATURE_SMBUS_PEC
| FEATURE_BLOCK_BUFFER
))
856 outb_p(inb_p(SMBAUXCTL(priv
)) &
857 ~(SMBAUXCTL_CRC
| SMBAUXCTL_E32B
), SMBAUXCTL(priv
));
859 /* set up the sysfs linkage to our parent device */
860 priv
->adapter
.dev
.parent
= &dev
->dev
;
862 /* Retry up to 3 times on lost arbitration */
863 priv
->adapter
.retries
= 3;
865 snprintf(priv
->adapter
.name
, sizeof(priv
->adapter
.name
),
866 "SMBus I801 adapter at %04lx", priv
->smba
);
867 err
= i2c_add_adapter(&priv
->adapter
);
869 dev_err(&dev
->dev
, "Failed to add SMBus adapter\n");
873 i801_probe_optional_slaves(priv
);
875 pci_set_drvdata(dev
, priv
);
879 pci_release_region(dev
, SMBBAR
);
885 static void __devexit
i801_remove(struct pci_dev
*dev
)
887 struct i801_priv
*priv
= pci_get_drvdata(dev
);
889 i2c_del_adapter(&priv
->adapter
);
890 pci_write_config_byte(dev
, SMBHSTCFG
, priv
->original_hstcfg
);
891 pci_release_region(dev
, SMBBAR
);
892 pci_set_drvdata(dev
, NULL
);
895 * do not call pci_disable_device(dev) since it can cause hard hangs on
896 * some systems during power-off (eg. Fujitsu-Siemens Lifebook E8010)
901 static int i801_suspend(struct pci_dev
*dev
, pm_message_t mesg
)
903 struct i801_priv
*priv
= pci_get_drvdata(dev
);
906 pci_write_config_byte(dev
, SMBHSTCFG
, priv
->original_hstcfg
);
907 pci_set_power_state(dev
, pci_choose_state(dev
, mesg
));
911 static int i801_resume(struct pci_dev
*dev
)
913 pci_set_power_state(dev
, PCI_D0
);
914 pci_restore_state(dev
);
915 return pci_enable_device(dev
);
918 #define i801_suspend NULL
919 #define i801_resume NULL
922 static struct pci_driver i801_driver
= {
923 .name
= "i801_smbus",
924 .id_table
= i801_ids
,
926 .remove
= __devexit_p(i801_remove
),
927 .suspend
= i801_suspend
,
928 .resume
= i801_resume
,
931 static int __init
i2c_i801_init(void)
933 if (dmi_name_in_vendors("FUJITSU"))
935 return pci_register_driver(&i801_driver
);
938 static void __exit
i2c_i801_exit(void)
940 pci_unregister_driver(&i801_driver
);
943 MODULE_AUTHOR("Mark D. Studebaker <mdsxyz123@yahoo.com>, "
944 "Jean Delvare <khali@linux-fr.org>");
945 MODULE_DESCRIPTION("I801 SMBus driver");
946 MODULE_LICENSE("GPL");
948 module_init(i2c_i801_init
);
949 module_exit(i2c_i801_exit
);