1 /* 2 Copyright (c) 1998 - 2002 Frodo Looijaard <frodol@dds.nl>, 3 Philip Edelbrock <phil@netroedge.com>, Kyösti Mälkki <kmalkki@cc.hut.fi>, 4 Mark D. Studebaker <mdsxyz123@yahoo.com> 5 Copyright (C) 2005 - 2008 Jean Delvare <khali@linux-fr.org> 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 2 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, write to the Free Software 19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 */ 21 22 /* 23 Supports the following VIA south bridges: 24 25 Chip name PCI ID REV I2C block 26 VT82C596A 0x3050 no 27 VT82C596B 0x3051 no 28 VT82C686A 0x3057 0x30 no 29 VT82C686B 0x3057 0x40 yes 30 VT8231 0x8235 no? 31 VT8233 0x3074 yes 32 VT8233A 0x3147 yes? 33 VT8235 0x3177 yes 34 VT8237R 0x3227 yes 35 VT8237A 0x3337 yes 36 VT8237S 0x3372 yes 37 VT8251 0x3287 yes 38 CX700 0x8324 yes 39 VX800/VX820 0x8353 yes 40 VX855/VX875 0x8409 yes 41 42 Note: we assume there can only be one device, with one SMBus interface. 43 */ 44 45 #include <linux/module.h> 46 #include <linux/delay.h> 47 #include <linux/pci.h> 48 #include <linux/kernel.h> 49 #include <linux/stddef.h> 50 #include <linux/ioport.h> 51 #include <linux/i2c.h> 52 #include <linux/init.h> 53 #include <linux/acpi.h> 54 #include <asm/io.h> 55 56 static struct pci_dev *vt596_pdev; 57 58 #define SMBBA1 0x90 59 #define SMBBA2 0x80 60 #define SMBBA3 0xD0 61 62 /* SMBus address offsets */ 63 static unsigned short vt596_smba; 64 #define SMBHSTSTS (vt596_smba + 0) 65 #define SMBHSTCNT (vt596_smba + 2) 66 #define SMBHSTCMD (vt596_smba + 3) 67 #define SMBHSTADD (vt596_smba + 4) 68 #define SMBHSTDAT0 (vt596_smba + 5) 69 #define SMBHSTDAT1 (vt596_smba + 6) 70 #define SMBBLKDAT (vt596_smba + 7) 71 72 /* PCI Address Constants */ 73 74 /* SMBus data in configuration space can be found in two places, 75 We try to select the better one */ 76 77 static unsigned short SMBHSTCFG = 0xD2; 78 79 /* Other settings */ 80 #define MAX_TIMEOUT 500 81 82 /* VT82C596 constants */ 83 #define VT596_QUICK 0x00 84 #define VT596_BYTE 0x04 85 #define VT596_BYTE_DATA 0x08 86 #define VT596_WORD_DATA 0x0C 87 #define VT596_PROC_CALL 0x10 88 #define VT596_BLOCK_DATA 0x14 89 #define VT596_I2C_BLOCK_DATA 0x34 90 91 92 /* If force is set to anything different from 0, we forcibly enable the 93 VT596. DANGEROUS! */ 94 static int force; 95 module_param(force, bool, 0); 96 MODULE_PARM_DESC(force, "Forcibly enable the SMBus. DANGEROUS!"); 97 98 /* If force_addr is set to anything different from 0, we forcibly enable 99 the VT596 at the given address. VERY DANGEROUS! */ 100 static u16 force_addr; 101 module_param(force_addr, ushort, 0); 102 MODULE_PARM_DESC(force_addr, 103 "Forcibly enable the SMBus at the given address. " 104 "EXTREMELY DANGEROUS!"); 105 106 107 static struct pci_driver vt596_driver; 108 static struct i2c_adapter vt596_adapter; 109 110 #define FEATURE_I2CBLOCK (1<<0) 111 static unsigned int vt596_features; 112 113 #ifdef DEBUG 114 static void vt596_dump_regs(const char *msg, u8 size) 115 { 116 dev_dbg(&vt596_adapter.dev, "%s: STS=%02x CNT=%02x CMD=%02x ADD=%02x " 117 "DAT=%02x,%02x\n", msg, inb_p(SMBHSTSTS), inb_p(SMBHSTCNT), 118 inb_p(SMBHSTCMD), inb_p(SMBHSTADD), inb_p(SMBHSTDAT0), 119 inb_p(SMBHSTDAT1)); 120 121 if (size == VT596_BLOCK_DATA 122 || size == VT596_I2C_BLOCK_DATA) { 123 int i; 124 125 dev_dbg(&vt596_adapter.dev, "BLK="); 126 for (i = 0; i < I2C_SMBUS_BLOCK_MAX / 2; i++) 127 printk("%02x,", inb_p(SMBBLKDAT)); 128 printk("\n"); 129 dev_dbg(&vt596_adapter.dev, " "); 130 for (; i < I2C_SMBUS_BLOCK_MAX - 1; i++) 131 printk("%02x,", inb_p(SMBBLKDAT)); 132 printk("%02x\n", inb_p(SMBBLKDAT)); 133 } 134 } 135 #else 136 static inline void vt596_dump_regs(const char *msg, u8 size) { } 137 #endif 138 139 /* Return -1 on error, 0 on success */ 140 static int vt596_transaction(u8 size) 141 { 142 int temp; 143 int result = 0; 144 int timeout = 0; 145 146 vt596_dump_regs("Transaction (pre)", size); 147 148 /* Make sure the SMBus host is ready to start transmitting */ 149 if ((temp = inb_p(SMBHSTSTS)) & 0x1F) { 150 dev_dbg(&vt596_adapter.dev, "SMBus busy (0x%02x). " 151 "Resetting...\n", temp); 152 153 outb_p(temp, SMBHSTSTS); 154 if ((temp = inb_p(SMBHSTSTS)) & 0x1F) { 155 dev_err(&vt596_adapter.dev, "SMBus reset failed! " 156 "(0x%02x)\n", temp); 157 return -EBUSY; 158 } 159 } 160 161 /* Start the transaction by setting bit 6 */ 162 outb_p(0x40 | size, SMBHSTCNT); 163 164 /* We will always wait for a fraction of a second */ 165 do { 166 msleep(1); 167 temp = inb_p(SMBHSTSTS); 168 } while ((temp & 0x01) && (timeout++ < MAX_TIMEOUT)); 169 170 /* If the SMBus is still busy, we give up */ 171 if (timeout >= MAX_TIMEOUT) { 172 result = -ETIMEDOUT; 173 dev_err(&vt596_adapter.dev, "SMBus timeout!\n"); 174 } 175 176 if (temp & 0x10) { 177 result = -EIO; 178 dev_err(&vt596_adapter.dev, "Transaction failed (0x%02x)\n", 179 size); 180 } 181 182 if (temp & 0x08) { 183 result = -EIO; 184 dev_err(&vt596_adapter.dev, "SMBus collision!\n"); 185 } 186 187 if (temp & 0x04) { 188 int read = inb_p(SMBHSTADD) & 0x01; 189 result = -ENXIO; 190 /* The quick and receive byte commands are used to probe 191 for chips, so errors are expected, and we don't want 192 to frighten the user. */ 193 if (!((size == VT596_QUICK && !read) || 194 (size == VT596_BYTE && read))) 195 dev_err(&vt596_adapter.dev, "Transaction error!\n"); 196 } 197 198 /* Resetting status register */ 199 if (temp & 0x1F) 200 outb_p(temp, SMBHSTSTS); 201 202 vt596_dump_regs("Transaction (post)", size); 203 204 return result; 205 } 206 207 /* Return negative errno on error, 0 on success */ 208 static s32 vt596_access(struct i2c_adapter *adap, u16 addr, 209 unsigned short flags, char read_write, u8 command, 210 int size, union i2c_smbus_data *data) 211 { 212 int i; 213 int status; 214 215 switch (size) { 216 case I2C_SMBUS_QUICK: 217 size = VT596_QUICK; 218 break; 219 case I2C_SMBUS_BYTE: 220 if (read_write == I2C_SMBUS_WRITE) 221 outb_p(command, SMBHSTCMD); 222 size = VT596_BYTE; 223 break; 224 case I2C_SMBUS_BYTE_DATA: 225 outb_p(command, SMBHSTCMD); 226 if (read_write == I2C_SMBUS_WRITE) 227 outb_p(data->byte, SMBHSTDAT0); 228 size = VT596_BYTE_DATA; 229 break; 230 case I2C_SMBUS_WORD_DATA: 231 outb_p(command, SMBHSTCMD); 232 if (read_write == I2C_SMBUS_WRITE) { 233 outb_p(data->word & 0xff, SMBHSTDAT0); 234 outb_p((data->word & 0xff00) >> 8, SMBHSTDAT1); 235 } 236 size = VT596_WORD_DATA; 237 break; 238 case I2C_SMBUS_PROC_CALL: 239 outb_p(command, SMBHSTCMD); 240 outb_p(data->word & 0xff, SMBHSTDAT0); 241 outb_p((data->word & 0xff00) >> 8, SMBHSTDAT1); 242 size = VT596_PROC_CALL; 243 break; 244 case I2C_SMBUS_I2C_BLOCK_DATA: 245 if (!(vt596_features & FEATURE_I2CBLOCK)) 246 goto exit_unsupported; 247 if (read_write == I2C_SMBUS_READ) 248 outb_p(data->block[0], SMBHSTDAT0); 249 /* Fall through */ 250 case I2C_SMBUS_BLOCK_DATA: 251 outb_p(command, SMBHSTCMD); 252 if (read_write == I2C_SMBUS_WRITE) { 253 u8 len = data->block[0]; 254 if (len > I2C_SMBUS_BLOCK_MAX) 255 len = I2C_SMBUS_BLOCK_MAX; 256 outb_p(len, SMBHSTDAT0); 257 inb_p(SMBHSTCNT); /* Reset SMBBLKDAT */ 258 for (i = 1; i <= len; i++) 259 outb_p(data->block[i], SMBBLKDAT); 260 } 261 size = (size == I2C_SMBUS_I2C_BLOCK_DATA) ? 262 VT596_I2C_BLOCK_DATA : VT596_BLOCK_DATA; 263 break; 264 default: 265 goto exit_unsupported; 266 } 267 268 outb_p(((addr & 0x7f) << 1) | read_write, SMBHSTADD); 269 270 status = vt596_transaction(size); 271 if (status) 272 return status; 273 274 if (size == VT596_PROC_CALL) 275 read_write = I2C_SMBUS_READ; 276 277 if ((read_write == I2C_SMBUS_WRITE) || (size == VT596_QUICK)) 278 return 0; 279 280 switch (size) { 281 case VT596_BYTE: 282 case VT596_BYTE_DATA: 283 data->byte = inb_p(SMBHSTDAT0); 284 break; 285 case VT596_WORD_DATA: 286 case VT596_PROC_CALL: 287 data->word = inb_p(SMBHSTDAT0) + (inb_p(SMBHSTDAT1) << 8); 288 break; 289 case VT596_I2C_BLOCK_DATA: 290 case VT596_BLOCK_DATA: 291 data->block[0] = inb_p(SMBHSTDAT0); 292 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) 293 data->block[0] = I2C_SMBUS_BLOCK_MAX; 294 inb_p(SMBHSTCNT); /* Reset SMBBLKDAT */ 295 for (i = 1; i <= data->block[0]; i++) 296 data->block[i] = inb_p(SMBBLKDAT); 297 break; 298 } 299 return 0; 300 301 exit_unsupported: 302 dev_warn(&vt596_adapter.dev, "Unsupported transaction %d\n", 303 size); 304 return -EOPNOTSUPP; 305 } 306 307 static u32 vt596_func(struct i2c_adapter *adapter) 308 { 309 u32 func = I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE | 310 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA | 311 I2C_SMBUS_PROC_CALL | I2C_FUNC_SMBUS_BLOCK_DATA; 312 313 if (vt596_features & FEATURE_I2CBLOCK) 314 func |= I2C_FUNC_SMBUS_I2C_BLOCK; 315 return func; 316 } 317 318 static const struct i2c_algorithm smbus_algorithm = { 319 .smbus_xfer = vt596_access, 320 .functionality = vt596_func, 321 }; 322 323 static struct i2c_adapter vt596_adapter = { 324 .owner = THIS_MODULE, 325 .class = I2C_CLASS_HWMON | I2C_CLASS_SPD, 326 .algo = &smbus_algorithm, 327 }; 328 329 static int __devinit vt596_probe(struct pci_dev *pdev, 330 const struct pci_device_id *id) 331 { 332 unsigned char temp; 333 int error = -ENODEV; 334 335 /* Determine the address of the SMBus areas */ 336 if (force_addr) { 337 vt596_smba = force_addr & 0xfff0; 338 force = 0; 339 goto found; 340 } 341 342 if ((pci_read_config_word(pdev, id->driver_data, &vt596_smba)) || 343 !(vt596_smba & 0x0001)) { 344 /* try 2nd address and config reg. for 596 */ 345 if (id->device == PCI_DEVICE_ID_VIA_82C596_3 && 346 !pci_read_config_word(pdev, SMBBA2, &vt596_smba) && 347 (vt596_smba & 0x0001)) { 348 SMBHSTCFG = 0x84; 349 } else { 350 /* no matches at all */ 351 dev_err(&pdev->dev, "Cannot configure " 352 "SMBus I/O Base address\n"); 353 return -ENODEV; 354 } 355 } 356 357 vt596_smba &= 0xfff0; 358 if (vt596_smba == 0) { 359 dev_err(&pdev->dev, "SMBus base address " 360 "uninitialized - upgrade BIOS or use " 361 "force_addr=0xaddr\n"); 362 return -ENODEV; 363 } 364 365 found: 366 error = acpi_check_region(vt596_smba, 8, vt596_driver.name); 367 if (error) 368 return -ENODEV; 369 370 if (!request_region(vt596_smba, 8, vt596_driver.name)) { 371 dev_err(&pdev->dev, "SMBus region 0x%x already in use!\n", 372 vt596_smba); 373 return -ENODEV; 374 } 375 376 pci_read_config_byte(pdev, SMBHSTCFG, &temp); 377 /* If force_addr is set, we program the new address here. Just to make 378 sure, we disable the VT596 first. */ 379 if (force_addr) { 380 pci_write_config_byte(pdev, SMBHSTCFG, temp & 0xfe); 381 pci_write_config_word(pdev, id->driver_data, vt596_smba); 382 pci_write_config_byte(pdev, SMBHSTCFG, temp | 0x01); 383 dev_warn(&pdev->dev, "WARNING: SMBus interface set to new " 384 "address 0x%04x!\n", vt596_smba); 385 } else if (!(temp & 0x01)) { 386 if (force) { 387 /* NOTE: This assumes I/O space and other allocations 388 * WERE done by the Bios! Don't complain if your 389 * hardware does weird things after enabling this. 390 * :') Check for Bios updates before resorting to 391 * this. 392 */ 393 pci_write_config_byte(pdev, SMBHSTCFG, temp | 0x01); 394 dev_info(&pdev->dev, "Enabling SMBus device\n"); 395 } else { 396 dev_err(&pdev->dev, "SMBUS: Error: Host SMBus " 397 "controller not enabled! - upgrade BIOS or " 398 "use force=1\n"); 399 goto release_region; 400 } 401 } 402 403 dev_dbg(&pdev->dev, "VT596_smba = 0x%X\n", vt596_smba); 404 405 switch (pdev->device) { 406 case PCI_DEVICE_ID_VIA_CX700: 407 case PCI_DEVICE_ID_VIA_VX800: 408 case PCI_DEVICE_ID_VIA_VX855: 409 case PCI_DEVICE_ID_VIA_8251: 410 case PCI_DEVICE_ID_VIA_8237: 411 case PCI_DEVICE_ID_VIA_8237A: 412 case PCI_DEVICE_ID_VIA_8237S: 413 case PCI_DEVICE_ID_VIA_8235: 414 case PCI_DEVICE_ID_VIA_8233A: 415 case PCI_DEVICE_ID_VIA_8233_0: 416 vt596_features |= FEATURE_I2CBLOCK; 417 break; 418 case PCI_DEVICE_ID_VIA_82C686_4: 419 /* The VT82C686B (rev 0x40) does support I2C block 420 transactions, but the VT82C686A (rev 0x30) doesn't */ 421 if (pdev->revision >= 0x40) 422 vt596_features |= FEATURE_I2CBLOCK; 423 break; 424 } 425 426 vt596_adapter.dev.parent = &pdev->dev; 427 snprintf(vt596_adapter.name, sizeof(vt596_adapter.name), 428 "SMBus Via Pro adapter at %04x", vt596_smba); 429 430 vt596_pdev = pci_dev_get(pdev); 431 if (i2c_add_adapter(&vt596_adapter)) { 432 pci_dev_put(vt596_pdev); 433 vt596_pdev = NULL; 434 } 435 436 /* Always return failure here. This is to allow other drivers to bind 437 * to this pci device. We don't really want to have control over the 438 * pci device, we only wanted to read as few register values from it. 439 */ 440 return -ENODEV; 441 442 release_region: 443 release_region(vt596_smba, 8); 444 return error; 445 } 446 447 static struct pci_device_id vt596_ids[] = { 448 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C596_3), 449 .driver_data = SMBBA1 }, 450 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C596B_3), 451 .driver_data = SMBBA1 }, 452 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C686_4), 453 .driver_data = SMBBA1 }, 454 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8233_0), 455 .driver_data = SMBBA3 }, 456 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8233A), 457 .driver_data = SMBBA3 }, 458 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8235), 459 .driver_data = SMBBA3 }, 460 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8237), 461 .driver_data = SMBBA3 }, 462 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8237A), 463 .driver_data = SMBBA3 }, 464 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8237S), 465 .driver_data = SMBBA3 }, 466 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8231_4), 467 .driver_data = SMBBA1 }, 468 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8251), 469 .driver_data = SMBBA3 }, 470 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_CX700), 471 .driver_data = SMBBA3 }, 472 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_VX800), 473 .driver_data = SMBBA3 }, 474 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_VX855), 475 .driver_data = SMBBA3 }, 476 { 0, } 477 }; 478 479 MODULE_DEVICE_TABLE(pci, vt596_ids); 480 481 static struct pci_driver vt596_driver = { 482 .name = "vt596_smbus", 483 .id_table = vt596_ids, 484 .probe = vt596_probe, 485 }; 486 487 static int __init i2c_vt596_init(void) 488 { 489 return pci_register_driver(&vt596_driver); 490 } 491 492 493 static void __exit i2c_vt596_exit(void) 494 { 495 pci_unregister_driver(&vt596_driver); 496 if (vt596_pdev != NULL) { 497 i2c_del_adapter(&vt596_adapter); 498 release_region(vt596_smba, 8); 499 pci_dev_put(vt596_pdev); 500 vt596_pdev = NULL; 501 } 502 } 503 504 MODULE_AUTHOR("Kyosti Malkki <kmalkki@cc.hut.fi>, " 505 "Mark D. Studebaker <mdsxyz123@yahoo.com> and " 506 "Jean Delvare <khali@linux-fr.org>"); 507 MODULE_DESCRIPTION("vt82c596 SMBus driver"); 508 MODULE_LICENSE("GPL"); 509 510 module_init(i2c_vt596_init); 511 module_exit(i2c_vt596_exit); 512