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