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 41 Note: we assume there can only be one device, with one SMBus interface. 42 */ 43 44 #include <linux/module.h> 45 #include <linux/delay.h> 46 #include <linux/pci.h> 47 #include <linux/kernel.h> 48 #include <linux/stddef.h> 49 #include <linux/ioport.h> 50 #include <linux/i2c.h> 51 #include <linux/init.h> 52 #include <linux/acpi.h> 53 #include <asm/io.h> 54 55 static struct pci_dev *vt596_pdev; 56 57 #define SMBBA1 0x90 58 #define SMBBA2 0x80 59 #define SMBBA3 0xD0 60 61 /* SMBus address offsets */ 62 static unsigned short vt596_smba; 63 #define SMBHSTSTS (vt596_smba + 0) 64 #define SMBHSTCNT (vt596_smba + 2) 65 #define SMBHSTCMD (vt596_smba + 3) 66 #define SMBHSTADD (vt596_smba + 4) 67 #define SMBHSTDAT0 (vt596_smba + 5) 68 #define SMBHSTDAT1 (vt596_smba + 6) 69 #define SMBBLKDAT (vt596_smba + 7) 70 71 /* PCI Address Constants */ 72 73 /* SMBus data in configuration space can be found in two places, 74 We try to select the better one */ 75 76 static unsigned short SMBHSTCFG = 0xD2; 77 78 /* Other settings */ 79 #define MAX_TIMEOUT 500 80 81 /* VT82C596 constants */ 82 #define VT596_QUICK 0x00 83 #define VT596_BYTE 0x04 84 #define VT596_BYTE_DATA 0x08 85 #define VT596_WORD_DATA 0x0C 86 #define VT596_PROC_CALL 0x10 87 #define VT596_BLOCK_DATA 0x14 88 #define VT596_I2C_BLOCK_DATA 0x34 89 90 91 /* If force is set to anything different from 0, we forcibly enable the 92 VT596. DANGEROUS! */ 93 static int force; 94 module_param(force, bool, 0); 95 MODULE_PARM_DESC(force, "Forcibly enable the SMBus. DANGEROUS!"); 96 97 /* If force_addr is set to anything different from 0, we forcibly enable 98 the VT596 at the given address. VERY DANGEROUS! */ 99 static u16 force_addr; 100 module_param(force_addr, ushort, 0); 101 MODULE_PARM_DESC(force_addr, 102 "Forcibly enable the SMBus at the given address. " 103 "EXTREMELY DANGEROUS!"); 104 105 106 static struct pci_driver vt596_driver; 107 static struct i2c_adapter vt596_adapter; 108 109 #define FEATURE_I2CBLOCK (1<<0) 110 static unsigned int vt596_features; 111 112 #ifdef DEBUG 113 static void vt596_dump_regs(const char *msg, u8 size) 114 { 115 dev_dbg(&vt596_adapter.dev, "%s: STS=%02x CNT=%02x CMD=%02x ADD=%02x " 116 "DAT=%02x,%02x\n", msg, inb_p(SMBHSTSTS), inb_p(SMBHSTCNT), 117 inb_p(SMBHSTCMD), inb_p(SMBHSTADD), inb_p(SMBHSTDAT0), 118 inb_p(SMBHSTDAT1)); 119 120 if (size == VT596_BLOCK_DATA 121 || size == VT596_I2C_BLOCK_DATA) { 122 int i; 123 124 dev_dbg(&vt596_adapter.dev, "BLK="); 125 for (i = 0; i < I2C_SMBUS_BLOCK_MAX / 2; i++) 126 printk("%02x,", inb_p(SMBBLKDAT)); 127 printk("\n"); 128 dev_dbg(&vt596_adapter.dev, " "); 129 for (; i < I2C_SMBUS_BLOCK_MAX - 1; i++) 130 printk("%02x,", inb_p(SMBBLKDAT)); 131 printk("%02x\n", inb_p(SMBBLKDAT)); 132 } 133 } 134 #else 135 static inline void vt596_dump_regs(const char *msg, u8 size) { } 136 #endif 137 138 /* Return -1 on error, 0 on success */ 139 static int vt596_transaction(u8 size) 140 { 141 int temp; 142 int result = 0; 143 int timeout = 0; 144 145 vt596_dump_regs("Transaction (pre)", size); 146 147 /* Make sure the SMBus host is ready to start transmitting */ 148 if ((temp = inb_p(SMBHSTSTS)) & 0x1F) { 149 dev_dbg(&vt596_adapter.dev, "SMBus busy (0x%02x). " 150 "Resetting...\n", temp); 151 152 outb_p(temp, SMBHSTSTS); 153 if ((temp = inb_p(SMBHSTSTS)) & 0x1F) { 154 dev_err(&vt596_adapter.dev, "SMBus reset failed! " 155 "(0x%02x)\n", temp); 156 return -EBUSY; 157 } 158 } 159 160 /* Start the transaction by setting bit 6 */ 161 outb_p(0x40 | size, SMBHSTCNT); 162 163 /* We will always wait for a fraction of a second */ 164 do { 165 msleep(1); 166 temp = inb_p(SMBHSTSTS); 167 } while ((temp & 0x01) && (timeout++ < MAX_TIMEOUT)); 168 169 /* If the SMBus is still busy, we give up */ 170 if (timeout >= MAX_TIMEOUT) { 171 result = -ETIMEDOUT; 172 dev_err(&vt596_adapter.dev, "SMBus timeout!\n"); 173 } 174 175 if (temp & 0x10) { 176 result = -EIO; 177 dev_err(&vt596_adapter.dev, "Transaction failed (0x%02x)\n", 178 size); 179 } 180 181 if (temp & 0x08) { 182 result = -EIO; 183 dev_err(&vt596_adapter.dev, "SMBus collision!\n"); 184 } 185 186 if (temp & 0x04) { 187 int read = inb_p(SMBHSTADD) & 0x01; 188 result = -ENXIO; 189 /* The quick and receive byte commands are used to probe 190 for chips, so errors are expected, and we don't want 191 to frighten the user. */ 192 if (!((size == VT596_QUICK && !read) || 193 (size == VT596_BYTE && read))) 194 dev_err(&vt596_adapter.dev, "Transaction error!\n"); 195 } 196 197 /* Resetting status register */ 198 if (temp & 0x1F) 199 outb_p(temp, SMBHSTSTS); 200 201 vt596_dump_regs("Transaction (post)", size); 202 203 return result; 204 } 205 206 /* Return negative errno on error, 0 on success */ 207 static s32 vt596_access(struct i2c_adapter *adap, u16 addr, 208 unsigned short flags, char read_write, u8 command, 209 int size, union i2c_smbus_data *data) 210 { 211 int i; 212 int status; 213 214 switch (size) { 215 case I2C_SMBUS_QUICK: 216 size = VT596_QUICK; 217 break; 218 case I2C_SMBUS_BYTE: 219 if (read_write == I2C_SMBUS_WRITE) 220 outb_p(command, SMBHSTCMD); 221 size = VT596_BYTE; 222 break; 223 case I2C_SMBUS_BYTE_DATA: 224 outb_p(command, SMBHSTCMD); 225 if (read_write == I2C_SMBUS_WRITE) 226 outb_p(data->byte, SMBHSTDAT0); 227 size = VT596_BYTE_DATA; 228 break; 229 case I2C_SMBUS_WORD_DATA: 230 outb_p(command, SMBHSTCMD); 231 if (read_write == I2C_SMBUS_WRITE) { 232 outb_p(data->word & 0xff, SMBHSTDAT0); 233 outb_p((data->word & 0xff00) >> 8, SMBHSTDAT1); 234 } 235 size = VT596_WORD_DATA; 236 break; 237 case I2C_SMBUS_PROC_CALL: 238 outb_p(command, SMBHSTCMD); 239 outb_p(data->word & 0xff, SMBHSTDAT0); 240 outb_p((data->word & 0xff00) >> 8, SMBHSTDAT1); 241 size = VT596_PROC_CALL; 242 break; 243 case I2C_SMBUS_I2C_BLOCK_DATA: 244 if (!(vt596_features & FEATURE_I2CBLOCK)) 245 goto exit_unsupported; 246 if (read_write == I2C_SMBUS_READ) 247 outb_p(data->block[0], SMBHSTDAT0); 248 /* Fall through */ 249 case I2C_SMBUS_BLOCK_DATA: 250 outb_p(command, SMBHSTCMD); 251 if (read_write == I2C_SMBUS_WRITE) { 252 u8 len = data->block[0]; 253 if (len > I2C_SMBUS_BLOCK_MAX) 254 len = I2C_SMBUS_BLOCK_MAX; 255 outb_p(len, SMBHSTDAT0); 256 inb_p(SMBHSTCNT); /* Reset SMBBLKDAT */ 257 for (i = 1; i <= len; i++) 258 outb_p(data->block[i], SMBBLKDAT); 259 } 260 size = (size == I2C_SMBUS_I2C_BLOCK_DATA) ? 261 VT596_I2C_BLOCK_DATA : VT596_BLOCK_DATA; 262 break; 263 default: 264 goto exit_unsupported; 265 } 266 267 outb_p(((addr & 0x7f) << 1) | read_write, SMBHSTADD); 268 269 status = vt596_transaction(size); 270 if (status) 271 return status; 272 273 if (size == VT596_PROC_CALL) 274 read_write = I2C_SMBUS_READ; 275 276 if ((read_write == I2C_SMBUS_WRITE) || (size == VT596_QUICK)) 277 return 0; 278 279 switch (size) { 280 case VT596_BYTE: 281 case VT596_BYTE_DATA: 282 data->byte = inb_p(SMBHSTDAT0); 283 break; 284 case VT596_WORD_DATA: 285 case VT596_PROC_CALL: 286 data->word = inb_p(SMBHSTDAT0) + (inb_p(SMBHSTDAT1) << 8); 287 break; 288 case VT596_I2C_BLOCK_DATA: 289 case VT596_BLOCK_DATA: 290 data->block[0] = inb_p(SMBHSTDAT0); 291 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) 292 data->block[0] = I2C_SMBUS_BLOCK_MAX; 293 inb_p(SMBHSTCNT); /* Reset SMBBLKDAT */ 294 for (i = 1; i <= data->block[0]; i++) 295 data->block[i] = inb_p(SMBBLKDAT); 296 break; 297 } 298 return 0; 299 300 exit_unsupported: 301 dev_warn(&vt596_adapter.dev, "Unsupported transaction %d\n", 302 size); 303 return -EOPNOTSUPP; 304 } 305 306 static u32 vt596_func(struct i2c_adapter *adapter) 307 { 308 u32 func = I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE | 309 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA | 310 I2C_SMBUS_PROC_CALL | I2C_FUNC_SMBUS_BLOCK_DATA; 311 312 if (vt596_features & FEATURE_I2CBLOCK) 313 func |= I2C_FUNC_SMBUS_I2C_BLOCK; 314 return func; 315 } 316 317 static const struct i2c_algorithm smbus_algorithm = { 318 .smbus_xfer = vt596_access, 319 .functionality = vt596_func, 320 }; 321 322 static struct i2c_adapter vt596_adapter = { 323 .owner = THIS_MODULE, 324 .id = I2C_HW_SMBUS_VIA2, 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 error; 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_8251: 409 case PCI_DEVICE_ID_VIA_8237: 410 case PCI_DEVICE_ID_VIA_8237A: 411 case PCI_DEVICE_ID_VIA_8237S: 412 case PCI_DEVICE_ID_VIA_8235: 413 case PCI_DEVICE_ID_VIA_8233A: 414 case PCI_DEVICE_ID_VIA_8233_0: 415 vt596_features |= FEATURE_I2CBLOCK; 416 break; 417 case PCI_DEVICE_ID_VIA_82C686_4: 418 /* The VT82C686B (rev 0x40) does support I2C block 419 transactions, but the VT82C686A (rev 0x30) doesn't */ 420 if (pdev->revision >= 0x40) 421 vt596_features |= FEATURE_I2CBLOCK; 422 break; 423 } 424 425 vt596_adapter.dev.parent = &pdev->dev; 426 snprintf(vt596_adapter.name, sizeof(vt596_adapter.name), 427 "SMBus Via Pro adapter at %04x", vt596_smba); 428 429 vt596_pdev = pci_dev_get(pdev); 430 if (i2c_add_adapter(&vt596_adapter)) { 431 pci_dev_put(vt596_pdev); 432 vt596_pdev = NULL; 433 } 434 435 /* Always return failure here. This is to allow other drivers to bind 436 * to this pci device. We don't really want to have control over the 437 * pci device, we only wanted to read as few register values from it. 438 */ 439 return -ENODEV; 440 441 release_region: 442 release_region(vt596_smba, 8); 443 return error; 444 } 445 446 static struct pci_device_id vt596_ids[] = { 447 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C596_3), 448 .driver_data = SMBBA1 }, 449 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C596B_3), 450 .driver_data = SMBBA1 }, 451 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C686_4), 452 .driver_data = SMBBA1 }, 453 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8233_0), 454 .driver_data = SMBBA3 }, 455 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8233A), 456 .driver_data = SMBBA3 }, 457 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8235), 458 .driver_data = SMBBA3 }, 459 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8237), 460 .driver_data = SMBBA3 }, 461 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8237A), 462 .driver_data = SMBBA3 }, 463 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8237S), 464 .driver_data = SMBBA3 }, 465 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8231_4), 466 .driver_data = SMBBA1 }, 467 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8251), 468 .driver_data = SMBBA3 }, 469 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_CX700), 470 .driver_data = SMBBA3 }, 471 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_VX800), 472 .driver_data = SMBBA3 }, 473 { 0, } 474 }; 475 476 MODULE_DEVICE_TABLE(pci, vt596_ids); 477 478 static struct pci_driver vt596_driver = { 479 .name = "vt596_smbus", 480 .id_table = vt596_ids, 481 .probe = vt596_probe, 482 }; 483 484 static int __init i2c_vt596_init(void) 485 { 486 return pci_register_driver(&vt596_driver); 487 } 488 489 490 static void __exit i2c_vt596_exit(void) 491 { 492 pci_unregister_driver(&vt596_driver); 493 if (vt596_pdev != NULL) { 494 i2c_del_adapter(&vt596_adapter); 495 release_region(vt596_smba, 8); 496 pci_dev_put(vt596_pdev); 497 vt596_pdev = NULL; 498 } 499 } 500 501 MODULE_AUTHOR("Kyosti Malkki <kmalkki@cc.hut.fi>, " 502 "Mark D. Studebaker <mdsxyz123@yahoo.com> and " 503 "Jean Delvare <khali@linux-fr.org>"); 504 MODULE_DESCRIPTION("vt82c596 SMBus driver"); 505 MODULE_LICENSE("GPL"); 506 507 module_init(i2c_vt596_init); 508 module_exit(i2c_vt596_exit); 509