1 /* 2 Copyright (c) 2002,2003 Alexander Malysh <amalysh@web.de> 3 4 This program is free software; you can redistribute it and/or modify 5 it under the terms of the GNU General Public License as published by 6 the Free Software Foundation; either version 2 of the License, or 7 (at your option) any later version. 8 9 This program is distributed in the hope that it will be useful, 10 but WITHOUT ANY WARRANTY; without even the implied warranty of 11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 GNU General Public License for more details. 13 */ 14 15 /* 16 Status: beta 17 18 Supports: 19 SIS 630 20 SIS 730 21 SIS 964 22 23 Notable differences between chips: 24 +------------------------+--------------------+-------------------+ 25 | | SIS630/730 | SIS964 | 26 +------------------------+--------------------+-------------------+ 27 | Clock | 14kHz/56kHz | 55.56kHz/27.78kHz | 28 | SMBus registers offset | 0x80 | 0xE0 | 29 | SMB_CNT | Bit 1 = Slave Busy | Bit 1 = Bus probe | 30 | (not used yet) | Bit 3 is reserved | Bit 3 = Last byte | 31 | SMB_PCOUNT | Offset + 0x06 | Offset + 0x14 | 32 | SMB_COUNT | 4:0 bits | 5:0 bits | 33 +------------------------+--------------------+-------------------+ 34 (Other differences don't affect the functions provided by the driver) 35 36 Note: we assume there can only be one device, with one SMBus interface. 37 */ 38 39 #include <linux/kernel.h> 40 #include <linux/module.h> 41 #include <linux/delay.h> 42 #include <linux/pci.h> 43 #include <linux/ioport.h> 44 #include <linux/i2c.h> 45 #include <linux/acpi.h> 46 #include <linux/io.h> 47 48 /* SIS964 id is defined here as we are the only file using it */ 49 #define PCI_DEVICE_ID_SI_964 0x0964 50 51 /* SIS630/730/964 SMBus registers */ 52 #define SMB_STS 0x00 /* status */ 53 #define SMB_CNT 0x02 /* control */ 54 #define SMBHOST_CNT 0x03 /* host control */ 55 #define SMB_ADDR 0x04 /* address */ 56 #define SMB_CMD 0x05 /* command */ 57 #define SMB_COUNT 0x07 /* byte count */ 58 #define SMB_BYTE 0x08 /* ~0x8F data byte field */ 59 60 /* SMB_STS register */ 61 #define BYTE_DONE_STS 0x10 /* Byte Done Status / Block Array */ 62 #define SMBCOL_STS 0x04 /* Collision */ 63 #define SMBERR_STS 0x02 /* Device error */ 64 65 /* SMB_CNT register */ 66 #define MSTO_EN 0x40 /* Host Master Timeout Enable */ 67 #define SMBCLK_SEL 0x20 /* Host master clock selection */ 68 #define SMB_PROBE 0x02 /* Bus Probe/Slave busy */ 69 #define SMB_HOSTBUSY 0x01 /* Host Busy */ 70 71 /* SMBHOST_CNT register */ 72 #define SMB_KILL 0x20 /* Kill */ 73 #define SMB_START 0x10 /* Start */ 74 75 /* register count for request_region 76 * As we don't use SMB_PCOUNT, 20 is ok for SiS630 and SiS964 77 */ 78 #define SIS630_SMB_IOREGION 20 79 80 /* PCI address constants */ 81 /* acpi base address register */ 82 #define SIS630_ACPI_BASE_REG 0x74 83 /* bios control register */ 84 #define SIS630_BIOS_CTL_REG 0x40 85 86 /* Other settings */ 87 #define MAX_TIMEOUT 500 88 89 /* SIS630 constants */ 90 #define SIS630_QUICK 0x00 91 #define SIS630_BYTE 0x01 92 #define SIS630_BYTE_DATA 0x02 93 #define SIS630_WORD_DATA 0x03 94 #define SIS630_PCALL 0x04 95 #define SIS630_BLOCK_DATA 0x05 96 97 static struct pci_driver sis630_driver; 98 99 /* insmod parameters */ 100 static bool high_clock; 101 static bool force; 102 module_param(high_clock, bool, 0); 103 MODULE_PARM_DESC(high_clock, 104 "Set Host Master Clock to 56KHz (default 14KHz) (SIS630/730 only)."); 105 module_param(force, bool, 0); 106 MODULE_PARM_DESC(force, "Forcibly enable the SIS630. DANGEROUS!"); 107 108 /* SMBus base adress */ 109 static unsigned short smbus_base; 110 111 /* supported chips */ 112 static int supported[] = { 113 PCI_DEVICE_ID_SI_630, 114 PCI_DEVICE_ID_SI_730, 115 PCI_DEVICE_ID_SI_760, 116 0 /* terminates the list */ 117 }; 118 119 static inline u8 sis630_read(u8 reg) 120 { 121 return inb(smbus_base + reg); 122 } 123 124 static inline void sis630_write(u8 reg, u8 data) 125 { 126 outb(data, smbus_base + reg); 127 } 128 129 static int sis630_transaction_start(struct i2c_adapter *adap, int size, 130 u8 *oldclock) 131 { 132 int temp; 133 134 /* Make sure the SMBus host is ready to start transmitting. */ 135 temp = sis630_read(SMB_CNT); 136 if ((temp & (SMB_PROBE | SMB_HOSTBUSY)) != 0x00) { 137 dev_dbg(&adap->dev, "SMBus busy (%02x). Resetting...\n", temp); 138 /* kill smbus transaction */ 139 sis630_write(SMBHOST_CNT, SMB_KILL); 140 141 temp = sis630_read(SMB_CNT); 142 if (temp & (SMB_PROBE | SMB_HOSTBUSY)) { 143 dev_dbg(&adap->dev, "Failed! (%02x)\n", temp); 144 return -EBUSY; 145 } else { 146 dev_dbg(&adap->dev, "Successful!\n"); 147 } 148 } 149 150 /* save old clock, so we can prevent machine for hung */ 151 *oldclock = sis630_read(SMB_CNT); 152 153 dev_dbg(&adap->dev, "saved clock 0x%02x\n", *oldclock); 154 155 /* disable timeout interrupt, 156 * set Host Master Clock to 56KHz if requested */ 157 if (high_clock) 158 sis630_write(SMB_CNT, SMBCLK_SEL); 159 else 160 sis630_write(SMB_CNT, (*oldclock & ~MSTO_EN)); 161 162 /* clear all sticky bits */ 163 temp = sis630_read(SMB_STS); 164 sis630_write(SMB_STS, temp & 0x1e); 165 166 /* start the transaction by setting bit 4 and size */ 167 sis630_write(SMBHOST_CNT, SMB_START | (size & 0x07)); 168 169 return 0; 170 } 171 172 static int sis630_transaction_wait(struct i2c_adapter *adap, int size) 173 { 174 int temp, result = 0, timeout = 0; 175 176 /* We will always wait for a fraction of a second! */ 177 do { 178 msleep(1); 179 temp = sis630_read(SMB_STS); 180 /* check if block transmitted */ 181 if (size == SIS630_BLOCK_DATA && (temp & BYTE_DONE_STS)) 182 break; 183 } while (!(temp & 0x0e) && (timeout++ < MAX_TIMEOUT)); 184 185 /* If the SMBus is still busy, we give up */ 186 if (timeout > MAX_TIMEOUT) { 187 dev_dbg(&adap->dev, "SMBus Timeout!\n"); 188 result = -ETIMEDOUT; 189 } 190 191 if (temp & SMBERR_STS) { 192 dev_dbg(&adap->dev, "Error: Failed bus transaction\n"); 193 result = -ENXIO; 194 } 195 196 if (temp & SMBCOL_STS) { 197 dev_err(&adap->dev, "Bus collision!\n"); 198 result = -EAGAIN; 199 } 200 201 return result; 202 } 203 204 static void sis630_transaction_end(struct i2c_adapter *adap, u8 oldclock) 205 { 206 /* clear all status "sticky" bits */ 207 sis630_write(SMB_STS, 0xFF); 208 209 dev_dbg(&adap->dev, 210 "SMB_CNT before clock restore 0x%02x\n", sis630_read(SMB_CNT)); 211 212 /* 213 * restore old Host Master Clock if high_clock is set 214 * and oldclock was not 56KHz 215 */ 216 if (high_clock && !(oldclock & SMBCLK_SEL)) 217 sis630_write(SMB_CNT, sis630_read(SMB_CNT) & ~SMBCLK_SEL); 218 219 dev_dbg(&adap->dev, 220 "SMB_CNT after clock restore 0x%02x\n", sis630_read(SMB_CNT)); 221 } 222 223 static int sis630_transaction(struct i2c_adapter *adap, int size) 224 { 225 int result = 0; 226 u8 oldclock = 0; 227 228 result = sis630_transaction_start(adap, size, &oldclock); 229 if (!result) { 230 result = sis630_transaction_wait(adap, size); 231 sis630_transaction_end(adap, oldclock); 232 } 233 234 return result; 235 } 236 237 static int sis630_block_data(struct i2c_adapter *adap, 238 union i2c_smbus_data *data, int read_write) 239 { 240 int i, len = 0, rc = 0; 241 u8 oldclock = 0; 242 243 if (read_write == I2C_SMBUS_WRITE) { 244 len = data->block[0]; 245 if (len < 0) 246 len = 0; 247 else if (len > 32) 248 len = 32; 249 sis630_write(SMB_COUNT, len); 250 for (i = 1; i <= len; i++) { 251 dev_dbg(&adap->dev, 252 "set data 0x%02x\n", data->block[i]); 253 /* set data */ 254 sis630_write(SMB_BYTE + (i - 1) % 8, data->block[i]); 255 if (i == 8 || (len < 8 && i == len)) { 256 dev_dbg(&adap->dev, 257 "start trans len=%d i=%d\n", len, i); 258 /* first transaction */ 259 rc = sis630_transaction_start(adap, 260 SIS630_BLOCK_DATA, &oldclock); 261 if (rc) 262 return rc; 263 } else if ((i - 1) % 8 == 7 || i == len) { 264 dev_dbg(&adap->dev, 265 "trans_wait len=%d i=%d\n", len, i); 266 if (i > 8) { 267 dev_dbg(&adap->dev, 268 "clear smbary_sts" 269 " len=%d i=%d\n", len, i); 270 /* 271 If this is not first transaction, 272 we must clear sticky bit. 273 clear SMBARY_STS 274 */ 275 sis630_write(SMB_STS, BYTE_DONE_STS); 276 } 277 rc = sis630_transaction_wait(adap, 278 SIS630_BLOCK_DATA); 279 if (rc) { 280 dev_dbg(&adap->dev, 281 "trans_wait failed\n"); 282 break; 283 } 284 } 285 } 286 } else { 287 /* read request */ 288 data->block[0] = len = 0; 289 rc = sis630_transaction_start(adap, 290 SIS630_BLOCK_DATA, &oldclock); 291 if (rc) 292 return rc; 293 do { 294 rc = sis630_transaction_wait(adap, SIS630_BLOCK_DATA); 295 if (rc) { 296 dev_dbg(&adap->dev, "trans_wait failed\n"); 297 break; 298 } 299 /* if this first transaction then read byte count */ 300 if (len == 0) 301 data->block[0] = sis630_read(SMB_COUNT); 302 303 /* just to be sure */ 304 if (data->block[0] > 32) 305 data->block[0] = 32; 306 307 dev_dbg(&adap->dev, 308 "block data read len=0x%x\n", data->block[0]); 309 310 for (i = 0; i < 8 && len < data->block[0]; i++, len++) { 311 dev_dbg(&adap->dev, 312 "read i=%d len=%d\n", i, len); 313 data->block[len + 1] = sis630_read(SMB_BYTE + 314 i); 315 } 316 317 dev_dbg(&adap->dev, 318 "clear smbary_sts len=%d i=%d\n", len, i); 319 320 /* clear SMBARY_STS */ 321 sis630_write(SMB_STS, BYTE_DONE_STS); 322 } while (len < data->block[0]); 323 } 324 325 sis630_transaction_end(adap, oldclock); 326 327 return rc; 328 } 329 330 /* Return negative errno on error. */ 331 static s32 sis630_access(struct i2c_adapter *adap, u16 addr, 332 unsigned short flags, char read_write, 333 u8 command, int size, union i2c_smbus_data *data) 334 { 335 int status; 336 337 switch (size) { 338 case I2C_SMBUS_QUICK: 339 sis630_write(SMB_ADDR, 340 ((addr & 0x7f) << 1) | (read_write & 0x01)); 341 size = SIS630_QUICK; 342 break; 343 case I2C_SMBUS_BYTE: 344 sis630_write(SMB_ADDR, 345 ((addr & 0x7f) << 1) | (read_write & 0x01)); 346 if (read_write == I2C_SMBUS_WRITE) 347 sis630_write(SMB_CMD, command); 348 size = SIS630_BYTE; 349 break; 350 case I2C_SMBUS_BYTE_DATA: 351 sis630_write(SMB_ADDR, 352 ((addr & 0x7f) << 1) | (read_write & 0x01)); 353 sis630_write(SMB_CMD, command); 354 if (read_write == I2C_SMBUS_WRITE) 355 sis630_write(SMB_BYTE, data->byte); 356 size = SIS630_BYTE_DATA; 357 break; 358 case I2C_SMBUS_PROC_CALL: 359 case I2C_SMBUS_WORD_DATA: 360 sis630_write(SMB_ADDR, 361 ((addr & 0x7f) << 1) | (read_write & 0x01)); 362 sis630_write(SMB_CMD, command); 363 if (read_write == I2C_SMBUS_WRITE) { 364 sis630_write(SMB_BYTE, data->word & 0xff); 365 sis630_write(SMB_BYTE + 1, (data->word & 0xff00) >> 8); 366 } 367 size = (size == I2C_SMBUS_PROC_CALL ? 368 SIS630_PCALL : SIS630_WORD_DATA); 369 break; 370 case I2C_SMBUS_BLOCK_DATA: 371 sis630_write(SMB_ADDR, 372 ((addr & 0x7f) << 1) | (read_write & 0x01)); 373 sis630_write(SMB_CMD, command); 374 size = SIS630_BLOCK_DATA; 375 return sis630_block_data(adap, data, read_write); 376 default: 377 dev_warn(&adap->dev, "Unsupported transaction %d\n", size); 378 return -EOPNOTSUPP; 379 } 380 381 status = sis630_transaction(adap, size); 382 if (status) 383 return status; 384 385 if ((size != SIS630_PCALL) && 386 ((read_write == I2C_SMBUS_WRITE) || (size == SIS630_QUICK))) { 387 return 0; 388 } 389 390 switch (size) { 391 case SIS630_BYTE: 392 case SIS630_BYTE_DATA: 393 data->byte = sis630_read(SMB_BYTE); 394 break; 395 case SIS630_PCALL: 396 case SIS630_WORD_DATA: 397 data->word = sis630_read(SMB_BYTE) + 398 (sis630_read(SMB_BYTE + 1) << 8); 399 break; 400 } 401 402 return 0; 403 } 404 405 static u32 sis630_func(struct i2c_adapter *adapter) 406 { 407 return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE | 408 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA | 409 I2C_FUNC_SMBUS_PROC_CALL | I2C_FUNC_SMBUS_BLOCK_DATA; 410 } 411 412 static int sis630_setup(struct pci_dev *sis630_dev) 413 { 414 unsigned char b; 415 struct pci_dev *dummy = NULL; 416 int retval, i; 417 /* acpi base address */ 418 unsigned short acpi_base; 419 420 /* check for supported SiS devices */ 421 for (i = 0; supported[i] > 0; i++) { 422 dummy = pci_get_device(PCI_VENDOR_ID_SI, supported[i], dummy); 423 if (dummy) 424 break; /* found */ 425 } 426 427 if (dummy) { 428 pci_dev_put(dummy); 429 } else if (force) { 430 dev_err(&sis630_dev->dev, 431 "WARNING: Can't detect SIS630 compatible device, but " 432 "loading because of force option enabled\n"); 433 } else { 434 return -ENODEV; 435 } 436 437 /* 438 Enable ACPI first , so we can accsess reg 74-75 439 in acpi io space and read acpi base addr 440 */ 441 if (pci_read_config_byte(sis630_dev, SIS630_BIOS_CTL_REG, &b)) { 442 dev_err(&sis630_dev->dev, "Error: Can't read bios ctl reg\n"); 443 retval = -ENODEV; 444 goto exit; 445 } 446 /* if ACPI already enabled , do nothing */ 447 if (!(b & 0x80) && 448 pci_write_config_byte(sis630_dev, SIS630_BIOS_CTL_REG, b | 0x80)) { 449 dev_err(&sis630_dev->dev, "Error: Can't enable ACPI\n"); 450 retval = -ENODEV; 451 goto exit; 452 } 453 454 /* Determine the ACPI base address */ 455 if (pci_read_config_word(sis630_dev, 456 SIS630_ACPI_BASE_REG, &acpi_base)) { 457 dev_err(&sis630_dev->dev, 458 "Error: Can't determine ACPI base address\n"); 459 retval = -ENODEV; 460 goto exit; 461 } 462 463 dev_dbg(&sis630_dev->dev, "ACPI base at 0x%04hx\n", acpi_base); 464 465 if (supported[i] == PCI_DEVICE_ID_SI_760) 466 smbus_base = acpi_base + 0xE0; 467 else 468 smbus_base = acpi_base + 0x80; 469 470 dev_dbg(&sis630_dev->dev, "SMBus base at 0x%04hx\n", smbus_base); 471 472 retval = acpi_check_region(smbus_base + SMB_STS, SIS630_SMB_IOREGION, 473 sis630_driver.name); 474 if (retval) 475 goto exit; 476 477 /* Everything is happy, let's grab the memory and set things up. */ 478 if (!request_region(smbus_base + SMB_STS, SIS630_SMB_IOREGION, 479 sis630_driver.name)) { 480 dev_err(&sis630_dev->dev, 481 "I/O Region 0x%04x-0x%04x for SMBus already in use.\n", 482 smbus_base + SMB_STS, 483 smbus_base + SMB_STS + SIS630_SMB_IOREGION - 1); 484 retval = -EBUSY; 485 goto exit; 486 } 487 488 retval = 0; 489 490 exit: 491 if (retval) 492 smbus_base = 0; 493 return retval; 494 } 495 496 497 static const struct i2c_algorithm smbus_algorithm = { 498 .smbus_xfer = sis630_access, 499 .functionality = sis630_func, 500 }; 501 502 static struct i2c_adapter sis630_adapter = { 503 .owner = THIS_MODULE, 504 .class = I2C_CLASS_HWMON | I2C_CLASS_SPD, 505 .algo = &smbus_algorithm, 506 .retries = 3 507 }; 508 509 static const struct pci_device_id sis630_ids[] = { 510 { PCI_DEVICE(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_503) }, 511 { PCI_DEVICE(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_LPC) }, 512 { PCI_DEVICE(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_964) }, 513 { 0, } 514 }; 515 516 MODULE_DEVICE_TABLE(pci, sis630_ids); 517 518 static int sis630_probe(struct pci_dev *dev, const struct pci_device_id *id) 519 { 520 if (sis630_setup(dev)) { 521 dev_err(&dev->dev, 522 "SIS630 compatible bus not detected, " 523 "module not inserted.\n"); 524 return -ENODEV; 525 } 526 527 /* set up the sysfs linkage to our parent device */ 528 sis630_adapter.dev.parent = &dev->dev; 529 530 snprintf(sis630_adapter.name, sizeof(sis630_adapter.name), 531 "SMBus SIS630 adapter at %04x", smbus_base + SMB_STS); 532 533 return i2c_add_adapter(&sis630_adapter); 534 } 535 536 static void sis630_remove(struct pci_dev *dev) 537 { 538 if (smbus_base) { 539 i2c_del_adapter(&sis630_adapter); 540 release_region(smbus_base + SMB_STS, SIS630_SMB_IOREGION); 541 smbus_base = 0; 542 } 543 } 544 545 546 static struct pci_driver sis630_driver = { 547 .name = "sis630_smbus", 548 .id_table = sis630_ids, 549 .probe = sis630_probe, 550 .remove = sis630_remove, 551 }; 552 553 module_pci_driver(sis630_driver); 554 555 MODULE_LICENSE("GPL"); 556 MODULE_AUTHOR("Alexander Malysh <amalysh@web.de>"); 557 MODULE_DESCRIPTION("SIS630 SMBus driver"); 558