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)
63 Interrupt processing yes
65 See the file Documentation/i2c/busses/i2c-i801 for details.
68 #include <linux/interrupt.h>
69 #include <linux/module.h>
70 #include <linux/pci.h>
71 #include <linux/kernel.h>
72 #include <linux/stddef.h>
73 #include <linux/delay.h>
74 #include <linux/ioport.h>
75 #include <linux/init.h>
76 #include <linux/i2c.h>
77 #include <linux/acpi.h>
79 #include <linux/dmi.h>
80 #include <linux/slab.h>
81 #include <linux/wait.h>
83 /* I801 SMBus address offsets */
84 #define SMBHSTSTS(p) (0 + (p)->smba)
85 #define SMBHSTCNT(p) (2 + (p)->smba)
86 #define SMBHSTCMD(p) (3 + (p)->smba)
87 #define SMBHSTADD(p) (4 + (p)->smba)
88 #define SMBHSTDAT0(p) (5 + (p)->smba)
89 #define SMBHSTDAT1(p) (6 + (p)->smba)
90 #define SMBBLKDAT(p) (7 + (p)->smba)
91 #define SMBPEC(p) (8 + (p)->smba) /* ICH3 and later */
92 #define SMBAUXSTS(p) (12 + (p)->smba) /* ICH4 and later */
93 #define SMBAUXCTL(p) (13 + (p)->smba) /* ICH4 and later */
95 /* PCI Address Constants */
97 #define SMBPCISTS 0x006
98 #define SMBHSTCFG 0x040
100 /* Host status bits for SMBPCISTS */
101 #define SMBPCISTS_INTS 0x08
103 /* Host configuration bits for SMBHSTCFG */
104 #define SMBHSTCFG_HST_EN 1
105 #define SMBHSTCFG_SMB_SMI_EN 2
106 #define SMBHSTCFG_I2C_EN 4
108 /* Auxiliary control register bits, ICH4+ only */
109 #define SMBAUXCTL_CRC 1
110 #define SMBAUXCTL_E32B 2
113 #define MAX_RETRIES 400
115 /* I801 command constants */
116 #define I801_QUICK 0x00
117 #define I801_BYTE 0x04
118 #define I801_BYTE_DATA 0x08
119 #define I801_WORD_DATA 0x0C
120 #define I801_PROC_CALL 0x10 /* unimplemented */
121 #define I801_BLOCK_DATA 0x14
122 #define I801_I2C_BLOCK_DATA 0x18 /* ICH5 and later */
124 /* I801 Host Control register bits */
125 #define SMBHSTCNT_INTREN 0x01
126 #define SMBHSTCNT_KILL 0x02
127 #define SMBHSTCNT_LAST_BYTE 0x20
128 #define SMBHSTCNT_START 0x40
129 #define SMBHSTCNT_PEC_EN 0x80 /* ICH3 and later */
131 /* I801 Hosts Status register bits */
132 #define SMBHSTSTS_BYTE_DONE 0x80
133 #define SMBHSTSTS_INUSE_STS 0x40
134 #define SMBHSTSTS_SMBALERT_STS 0x20
135 #define SMBHSTSTS_FAILED 0x10
136 #define SMBHSTSTS_BUS_ERR 0x08
137 #define SMBHSTSTS_DEV_ERR 0x04
138 #define SMBHSTSTS_INTR 0x02
139 #define SMBHSTSTS_HOST_BUSY 0x01
141 #define STATUS_ERROR_FLAGS (SMBHSTSTS_FAILED | SMBHSTSTS_BUS_ERR | \
144 #define STATUS_FLAGS (SMBHSTSTS_BYTE_DONE | SMBHSTSTS_INTR | \
147 /* Older devices have their ID defined in <linux/pci_ids.h> */
148 #define PCI_DEVICE_ID_INTEL_COUGARPOINT_SMBUS 0x1c22
149 #define PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS 0x1d22
150 /* Patsburg also has three 'Integrated Device Function' SMBus controllers */
151 #define PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS_IDF0 0x1d70
152 #define PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS_IDF1 0x1d71
153 #define PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS_IDF2 0x1d72
154 #define PCI_DEVICE_ID_INTEL_PANTHERPOINT_SMBUS 0x1e22
155 #define PCI_DEVICE_ID_INTEL_DH89XXCC_SMBUS 0x2330
156 #define PCI_DEVICE_ID_INTEL_5_3400_SERIES_SMBUS 0x3b30
157 #define PCI_DEVICE_ID_INTEL_LYNXPOINT_SMBUS 0x8c22
160 struct i2c_adapter adapter;
162 unsigned char original_hstcfg;
163 struct pci_dev *pci_dev;
164 unsigned int features;
167 wait_queue_head_t waitq;
170 /* Command state used by isr for byte-by-byte block transactions */
178 static struct pci_driver i801_driver;
180 #define FEATURE_SMBUS_PEC (1 << 0)
181 #define FEATURE_BLOCK_BUFFER (1 << 1)
182 #define FEATURE_BLOCK_PROC (1 << 2)
183 #define FEATURE_I2C_BLOCK_READ (1 << 3)
184 #define FEATURE_IRQ (1 << 4)
185 /* Not really a feature, but it's convenient to handle it as such */
186 #define FEATURE_IDF (1 << 15)
188 static const char *i801_feature_names[] = {
191 "Block process call",
196 static unsigned int disable_features;
197 module_param(disable_features, uint, S_IRUGO | S_IWUSR);
198 MODULE_PARM_DESC(disable_features, "Disable selected driver features");
200 /* Make sure the SMBus host is ready to start transmitting.
201 Return 0 if it is, -EBUSY if it is not. */
202 static int i801_check_pre(struct i801_priv *priv)
206 status = inb_p(SMBHSTSTS(priv));
207 if (status & SMBHSTSTS_HOST_BUSY) {
208 dev_err(&priv->pci_dev->dev, "SMBus is busy, can't use it!\n");
212 status &= STATUS_FLAGS;
214 dev_dbg(&priv->pci_dev->dev, "Clearing status flags (%02x)\n",
216 outb_p(status, SMBHSTSTS(priv));
217 status = inb_p(SMBHSTSTS(priv)) & STATUS_FLAGS;
219 dev_err(&priv->pci_dev->dev,
220 "Failed clearing status flags (%02x)\n",
230 * Convert the status register to an error code, and clear it.
231 * Note that status only contains the bits we want to clear, not the
232 * actual register value.
234 static int i801_check_post(struct i801_priv *priv, int status)
239 * If the SMBus is still busy, we give up
240 * Note: This timeout condition only happens when using polling
241 * transactions. For interrupt operation, NAK/timeout is indicated by
244 if (unlikely(status < 0)) {
245 dev_err(&priv->pci_dev->dev, "Transaction timeout\n");
246 /* try to stop the current command */
247 dev_dbg(&priv->pci_dev->dev, "Terminating the current operation\n");
248 outb_p(inb_p(SMBHSTCNT(priv)) | SMBHSTCNT_KILL,
250 usleep_range(1000, 2000);
251 outb_p(inb_p(SMBHSTCNT(priv)) & (~SMBHSTCNT_KILL),
254 /* Check if it worked */
255 status = inb_p(SMBHSTSTS(priv));
256 if ((status & SMBHSTSTS_HOST_BUSY) ||
257 !(status & SMBHSTSTS_FAILED))
258 dev_err(&priv->pci_dev->dev,
259 "Failed terminating the transaction\n");
260 outb_p(STATUS_FLAGS, SMBHSTSTS(priv));
264 if (status & SMBHSTSTS_FAILED) {
266 dev_err(&priv->pci_dev->dev, "Transaction failed\n");
268 if (status & SMBHSTSTS_DEV_ERR) {
270 dev_dbg(&priv->pci_dev->dev, "No response\n");
272 if (status & SMBHSTSTS_BUS_ERR) {
274 dev_dbg(&priv->pci_dev->dev, "Lost arbitration\n");
277 /* Clear status flags except BYTE_DONE, to be cleared by caller */
278 outb_p(status, SMBHSTSTS(priv));
283 /* Wait for BUSY being cleared and either INTR or an error flag being set */
284 static int i801_wait_intr(struct i801_priv *priv)
289 /* We will always wait for a fraction of a second! */
291 usleep_range(250, 500);
292 status = inb_p(SMBHSTSTS(priv));
293 } while (((status & SMBHSTSTS_HOST_BUSY) ||
294 !(status & (STATUS_ERROR_FLAGS | SMBHSTSTS_INTR))) &&
295 (timeout++ < MAX_RETRIES));
297 if (timeout > MAX_RETRIES) {
298 dev_dbg(&priv->pci_dev->dev, "INTR Timeout!\n");
301 return status & (STATUS_ERROR_FLAGS | SMBHSTSTS_INTR);
304 /* Wait for either BYTE_DONE or an error flag being set */
305 static int i801_wait_byte_done(struct i801_priv *priv)
310 /* We will always wait for a fraction of a second! */
312 usleep_range(250, 500);
313 status = inb_p(SMBHSTSTS(priv));
314 } while (!(status & (STATUS_ERROR_FLAGS | SMBHSTSTS_BYTE_DONE)) &&
315 (timeout++ < MAX_RETRIES));
317 if (timeout > MAX_RETRIES) {
318 dev_dbg(&priv->pci_dev->dev, "BYTE_DONE Timeout!\n");
321 return status & STATUS_ERROR_FLAGS;
324 static int i801_transaction(struct i801_priv *priv, int xact)
329 result = i801_check_pre(priv);
333 if (priv->features & FEATURE_IRQ) {
334 outb_p(xact | SMBHSTCNT_INTREN | SMBHSTCNT_START,
336 wait_event(priv->waitq, (status = priv->status));
338 return i801_check_post(priv, status);
341 /* the current contents of SMBHSTCNT can be overwritten, since PEC,
342 * SMBSCMD are passed in xact */
343 outb_p(xact | SMBHSTCNT_START, SMBHSTCNT(priv));
345 status = i801_wait_intr(priv);
346 return i801_check_post(priv, status);
349 static int i801_block_transaction_by_block(struct i801_priv *priv,
350 union i2c_smbus_data *data,
351 char read_write, int hwpec)
356 inb_p(SMBHSTCNT(priv)); /* reset the data buffer index */
358 /* Use 32-byte buffer to process this transaction */
359 if (read_write == I2C_SMBUS_WRITE) {
360 len = data->block[0];
361 outb_p(len, SMBHSTDAT0(priv));
362 for (i = 0; i < len; i++)
363 outb_p(data->block[i+1], SMBBLKDAT(priv));
366 status = i801_transaction(priv, I801_BLOCK_DATA |
367 (hwpec ? SMBHSTCNT_PEC_EN : 0));
371 if (read_write == I2C_SMBUS_READ) {
372 len = inb_p(SMBHSTDAT0(priv));
373 if (len < 1 || len > I2C_SMBUS_BLOCK_MAX)
376 data->block[0] = len;
377 for (i = 0; i < len; i++)
378 data->block[i + 1] = inb_p(SMBBLKDAT(priv));
383 static void i801_isr_byte_done(struct i801_priv *priv)
386 /* For SMBus block reads, length is received with first byte */
387 if (((priv->cmd & 0x1c) == I801_BLOCK_DATA) &&
388 (priv->count == 0)) {
389 priv->len = inb_p(SMBHSTDAT0(priv));
390 if (priv->len < 1 || priv->len > I2C_SMBUS_BLOCK_MAX) {
391 dev_err(&priv->pci_dev->dev,
392 "Illegal SMBus block read size %d\n",
395 priv->len = I2C_SMBUS_BLOCK_MAX;
397 dev_dbg(&priv->pci_dev->dev,
398 "SMBus block read size is %d\n",
401 priv->data[-1] = priv->len;
405 if (priv->count < priv->len)
406 priv->data[priv->count++] = inb(SMBBLKDAT(priv));
408 dev_dbg(&priv->pci_dev->dev,
409 "Discarding extra byte on block read\n");
411 /* Set LAST_BYTE for last byte of read transaction */
412 if (priv->count == priv->len - 1)
413 outb_p(priv->cmd | SMBHSTCNT_LAST_BYTE,
415 } else if (priv->count < priv->len - 1) {
416 /* Write next byte, except for IRQ after last byte */
417 outb_p(priv->data[++priv->count], SMBBLKDAT(priv));
420 /* Clear BYTE_DONE to continue with next byte */
421 outb_p(SMBHSTSTS_BYTE_DONE, SMBHSTSTS(priv));
425 * There are two kinds of interrupts:
427 * 1) i801 signals transaction completion with one of these interrupts:
429 * DEV_ERR - Invalid command, NAK or communication timeout
430 * BUS_ERR - SMI# transaction collision
431 * FAILED - transaction was canceled due to a KILL request
432 * When any of these occur, update ->status and wake up the waitq.
433 * ->status must be cleared before kicking off the next transaction.
435 * 2) For byte-by-byte (I2C read/write) transactions, one BYTE_DONE interrupt
436 * occurs for each byte of a byte-by-byte to prepare the next byte.
438 static irqreturn_t i801_isr(int irq, void *dev_id)
440 struct i801_priv *priv = dev_id;
444 /* Confirm this is our interrupt */
445 pci_read_config_word(priv->pci_dev, SMBPCISTS, &pcists);
446 if (!(pcists & SMBPCISTS_INTS))
449 status = inb_p(SMBHSTSTS(priv));
451 dev_dbg(&priv->pci_dev->dev, "irq: status = %02x\n", status);
453 if (status & SMBHSTSTS_BYTE_DONE)
454 i801_isr_byte_done(priv);
457 * Clear irq sources and report transaction result.
458 * ->status must be cleared before the next transaction is started.
460 status &= SMBHSTSTS_INTR | STATUS_ERROR_FLAGS;
462 outb_p(status, SMBHSTSTS(priv));
463 priv->status |= status;
464 wake_up(&priv->waitq);
471 * For "byte-by-byte" block transactions:
472 * I2C write uses cmd=I801_BLOCK_DATA, I2C_EN=1
473 * I2C read uses cmd=I801_I2C_BLOCK_DATA
475 static int i801_block_transaction_byte_by_byte(struct i801_priv *priv,
476 union i2c_smbus_data *data,
477 char read_write, int command,
485 result = i801_check_pre(priv);
489 len = data->block[0];
491 if (read_write == I2C_SMBUS_WRITE) {
492 outb_p(len, SMBHSTDAT0(priv));
493 outb_p(data->block[1], SMBBLKDAT(priv));
496 if (command == I2C_SMBUS_I2C_BLOCK_DATA &&
497 read_write == I2C_SMBUS_READ)
498 smbcmd = I801_I2C_BLOCK_DATA;
500 smbcmd = I801_BLOCK_DATA;
502 if (priv->features & FEATURE_IRQ) {
503 priv->is_read = (read_write == I2C_SMBUS_READ);
504 if (len == 1 && priv->is_read)
505 smbcmd |= SMBHSTCNT_LAST_BYTE;
506 priv->cmd = smbcmd | SMBHSTCNT_INTREN;
509 priv->data = &data->block[1];
511 outb_p(priv->cmd | SMBHSTCNT_START, SMBHSTCNT(priv));
512 wait_event(priv->waitq, (status = priv->status));
514 return i801_check_post(priv, status);
517 for (i = 1; i <= len; i++) {
518 if (i == len && read_write == I2C_SMBUS_READ)
519 smbcmd |= SMBHSTCNT_LAST_BYTE;
520 outb_p(smbcmd, SMBHSTCNT(priv));
523 outb_p(inb(SMBHSTCNT(priv)) | SMBHSTCNT_START,
526 status = i801_wait_byte_done(priv);
530 if (i == 1 && read_write == I2C_SMBUS_READ
531 && command != I2C_SMBUS_I2C_BLOCK_DATA) {
532 len = inb_p(SMBHSTDAT0(priv));
533 if (len < 1 || len > I2C_SMBUS_BLOCK_MAX) {
534 dev_err(&priv->pci_dev->dev,
535 "Illegal SMBus block read size %d\n",
538 while (inb_p(SMBHSTSTS(priv)) &
540 outb_p(SMBHSTSTS_BYTE_DONE,
542 outb_p(SMBHSTSTS_INTR, SMBHSTSTS(priv));
545 data->block[0] = len;
548 /* Retrieve/store value in SMBBLKDAT */
549 if (read_write == I2C_SMBUS_READ)
550 data->block[i] = inb_p(SMBBLKDAT(priv));
551 if (read_write == I2C_SMBUS_WRITE && i+1 <= len)
552 outb_p(data->block[i+1], SMBBLKDAT(priv));
554 /* signals SMBBLKDAT ready */
555 outb_p(SMBHSTSTS_BYTE_DONE, SMBHSTSTS(priv));
558 status = i801_wait_intr(priv);
560 return i801_check_post(priv, status);
563 static int i801_set_block_buffer_mode(struct i801_priv *priv)
565 outb_p(inb_p(SMBAUXCTL(priv)) | SMBAUXCTL_E32B, SMBAUXCTL(priv));
566 if ((inb_p(SMBAUXCTL(priv)) & SMBAUXCTL_E32B) == 0)
571 /* Block transaction function */
572 static int i801_block_transaction(struct i801_priv *priv,
573 union i2c_smbus_data *data, char read_write,
574 int command, int hwpec)
579 if (command == I2C_SMBUS_I2C_BLOCK_DATA) {
580 if (read_write == I2C_SMBUS_WRITE) {
581 /* set I2C_EN bit in configuration register */
582 pci_read_config_byte(priv->pci_dev, SMBHSTCFG, &hostc);
583 pci_write_config_byte(priv->pci_dev, SMBHSTCFG,
584 hostc | SMBHSTCFG_I2C_EN);
585 } else if (!(priv->features & FEATURE_I2C_BLOCK_READ)) {
586 dev_err(&priv->pci_dev->dev,
587 "I2C block read is unsupported!\n");
592 if (read_write == I2C_SMBUS_WRITE
593 || command == I2C_SMBUS_I2C_BLOCK_DATA) {
594 if (data->block[0] < 1)
596 if (data->block[0] > I2C_SMBUS_BLOCK_MAX)
597 data->block[0] = I2C_SMBUS_BLOCK_MAX;
599 data->block[0] = 32; /* max for SMBus block reads */
602 /* Experience has shown that the block buffer can only be used for
603 SMBus (not I2C) block transactions, even though the datasheet
604 doesn't mention this limitation. */
605 if ((priv->features & FEATURE_BLOCK_BUFFER)
606 && command != I2C_SMBUS_I2C_BLOCK_DATA
607 && i801_set_block_buffer_mode(priv) == 0)
608 result = i801_block_transaction_by_block(priv, data,
611 result = i801_block_transaction_byte_by_byte(priv, data,
615 if (command == I2C_SMBUS_I2C_BLOCK_DATA
616 && read_write == I2C_SMBUS_WRITE) {
617 /* restore saved configuration register value */
618 pci_write_config_byte(priv->pci_dev, SMBHSTCFG, hostc);
623 /* Return negative errno on error. */
624 static s32 i801_access(struct i2c_adapter *adap, u16 addr,
625 unsigned short flags, char read_write, u8 command,
626 int size, union i2c_smbus_data *data)
631 struct i801_priv *priv = i2c_get_adapdata(adap);
633 hwpec = (priv->features & FEATURE_SMBUS_PEC) && (flags & I2C_CLIENT_PEC)
634 && size != I2C_SMBUS_QUICK
635 && size != I2C_SMBUS_I2C_BLOCK_DATA;
638 case I2C_SMBUS_QUICK:
639 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
644 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
646 if (read_write == I2C_SMBUS_WRITE)
647 outb_p(command, SMBHSTCMD(priv));
650 case I2C_SMBUS_BYTE_DATA:
651 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
653 outb_p(command, SMBHSTCMD(priv));
654 if (read_write == I2C_SMBUS_WRITE)
655 outb_p(data->byte, SMBHSTDAT0(priv));
656 xact = I801_BYTE_DATA;
658 case I2C_SMBUS_WORD_DATA:
659 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
661 outb_p(command, SMBHSTCMD(priv));
662 if (read_write == I2C_SMBUS_WRITE) {
663 outb_p(data->word & 0xff, SMBHSTDAT0(priv));
664 outb_p((data->word & 0xff00) >> 8, SMBHSTDAT1(priv));
666 xact = I801_WORD_DATA;
668 case I2C_SMBUS_BLOCK_DATA:
669 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
671 outb_p(command, SMBHSTCMD(priv));
674 case I2C_SMBUS_I2C_BLOCK_DATA:
675 /* NB: page 240 of ICH5 datasheet shows that the R/#W
676 * bit should be cleared here, even when reading */
677 outb_p((addr & 0x7f) << 1, SMBHSTADD(priv));
678 if (read_write == I2C_SMBUS_READ) {
679 /* NB: page 240 of ICH5 datasheet also shows
680 * that DATA1 is the cmd field when reading */
681 outb_p(command, SMBHSTDAT1(priv));
683 outb_p(command, SMBHSTCMD(priv));
687 dev_err(&priv->pci_dev->dev, "Unsupported transaction %d\n",
692 if (hwpec) /* enable/disable hardware PEC */
693 outb_p(inb_p(SMBAUXCTL(priv)) | SMBAUXCTL_CRC, SMBAUXCTL(priv));
695 outb_p(inb_p(SMBAUXCTL(priv)) & (~SMBAUXCTL_CRC),
699 ret = i801_block_transaction(priv, data, read_write, size,
702 ret = i801_transaction(priv, xact);
704 /* Some BIOSes don't like it when PEC is enabled at reboot or resume
705 time, so we forcibly disable it after every transaction. Turn off
706 E32B for the same reason. */
708 outb_p(inb_p(SMBAUXCTL(priv)) &
709 ~(SMBAUXCTL_CRC | SMBAUXCTL_E32B), SMBAUXCTL(priv));
715 if ((read_write == I2C_SMBUS_WRITE) || (xact == I801_QUICK))
718 switch (xact & 0x7f) {
719 case I801_BYTE: /* Result put in SMBHSTDAT0 */
721 data->byte = inb_p(SMBHSTDAT0(priv));
724 data->word = inb_p(SMBHSTDAT0(priv)) +
725 (inb_p(SMBHSTDAT1(priv)) << 8);
732 static u32 i801_func(struct i2c_adapter *adapter)
734 struct i801_priv *priv = i2c_get_adapdata(adapter);
736 return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
737 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
738 I2C_FUNC_SMBUS_BLOCK_DATA | I2C_FUNC_SMBUS_WRITE_I2C_BLOCK |
739 ((priv->features & FEATURE_SMBUS_PEC) ? I2C_FUNC_SMBUS_PEC : 0) |
740 ((priv->features & FEATURE_I2C_BLOCK_READ) ?
741 I2C_FUNC_SMBUS_READ_I2C_BLOCK : 0);
744 static const struct i2c_algorithm smbus_algorithm = {
745 .smbus_xfer = i801_access,
746 .functionality = i801_func,
749 static DEFINE_PCI_DEVICE_TABLE(i801_ids) = {
750 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801AA_3) },
751 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801AB_3) },
752 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801BA_2) },
753 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801CA_3) },
754 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_3) },
755 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801EB_3) },
756 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ESB_4) },
757 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_16) },
758 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH7_17) },
759 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ESB2_17) },
760 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH8_5) },
761 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH9_6) },
762 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_EP80579_1) },
763 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH10_4) },
764 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH10_5) },
765 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_5_3400_SERIES_SMBUS) },
766 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_COUGARPOINT_SMBUS) },
767 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS) },
768 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS_IDF0) },
769 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS_IDF1) },
770 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS_IDF2) },
771 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_DH89XXCC_SMBUS) },
772 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_PANTHERPOINT_SMBUS) },
773 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_LYNXPOINT_SMBUS) },
777 MODULE_DEVICE_TABLE(pci, i801_ids);
779 #if defined CONFIG_X86 && defined CONFIG_DMI
780 static unsigned char apanel_addr;
782 /* Scan the system ROM for the signature "FJKEYINF" */
783 static __init const void __iomem *bios_signature(const void __iomem *bios)
786 const unsigned char signature[] = "FJKEYINF";
788 for (offset = 0; offset < 0x10000; offset += 0x10) {
789 if (check_signature(bios + offset, signature,
790 sizeof(signature)-1))
791 return bios + offset;
796 static void __init input_apanel_init(void)
799 const void __iomem *p;
801 bios = ioremap(0xF0000, 0x10000); /* Can't fail */
802 p = bios_signature(bios);
804 /* just use the first address */
805 apanel_addr = readb(p + 8 + 3) >> 1;
810 struct dmi_onboard_device_info {
813 unsigned short i2c_addr;
814 const char *i2c_type;
817 static struct dmi_onboard_device_info __devinitdata dmi_devices[] = {
818 { "Syleus", DMI_DEV_TYPE_OTHER, 0x73, "fscsyl" },
819 { "Hermes", DMI_DEV_TYPE_OTHER, 0x73, "fscher" },
820 { "Hades", DMI_DEV_TYPE_OTHER, 0x73, "fschds" },
823 static void __devinit dmi_check_onboard_device(u8 type, const char *name,
824 struct i2c_adapter *adap)
827 struct i2c_board_info info;
829 for (i = 0; i < ARRAY_SIZE(dmi_devices); i++) {
830 /* & ~0x80, ignore enabled/disabled bit */
831 if ((type & ~0x80) != dmi_devices[i].type)
833 if (strcasecmp(name, dmi_devices[i].name))
836 memset(&info, 0, sizeof(struct i2c_board_info));
837 info.addr = dmi_devices[i].i2c_addr;
838 strlcpy(info.type, dmi_devices[i].i2c_type, I2C_NAME_SIZE);
839 i2c_new_device(adap, &info);
844 /* We use our own function to check for onboard devices instead of
845 dmi_find_device() as some buggy BIOS's have the devices we are interested
846 in marked as disabled */
847 static void __devinit dmi_check_onboard_devices(const struct dmi_header *dm,
855 count = (dm->length - sizeof(struct dmi_header)) / 2;
856 for (i = 0; i < count; i++) {
857 const u8 *d = (char *)(dm + 1) + (i * 2);
858 const char *name = ((char *) dm) + dm->length;
865 while (s > 0 && name[0]) {
866 name += strlen(name) + 1;
869 if (name[0] == 0) /* Bogus string reference */
872 dmi_check_onboard_device(type, name, adap);
876 /* Register optional slaves */
877 static void __devinit i801_probe_optional_slaves(struct i801_priv *priv)
879 /* Only register slaves on main SMBus channel */
880 if (priv->features & FEATURE_IDF)
884 struct i2c_board_info info;
886 memset(&info, 0, sizeof(struct i2c_board_info));
887 info.addr = apanel_addr;
888 strlcpy(info.type, "fujitsu_apanel", I2C_NAME_SIZE);
889 i2c_new_device(&priv->adapter, &info);
892 if (dmi_name_in_vendors("FUJITSU"))
893 dmi_walk(dmi_check_onboard_devices, &priv->adapter);
896 static void __init input_apanel_init(void) {}
897 static void __devinit i801_probe_optional_slaves(struct i801_priv *priv) {}
898 #endif /* CONFIG_X86 && CONFIG_DMI */
900 static int __devinit i801_probe(struct pci_dev *dev,
901 const struct pci_device_id *id)
905 struct i801_priv *priv;
907 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
911 i2c_set_adapdata(&priv->adapter, priv);
912 priv->adapter.owner = THIS_MODULE;
913 priv->adapter.class = I2C_CLASS_HWMON | I2C_CLASS_SPD;
914 priv->adapter.algo = &smbus_algorithm;
917 switch (dev->device) {
918 case PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS_IDF0:
919 case PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS_IDF1:
920 case PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS_IDF2:
921 priv->features |= FEATURE_IDF;
924 priv->features |= FEATURE_I2C_BLOCK_READ;
926 case PCI_DEVICE_ID_INTEL_82801DB_3:
927 priv->features |= FEATURE_SMBUS_PEC;
928 priv->features |= FEATURE_BLOCK_BUFFER;
930 case PCI_DEVICE_ID_INTEL_82801CA_3:
931 case PCI_DEVICE_ID_INTEL_82801BA_2:
932 case PCI_DEVICE_ID_INTEL_82801AB_3:
933 case PCI_DEVICE_ID_INTEL_82801AA_3:
937 /* IRQ processing tested on CougarPoint PCH, ICH5, ICH7-M and ICH10 */
938 if (dev->device == PCI_DEVICE_ID_INTEL_COUGARPOINT_SMBUS ||
939 dev->device == PCI_DEVICE_ID_INTEL_82801EB_3 ||
940 dev->device == PCI_DEVICE_ID_INTEL_ICH7_17 ||
941 dev->device == PCI_DEVICE_ID_INTEL_ICH8_5 ||
942 dev->device == PCI_DEVICE_ID_INTEL_ICH9_6 ||
943 dev->device == PCI_DEVICE_ID_INTEL_ICH10_4 ||
944 dev->device == PCI_DEVICE_ID_INTEL_ICH10_5)
945 priv->features |= FEATURE_IRQ;
947 /* Disable features on user request */
948 for (i = 0; i < ARRAY_SIZE(i801_feature_names); i++) {
949 if (priv->features & disable_features & (1 << i))
950 dev_notice(&dev->dev, "%s disabled by user\n",
951 i801_feature_names[i]);
953 priv->features &= ~disable_features;
955 err = pci_enable_device(dev);
957 dev_err(&dev->dev, "Failed to enable SMBus PCI device (%d)\n",
962 /* Determine the address of the SMBus area */
963 priv->smba = pci_resource_start(dev, SMBBAR);
965 dev_err(&dev->dev, "SMBus base address uninitialized, "
971 err = acpi_check_resource_conflict(&dev->resource[SMBBAR]);
977 err = pci_request_region(dev, SMBBAR, i801_driver.name);
979 dev_err(&dev->dev, "Failed to request SMBus region "
980 "0x%lx-0x%Lx\n", priv->smba,
981 (unsigned long long)pci_resource_end(dev, SMBBAR));
985 pci_read_config_byte(priv->pci_dev, SMBHSTCFG, &temp);
986 priv->original_hstcfg = temp;
987 temp &= ~SMBHSTCFG_I2C_EN; /* SMBus timing */
988 if (!(temp & SMBHSTCFG_HST_EN)) {
989 dev_info(&dev->dev, "Enabling SMBus device\n");
990 temp |= SMBHSTCFG_HST_EN;
992 pci_write_config_byte(priv->pci_dev, SMBHSTCFG, temp);
994 if (temp & SMBHSTCFG_SMB_SMI_EN) {
995 dev_dbg(&dev->dev, "SMBus using interrupt SMI#\n");
996 /* Disable SMBus interrupt feature if SMBus using SMI# */
997 priv->features &= ~FEATURE_IRQ;
1000 /* Clear special mode bits */
1001 if (priv->features & (FEATURE_SMBUS_PEC | FEATURE_BLOCK_BUFFER))
1002 outb_p(inb_p(SMBAUXCTL(priv)) &
1003 ~(SMBAUXCTL_CRC | SMBAUXCTL_E32B), SMBAUXCTL(priv));
1005 if (priv->features & FEATURE_IRQ) {
1006 init_waitqueue_head(&priv->waitq);
1008 err = request_irq(dev->irq, i801_isr, IRQF_SHARED,
1009 i801_driver.name, priv);
1011 dev_err(&dev->dev, "Failed to allocate irq %d: %d\n",
1015 dev_info(&dev->dev, "SMBus using PCI Interrupt\n");
1018 /* set up the sysfs linkage to our parent device */
1019 priv->adapter.dev.parent = &dev->dev;
1021 /* Retry up to 3 times on lost arbitration */
1022 priv->adapter.retries = 3;
1024 snprintf(priv->adapter.name, sizeof(priv->adapter.name),
1025 "SMBus I801 adapter at %04lx", priv->smba);
1026 err = i2c_add_adapter(&priv->adapter);
1028 dev_err(&dev->dev, "Failed to add SMBus adapter\n");
1032 i801_probe_optional_slaves(priv);
1034 pci_set_drvdata(dev, priv);
1039 if (priv->features & FEATURE_IRQ)
1040 free_irq(dev->irq, priv);
1042 pci_release_region(dev, SMBBAR);
1048 static void __devexit i801_remove(struct pci_dev *dev)
1050 struct i801_priv *priv = pci_get_drvdata(dev);
1052 i2c_del_adapter(&priv->adapter);
1053 pci_write_config_byte(dev, SMBHSTCFG, priv->original_hstcfg);
1055 if (priv->features & FEATURE_IRQ)
1056 free_irq(dev->irq, priv);
1057 pci_release_region(dev, SMBBAR);
1059 pci_set_drvdata(dev, NULL);
1062 * do not call pci_disable_device(dev) since it can cause hard hangs on
1063 * some systems during power-off (eg. Fujitsu-Siemens Lifebook E8010)
1068 static int i801_suspend(struct pci_dev *dev, pm_message_t mesg)
1070 struct i801_priv *priv = pci_get_drvdata(dev);
1072 pci_save_state(dev);
1073 pci_write_config_byte(dev, SMBHSTCFG, priv->original_hstcfg);
1074 pci_set_power_state(dev, pci_choose_state(dev, mesg));
1078 static int i801_resume(struct pci_dev *dev)
1080 pci_set_power_state(dev, PCI_D0);
1081 pci_restore_state(dev);
1082 return pci_enable_device(dev);
1085 #define i801_suspend NULL
1086 #define i801_resume NULL
1089 static struct pci_driver i801_driver = {
1090 .name = "i801_smbus",
1091 .id_table = i801_ids,
1092 .probe = i801_probe,
1093 .remove = __devexit_p(i801_remove),
1094 .suspend = i801_suspend,
1095 .resume = i801_resume,
1098 static int __init i2c_i801_init(void)
1100 if (dmi_name_in_vendors("FUJITSU"))
1101 input_apanel_init();
1102 return pci_register_driver(&i801_driver);
1105 static void __exit i2c_i801_exit(void)
1107 pci_unregister_driver(&i801_driver);
1110 MODULE_AUTHOR("Mark D. Studebaker <mdsxyz123@yahoo.com>, "
1111 "Jean Delvare <khali@linux-fr.org>");
1112 MODULE_DESCRIPTION("I801 SMBus driver");
1113 MODULE_LICENSE("GPL");
1115 module_init(i2c_i801_init);
1116 module_exit(i2c_i801_exit);