1 /* 2 i2c-i801.c - Part of lm_sensors, Linux kernel modules for hardware 3 monitoring 4 Copyright (c) 1998 - 2002 Frodo Looijaard <frodol@dds.nl>, 5 Philip Edelbrock <phil@netroedge.com>, and Mark D. Studebaker 6 <mdsxyz123@yahoo.com> 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 2 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the Free Software 20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 21 */ 22 23 /* 24 SUPPORTED DEVICES PCI ID 25 82801AA 2413 26 82801AB 2423 27 82801BA 2443 28 82801CA/CAM 2483 29 82801DB 24C3 (HW PEC supported, 32 byte buffer not supported) 30 82801EB 24D3 (HW PEC supported, 32 byte buffer not supported) 31 6300ESB 25A4 32 ICH6 266A 33 ICH7 27DA 34 ESB2 269B 35 ICH8 283E 36 This driver supports several versions of Intel's I/O Controller Hubs (ICH). 37 For SMBus support, they are similar to the PIIX4 and are part 38 of Intel's '810' and other chipsets. 39 See the file Documentation/i2c/busses/i2c-i801 for details. 40 I2C Block Read and Process Call are not supported. 41 */ 42 43 /* Note: we assume there can only be one I801, with one SMBus interface */ 44 45 #include <linux/module.h> 46 #include <linux/pci.h> 47 #include <linux/kernel.h> 48 #include <linux/stddef.h> 49 #include <linux/delay.h> 50 #include <linux/sched.h> 51 #include <linux/ioport.h> 52 #include <linux/init.h> 53 #include <linux/i2c.h> 54 #include <asm/io.h> 55 56 /* I801 SMBus address offsets */ 57 #define SMBHSTSTS (0 + i801_smba) 58 #define SMBHSTCNT (2 + i801_smba) 59 #define SMBHSTCMD (3 + i801_smba) 60 #define SMBHSTADD (4 + i801_smba) 61 #define SMBHSTDAT0 (5 + i801_smba) 62 #define SMBHSTDAT1 (6 + i801_smba) 63 #define SMBBLKDAT (7 + i801_smba) 64 #define SMBPEC (8 + i801_smba) /* ICH4 only */ 65 #define SMBAUXSTS (12 + i801_smba) /* ICH4 only */ 66 #define SMBAUXCTL (13 + i801_smba) /* ICH4 only */ 67 68 /* PCI Address Constants */ 69 #define SMBBAR 4 70 #define SMBHSTCFG 0x040 71 72 /* Host configuration bits for SMBHSTCFG */ 73 #define SMBHSTCFG_HST_EN 1 74 #define SMBHSTCFG_SMB_SMI_EN 2 75 #define SMBHSTCFG_I2C_EN 4 76 77 /* Other settings */ 78 #define MAX_TIMEOUT 100 79 #define ENABLE_INT9 0 /* set to 0x01 to enable - untested */ 80 81 /* I801 command constants */ 82 #define I801_QUICK 0x00 83 #define I801_BYTE 0x04 84 #define I801_BYTE_DATA 0x08 85 #define I801_WORD_DATA 0x0C 86 #define I801_PROC_CALL 0x10 /* later chips only, unimplemented */ 87 #define I801_BLOCK_DATA 0x14 88 #define I801_I2C_BLOCK_DATA 0x18 /* unimplemented */ 89 #define I801_BLOCK_LAST 0x34 90 #define I801_I2C_BLOCK_LAST 0x38 /* unimplemented */ 91 #define I801_START 0x40 92 #define I801_PEC_EN 0x80 /* ICH4 only */ 93 94 95 static int i801_transaction(void); 96 static int i801_block_transaction(union i2c_smbus_data *data, char read_write, 97 int command, int hwpec); 98 99 static unsigned long i801_smba; 100 static struct pci_driver i801_driver; 101 static struct pci_dev *I801_dev; 102 static int isich4; 103 104 static int i801_transaction(void) 105 { 106 int temp; 107 int result = 0; 108 int timeout = 0; 109 110 dev_dbg(&I801_dev->dev, "Transaction (pre): CNT=%02x, CMD=%02x, " 111 "ADD=%02x, DAT0=%02x, DAT1=%02x\n", inb_p(SMBHSTCNT), 112 inb_p(SMBHSTCMD), inb_p(SMBHSTADD), inb_p(SMBHSTDAT0), 113 inb_p(SMBHSTDAT1)); 114 115 /* Make sure the SMBus host is ready to start transmitting */ 116 /* 0x1f = Failed, Bus_Err, Dev_Err, Intr, Host_Busy */ 117 if ((temp = (0x1f & inb_p(SMBHSTSTS))) != 0x00) { 118 dev_dbg(&I801_dev->dev, "SMBus busy (%02x). Resetting...\n", 119 temp); 120 outb_p(temp, SMBHSTSTS); 121 if ((temp = (0x1f & inb_p(SMBHSTSTS))) != 0x00) { 122 dev_dbg(&I801_dev->dev, "Failed! (%02x)\n", temp); 123 return -1; 124 } else { 125 dev_dbg(&I801_dev->dev, "Successfull!\n"); 126 } 127 } 128 129 outb_p(inb(SMBHSTCNT) | I801_START, SMBHSTCNT); 130 131 /* We will always wait for a fraction of a second! */ 132 do { 133 msleep(1); 134 temp = inb_p(SMBHSTSTS); 135 } while ((temp & 0x01) && (timeout++ < MAX_TIMEOUT)); 136 137 /* If the SMBus is still busy, we give up */ 138 if (timeout >= MAX_TIMEOUT) { 139 dev_dbg(&I801_dev->dev, "SMBus Timeout!\n"); 140 result = -1; 141 } 142 143 if (temp & 0x10) { 144 result = -1; 145 dev_dbg(&I801_dev->dev, "Error: Failed bus transaction\n"); 146 } 147 148 if (temp & 0x08) { 149 result = -1; 150 dev_err(&I801_dev->dev, "Bus collision! SMBus may be locked " 151 "until next hard reset. (sorry!)\n"); 152 /* Clock stops and slave is stuck in mid-transmission */ 153 } 154 155 if (temp & 0x04) { 156 result = -1; 157 dev_dbg(&I801_dev->dev, "Error: no response!\n"); 158 } 159 160 if ((inb_p(SMBHSTSTS) & 0x1f) != 0x00) 161 outb_p(inb(SMBHSTSTS), SMBHSTSTS); 162 163 if ((temp = (0x1f & inb_p(SMBHSTSTS))) != 0x00) { 164 dev_dbg(&I801_dev->dev, "Failed reset at end of transaction " 165 "(%02x)\n", temp); 166 } 167 dev_dbg(&I801_dev->dev, "Transaction (post): CNT=%02x, CMD=%02x, " 168 "ADD=%02x, DAT0=%02x, DAT1=%02x\n", inb_p(SMBHSTCNT), 169 inb_p(SMBHSTCMD), inb_p(SMBHSTADD), inb_p(SMBHSTDAT0), 170 inb_p(SMBHSTDAT1)); 171 return result; 172 } 173 174 /* All-inclusive block transaction function */ 175 static int i801_block_transaction(union i2c_smbus_data *data, char read_write, 176 int command, int hwpec) 177 { 178 int i, len; 179 int smbcmd; 180 int temp; 181 int result = 0; 182 int timeout; 183 unsigned char hostc, errmask; 184 185 if (command == I2C_SMBUS_I2C_BLOCK_DATA) { 186 if (read_write == I2C_SMBUS_WRITE) { 187 /* set I2C_EN bit in configuration register */ 188 pci_read_config_byte(I801_dev, SMBHSTCFG, &hostc); 189 pci_write_config_byte(I801_dev, SMBHSTCFG, 190 hostc | SMBHSTCFG_I2C_EN); 191 } else { 192 dev_err(&I801_dev->dev, 193 "I2C_SMBUS_I2C_BLOCK_READ not DB!\n"); 194 return -1; 195 } 196 } 197 198 if (read_write == I2C_SMBUS_WRITE) { 199 len = data->block[0]; 200 if (len < 1) 201 len = 1; 202 if (len > 32) 203 len = 32; 204 outb_p(len, SMBHSTDAT0); 205 outb_p(data->block[1], SMBBLKDAT); 206 } else { 207 len = 32; /* max for reads */ 208 } 209 210 if(isich4 && command != I2C_SMBUS_I2C_BLOCK_DATA) { 211 /* set 32 byte buffer */ 212 } 213 214 for (i = 1; i <= len; i++) { 215 if (i == len && read_write == I2C_SMBUS_READ) 216 smbcmd = I801_BLOCK_LAST; 217 else 218 smbcmd = I801_BLOCK_DATA; 219 outb_p(smbcmd | ENABLE_INT9, SMBHSTCNT); 220 221 dev_dbg(&I801_dev->dev, "Block (pre %d): CNT=%02x, CMD=%02x, " 222 "ADD=%02x, DAT0=%02x, BLKDAT=%02x\n", i, 223 inb_p(SMBHSTCNT), inb_p(SMBHSTCMD), inb_p(SMBHSTADD), 224 inb_p(SMBHSTDAT0), inb_p(SMBBLKDAT)); 225 226 /* Make sure the SMBus host is ready to start transmitting */ 227 temp = inb_p(SMBHSTSTS); 228 if (i == 1) { 229 /* Erronenous conditions before transaction: 230 * Byte_Done, Failed, Bus_Err, Dev_Err, Intr, Host_Busy */ 231 errmask=0x9f; 232 } else { 233 /* Erronenous conditions during transaction: 234 * Failed, Bus_Err, Dev_Err, Intr */ 235 errmask=0x1e; 236 } 237 if (temp & errmask) { 238 dev_dbg(&I801_dev->dev, "SMBus busy (%02x). " 239 "Resetting...\n", temp); 240 outb_p(temp, SMBHSTSTS); 241 if (((temp = inb_p(SMBHSTSTS)) & errmask) != 0x00) { 242 dev_err(&I801_dev->dev, 243 "Reset failed! (%02x)\n", temp); 244 result = -1; 245 goto END; 246 } 247 if (i != 1) { 248 /* if die in middle of block transaction, fail */ 249 result = -1; 250 goto END; 251 } 252 } 253 254 if (i == 1) 255 outb_p(inb(SMBHSTCNT) | I801_START, SMBHSTCNT); 256 257 /* We will always wait for a fraction of a second! */ 258 timeout = 0; 259 do { 260 msleep(1); 261 temp = inb_p(SMBHSTSTS); 262 } 263 while ((!(temp & 0x80)) 264 && (timeout++ < MAX_TIMEOUT)); 265 266 /* If the SMBus is still busy, we give up */ 267 if (timeout >= MAX_TIMEOUT) { 268 result = -1; 269 dev_dbg(&I801_dev->dev, "SMBus Timeout!\n"); 270 } 271 272 if (temp & 0x10) { 273 result = -1; 274 dev_dbg(&I801_dev->dev, 275 "Error: Failed bus transaction\n"); 276 } else if (temp & 0x08) { 277 result = -1; 278 dev_err(&I801_dev->dev, "Bus collision!\n"); 279 } else if (temp & 0x04) { 280 result = -1; 281 dev_dbg(&I801_dev->dev, "Error: no response!\n"); 282 } 283 284 if (i == 1 && read_write == I2C_SMBUS_READ) { 285 len = inb_p(SMBHSTDAT0); 286 if (len < 1) 287 len = 1; 288 if (len > 32) 289 len = 32; 290 data->block[0] = len; 291 } 292 293 /* Retrieve/store value in SMBBLKDAT */ 294 if (read_write == I2C_SMBUS_READ) 295 data->block[i] = inb_p(SMBBLKDAT); 296 if (read_write == I2C_SMBUS_WRITE && i+1 <= len) 297 outb_p(data->block[i+1], SMBBLKDAT); 298 if ((temp & 0x9e) != 0x00) 299 outb_p(temp, SMBHSTSTS); /* signals SMBBLKDAT ready */ 300 301 if ((temp = (0x1e & inb_p(SMBHSTSTS))) != 0x00) { 302 dev_dbg(&I801_dev->dev, 303 "Bad status (%02x) at end of transaction\n", 304 temp); 305 } 306 dev_dbg(&I801_dev->dev, "Block (post %d): CNT=%02x, CMD=%02x, " 307 "ADD=%02x, DAT0=%02x, BLKDAT=%02x\n", i, 308 inb_p(SMBHSTCNT), inb_p(SMBHSTCMD), inb_p(SMBHSTADD), 309 inb_p(SMBHSTDAT0), inb_p(SMBBLKDAT)); 310 311 if (result < 0) 312 goto END; 313 } 314 315 if (hwpec) { 316 /* wait for INTR bit as advised by Intel */ 317 timeout = 0; 318 do { 319 msleep(1); 320 temp = inb_p(SMBHSTSTS); 321 } while ((!(temp & 0x02)) 322 && (timeout++ < MAX_TIMEOUT)); 323 324 if (timeout >= MAX_TIMEOUT) { 325 dev_dbg(&I801_dev->dev, "PEC Timeout!\n"); 326 } 327 outb_p(temp, SMBHSTSTS); 328 } 329 result = 0; 330 END: 331 if (command == I2C_SMBUS_I2C_BLOCK_DATA) { 332 /* restore saved configuration register value */ 333 pci_write_config_byte(I801_dev, SMBHSTCFG, hostc); 334 } 335 return result; 336 } 337 338 /* Return -1 on error. */ 339 static s32 i801_access(struct i2c_adapter * adap, u16 addr, 340 unsigned short flags, char read_write, u8 command, 341 int size, union i2c_smbus_data * data) 342 { 343 int hwpec; 344 int block = 0; 345 int ret, xact = 0; 346 347 hwpec = isich4 && (flags & I2C_CLIENT_PEC) 348 && size != I2C_SMBUS_QUICK 349 && size != I2C_SMBUS_I2C_BLOCK_DATA; 350 351 switch (size) { 352 case I2C_SMBUS_QUICK: 353 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01), 354 SMBHSTADD); 355 xact = I801_QUICK; 356 break; 357 case I2C_SMBUS_BYTE: 358 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01), 359 SMBHSTADD); 360 if (read_write == I2C_SMBUS_WRITE) 361 outb_p(command, SMBHSTCMD); 362 xact = I801_BYTE; 363 break; 364 case I2C_SMBUS_BYTE_DATA: 365 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01), 366 SMBHSTADD); 367 outb_p(command, SMBHSTCMD); 368 if (read_write == I2C_SMBUS_WRITE) 369 outb_p(data->byte, SMBHSTDAT0); 370 xact = I801_BYTE_DATA; 371 break; 372 case I2C_SMBUS_WORD_DATA: 373 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01), 374 SMBHSTADD); 375 outb_p(command, SMBHSTCMD); 376 if (read_write == I2C_SMBUS_WRITE) { 377 outb_p(data->word & 0xff, SMBHSTDAT0); 378 outb_p((data->word & 0xff00) >> 8, SMBHSTDAT1); 379 } 380 xact = I801_WORD_DATA; 381 break; 382 case I2C_SMBUS_BLOCK_DATA: 383 case I2C_SMBUS_I2C_BLOCK_DATA: 384 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01), 385 SMBHSTADD); 386 outb_p(command, SMBHSTCMD); 387 block = 1; 388 break; 389 case I2C_SMBUS_PROC_CALL: 390 default: 391 dev_err(&I801_dev->dev, "Unsupported transaction %d\n", size); 392 return -1; 393 } 394 395 outb_p(hwpec, SMBAUXCTL); /* enable/disable hardware PEC */ 396 397 if(block) 398 ret = i801_block_transaction(data, read_write, size, hwpec); 399 else { 400 outb_p(xact | ENABLE_INT9, SMBHSTCNT); 401 ret = i801_transaction(); 402 } 403 404 /* Some BIOSes don't like it when PEC is enabled at reboot or resume 405 time, so we forcibly disable it after every transaction. */ 406 if (hwpec) 407 outb_p(0, SMBAUXCTL); 408 409 if(block) 410 return ret; 411 if(ret) 412 return -1; 413 if ((read_write == I2C_SMBUS_WRITE) || (xact == I801_QUICK)) 414 return 0; 415 416 switch (xact & 0x7f) { 417 case I801_BYTE: /* Result put in SMBHSTDAT0 */ 418 case I801_BYTE_DATA: 419 data->byte = inb_p(SMBHSTDAT0); 420 break; 421 case I801_WORD_DATA: 422 data->word = inb_p(SMBHSTDAT0) + (inb_p(SMBHSTDAT1) << 8); 423 break; 424 } 425 return 0; 426 } 427 428 429 static u32 i801_func(struct i2c_adapter *adapter) 430 { 431 return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE | 432 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA | 433 I2C_FUNC_SMBUS_BLOCK_DATA | I2C_FUNC_SMBUS_WRITE_I2C_BLOCK 434 | (isich4 ? I2C_FUNC_SMBUS_HWPEC_CALC : 0); 435 } 436 437 static struct i2c_algorithm smbus_algorithm = { 438 .smbus_xfer = i801_access, 439 .functionality = i801_func, 440 }; 441 442 static struct i2c_adapter i801_adapter = { 443 .owner = THIS_MODULE, 444 .class = I2C_CLASS_HWMON, 445 .algo = &smbus_algorithm, 446 }; 447 448 static struct pci_device_id i801_ids[] = { 449 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801AA_3) }, 450 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801AB_3) }, 451 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801BA_2) }, 452 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801CA_3) }, 453 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_3) }, 454 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801EB_3) }, 455 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ESB_4) }, 456 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_16) }, 457 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH7_17) }, 458 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ESB2_17) }, 459 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH8_5) }, 460 { 0, } 461 }; 462 463 MODULE_DEVICE_TABLE (pci, i801_ids); 464 465 static int __devinit i801_probe(struct pci_dev *dev, const struct pci_device_id *id) 466 { 467 unsigned char temp; 468 int err; 469 470 I801_dev = dev; 471 if ((dev->device == PCI_DEVICE_ID_INTEL_82801DB_3) || 472 (dev->device == PCI_DEVICE_ID_INTEL_82801EB_3) || 473 (dev->device == PCI_DEVICE_ID_INTEL_ESB_4)) 474 isich4 = 1; 475 else 476 isich4 = 0; 477 478 err = pci_enable_device(dev); 479 if (err) { 480 dev_err(&dev->dev, "Failed to enable SMBus PCI device (%d)\n", 481 err); 482 goto exit; 483 } 484 485 /* Determine the address of the SMBus area */ 486 i801_smba = pci_resource_start(dev, SMBBAR); 487 if (!i801_smba) { 488 dev_err(&dev->dev, "SMBus base address uninitialized, " 489 "upgrade BIOS\n"); 490 err = -ENODEV; 491 goto exit; 492 } 493 494 err = pci_request_region(dev, SMBBAR, i801_driver.name); 495 if (err) { 496 dev_err(&dev->dev, "Failed to request SMBus region " 497 "0x%lx-0x%Lx\n", i801_smba, 498 (unsigned long long)pci_resource_end(dev, SMBBAR)); 499 goto exit; 500 } 501 502 pci_read_config_byte(I801_dev, SMBHSTCFG, &temp); 503 temp &= ~SMBHSTCFG_I2C_EN; /* SMBus timing */ 504 if (!(temp & SMBHSTCFG_HST_EN)) { 505 dev_info(&dev->dev, "Enabling SMBus device\n"); 506 temp |= SMBHSTCFG_HST_EN; 507 } 508 pci_write_config_byte(I801_dev, SMBHSTCFG, temp); 509 510 if (temp & SMBHSTCFG_SMB_SMI_EN) 511 dev_dbg(&dev->dev, "SMBus using interrupt SMI#\n"); 512 else 513 dev_dbg(&dev->dev, "SMBus using PCI Interrupt\n"); 514 515 /* set up the driverfs linkage to our parent device */ 516 i801_adapter.dev.parent = &dev->dev; 517 518 snprintf(i801_adapter.name, I2C_NAME_SIZE, 519 "SMBus I801 adapter at %04lx", i801_smba); 520 err = i2c_add_adapter(&i801_adapter); 521 if (err) { 522 dev_err(&dev->dev, "Failed to add SMBus adapter\n"); 523 goto exit_release; 524 } 525 return 0; 526 527 exit_release: 528 pci_release_region(dev, SMBBAR); 529 exit: 530 return err; 531 } 532 533 static void __devexit i801_remove(struct pci_dev *dev) 534 { 535 i2c_del_adapter(&i801_adapter); 536 pci_release_region(dev, SMBBAR); 537 /* 538 * do not call pci_disable_device(dev) since it can cause hard hangs on 539 * some systems during power-off (eg. Fujitsu-Siemens Lifebook E8010) 540 */ 541 } 542 543 static struct pci_driver i801_driver = { 544 .name = "i801_smbus", 545 .id_table = i801_ids, 546 .probe = i801_probe, 547 .remove = __devexit_p(i801_remove), 548 }; 549 550 static int __init i2c_i801_init(void) 551 { 552 return pci_register_driver(&i801_driver); 553 } 554 555 static void __exit i2c_i801_exit(void) 556 { 557 pci_unregister_driver(&i801_driver); 558 } 559 560 MODULE_AUTHOR ("Frodo Looijaard <frodol@dds.nl>, " 561 "Philip Edelbrock <phil@netroedge.com>, " 562 "and Mark D. Studebaker <mdsxyz123@yahoo.com>"); 563 MODULE_DESCRIPTION("I801 SMBus driver"); 564 MODULE_LICENSE("GPL"); 565 566 module_init(i2c_i801_init); 567 module_exit(i2c_i801_exit); 568