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