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