1 /* 2 i2c-sis630.c - Part of lm_sensors, Linux kernel modules for hardware 3 monitoring 4 5 Copyright (c) 2002,2003 Alexander Malysh <amalysh@web.de> 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 Changes: 24 24.08.2002 25 Fixed the typo in sis630_access (Thanks to Mark M. Hoffman) 26 Changed sis630_transaction.(Thanks to Mark M. Hoffman) 27 18.09.2002 28 Added SIS730 as supported. 29 21.09.2002 30 Added high_clock module option.If this option is set 31 used Host Master Clock 56KHz (default 14KHz).For now we save old Host 32 Master Clock and after transaction completed restore (otherwise 33 it's confuse BIOS and hung Machine). 34 24.09.2002 35 Fixed typo in sis630_access 36 Fixed logical error by restoring of Host Master Clock 37 31.07.2003 38 Added block data read/write support. 39 */ 40 41 /* 42 Status: beta 43 44 Supports: 45 SIS 630 46 SIS 730 47 48 Note: we assume there can only be one device, with one SMBus interface. 49 */ 50 51 #include <linux/config.h> 52 #include <linux/kernel.h> 53 #include <linux/module.h> 54 #include <linux/delay.h> 55 #include <linux/pci.h> 56 #include <linux/ioport.h> 57 #include <linux/init.h> 58 #include <linux/i2c.h> 59 #include <asm/io.h> 60 61 /* SIS630 SMBus registers */ 62 #define SMB_STS 0x80 /* status */ 63 #define SMB_EN 0x81 /* status enable */ 64 #define SMB_CNT 0x82 65 #define SMBHOST_CNT 0x83 66 #define SMB_ADDR 0x84 67 #define SMB_CMD 0x85 68 #define SMB_PCOUNT 0x86 /* processed count */ 69 #define SMB_COUNT 0x87 70 #define SMB_BYTE 0x88 /* ~0x8F data byte field */ 71 #define SMBDEV_ADDR 0x90 72 #define SMB_DB0 0x91 73 #define SMB_DB1 0x92 74 #define SMB_SAA 0x93 75 76 /* register count for request_region */ 77 #define SIS630_SMB_IOREGION 20 78 79 /* PCI address constants */ 80 /* acpi base address register */ 81 #define SIS630_ACPI_BASE_REG 0x74 82 /* bios control register */ 83 #define SIS630_BIOS_CTL_REG 0x40 84 85 /* Other settings */ 86 #define MAX_TIMEOUT 500 87 88 /* SIS630 constants */ 89 #define SIS630_QUICK 0x00 90 #define SIS630_BYTE 0x01 91 #define SIS630_BYTE_DATA 0x02 92 #define SIS630_WORD_DATA 0x03 93 #define SIS630_PCALL 0x04 94 #define SIS630_BLOCK_DATA 0x05 95 96 /* insmod parameters */ 97 static int high_clock; 98 static int force; 99 module_param(high_clock, bool, 0); 100 MODULE_PARM_DESC(high_clock, "Set Host Master Clock to 56KHz (default 14KHz)."); 101 module_param(force, bool, 0); 102 MODULE_PARM_DESC(force, "Forcibly enable the SIS630. DANGEROUS!"); 103 104 /* acpi base address */ 105 static unsigned short acpi_base = 0; 106 107 /* supported chips */ 108 static int supported[] = { 109 PCI_DEVICE_ID_SI_630, 110 PCI_DEVICE_ID_SI_730, 111 0 /* terminates the list */ 112 }; 113 114 static inline u8 sis630_read(u8 reg) 115 { 116 return inb(acpi_base + reg); 117 } 118 119 static inline void sis630_write(u8 reg, u8 data) 120 { 121 outb(data, acpi_base + reg); 122 } 123 124 static int sis630_transaction_start(struct i2c_adapter *adap, int size, u8 *oldclock) 125 { 126 int temp; 127 128 /* Make sure the SMBus host is ready to start transmitting. */ 129 if ((temp = sis630_read(SMB_CNT) & 0x03) != 0x00) { 130 dev_dbg(&adap->dev, "SMBus busy (%02x).Resetting...\n",temp); 131 /* kill smbus transaction */ 132 sis630_write(SMBHOST_CNT, 0x20); 133 134 if ((temp = sis630_read(SMB_CNT) & 0x03) != 0x00) { 135 dev_dbg(&adap->dev, "Failed! (%02x)\n", temp); 136 return -1; 137 } else { 138 dev_dbg(&adap->dev, "Successfull!\n"); 139 } 140 } 141 142 /* save old clock, so we can prevent machine for hung */ 143 *oldclock = sis630_read(SMB_CNT); 144 145 dev_dbg(&adap->dev, "saved clock 0x%02x\n", *oldclock); 146 147 /* disable timeout interrupt , set Host Master Clock to 56KHz if requested */ 148 if (high_clock) 149 sis630_write(SMB_CNT, 0x20); 150 else 151 sis630_write(SMB_CNT, (*oldclock & ~0x40)); 152 153 /* clear all sticky bits */ 154 temp = sis630_read(SMB_STS); 155 sis630_write(SMB_STS, temp & 0x1e); 156 157 /* start the transaction by setting bit 4 and size */ 158 sis630_write(SMBHOST_CNT,0x10 | (size & 0x07)); 159 160 return 0; 161 } 162 163 static int sis630_transaction_wait(struct i2c_adapter *adap, int size) 164 { 165 int temp, result = 0, timeout = 0; 166 167 /* We will always wait for a fraction of a second! */ 168 do { 169 msleep(1); 170 temp = sis630_read(SMB_STS); 171 /* check if block transmitted */ 172 if (size == SIS630_BLOCK_DATA && (temp & 0x10)) 173 break; 174 } while (!(temp & 0x0e) && (timeout++ < MAX_TIMEOUT)); 175 176 /* If the SMBus is still busy, we give up */ 177 if (timeout >= MAX_TIMEOUT) { 178 dev_dbg(&adap->dev, "SMBus Timeout!\n"); 179 result = -1; 180 } 181 182 if (temp & 0x02) { 183 dev_dbg(&adap->dev, "Error: Failed bus transaction\n"); 184 result = -1; 185 } 186 187 if (temp & 0x04) { 188 dev_err(&adap->dev, "Bus collision!\n"); 189 result = -1; 190 /* 191 TBD: Datasheet say: 192 the software should clear this bit and restart SMBUS operation. 193 Should we do it or user start request again? 194 */ 195 } 196 197 return result; 198 } 199 200 static void sis630_transaction_end(struct i2c_adapter *adap, u8 oldclock) 201 { 202 int temp = 0; 203 204 /* clear all status "sticky" bits */ 205 sis630_write(SMB_STS, temp); 206 207 dev_dbg(&adap->dev, "SMB_CNT before clock restore 0x%02x\n", sis630_read(SMB_CNT)); 208 209 /* 210 * restore old Host Master Clock if high_clock is set 211 * and oldclock was not 56KHz 212 */ 213 if (high_clock && !(oldclock & 0x20)) 214 sis630_write(SMB_CNT,(sis630_read(SMB_CNT) & ~0x20)); 215 216 dev_dbg(&adap->dev, "SMB_CNT after clock restore 0x%02x\n", sis630_read(SMB_CNT)); 217 } 218 219 static int sis630_transaction(struct i2c_adapter *adap, int size) 220 { 221 int result = 0; 222 u8 oldclock = 0; 223 224 result = sis630_transaction_start(adap, size, &oldclock); 225 if (!result) { 226 result = sis630_transaction_wait(adap, size); 227 sis630_transaction_end(adap, oldclock); 228 } 229 230 return result; 231 } 232 233 static int sis630_block_data(struct i2c_adapter *adap, union i2c_smbus_data *data, int read_write) 234 { 235 int i, len = 0, rc = 0; 236 u8 oldclock = 0; 237 238 if (read_write == I2C_SMBUS_WRITE) { 239 len = data->block[0]; 240 if (len < 0) 241 len = 0; 242 else if (len > 32) 243 len = 32; 244 sis630_write(SMB_COUNT, len); 245 for (i=1; i <= len; i++) { 246 dev_dbg(&adap->dev, "set data 0x%02x\n", data->block[i]); 247 /* set data */ 248 sis630_write(SMB_BYTE+(i-1)%8, data->block[i]); 249 if (i==8 || (len<8 && i==len)) { 250 dev_dbg(&adap->dev, "start trans len=%d i=%d\n",len ,i); 251 /* first transaction */ 252 if (sis630_transaction_start(adap, SIS630_BLOCK_DATA, &oldclock)) 253 return -1; 254 } 255 else if ((i-1)%8 == 7 || i==len) { 256 dev_dbg(&adap->dev, "trans_wait len=%d i=%d\n",len,i); 257 if (i>8) { 258 dev_dbg(&adap->dev, "clear smbary_sts len=%d i=%d\n",len,i); 259 /* 260 If this is not first transaction, 261 we must clear sticky bit. 262 clear SMBARY_STS 263 */ 264 sis630_write(SMB_STS,0x10); 265 } 266 if (sis630_transaction_wait(adap, SIS630_BLOCK_DATA)) { 267 dev_dbg(&adap->dev, "trans_wait failed\n"); 268 rc = -1; 269 break; 270 } 271 } 272 } 273 } 274 else { 275 /* read request */ 276 data->block[0] = len = 0; 277 if (sis630_transaction_start(adap, SIS630_BLOCK_DATA, &oldclock)) { 278 return -1; 279 } 280 do { 281 if (sis630_transaction_wait(adap, SIS630_BLOCK_DATA)) { 282 dev_dbg(&adap->dev, "trans_wait failed\n"); 283 rc = -1; 284 break; 285 } 286 /* if this first transaction then read byte count */ 287 if (len == 0) 288 data->block[0] = sis630_read(SMB_COUNT); 289 290 /* just to be sure */ 291 if (data->block[0] > 32) 292 data->block[0] = 32; 293 294 dev_dbg(&adap->dev, "block data read len=0x%x\n", data->block[0]); 295 296 for (i=0; i < 8 && len < data->block[0]; i++,len++) { 297 dev_dbg(&adap->dev, "read i=%d len=%d\n", i, len); 298 data->block[len+1] = sis630_read(SMB_BYTE+i); 299 } 300 301 dev_dbg(&adap->dev, "clear smbary_sts len=%d i=%d\n",len,i); 302 303 /* clear SMBARY_STS */ 304 sis630_write(SMB_STS,0x10); 305 } while(len < data->block[0]); 306 } 307 308 sis630_transaction_end(adap, oldclock); 309 310 return rc; 311 } 312 313 /* Return -1 on error. */ 314 static s32 sis630_access(struct i2c_adapter *adap, u16 addr, 315 unsigned short flags, char read_write, 316 u8 command, int size, union i2c_smbus_data *data) 317 { 318 switch (size) { 319 case I2C_SMBUS_QUICK: 320 sis630_write(SMB_ADDR, ((addr & 0x7f) << 1) | (read_write & 0x01)); 321 size = SIS630_QUICK; 322 break; 323 case I2C_SMBUS_BYTE: 324 sis630_write(SMB_ADDR, ((addr & 0x7f) << 1) | (read_write & 0x01)); 325 if (read_write == I2C_SMBUS_WRITE) 326 sis630_write(SMB_CMD, command); 327 size = SIS630_BYTE; 328 break; 329 case I2C_SMBUS_BYTE_DATA: 330 sis630_write(SMB_ADDR, ((addr & 0x7f) << 1) | (read_write & 0x01)); 331 sis630_write(SMB_CMD, command); 332 if (read_write == I2C_SMBUS_WRITE) 333 sis630_write(SMB_BYTE, data->byte); 334 size = SIS630_BYTE_DATA; 335 break; 336 case I2C_SMBUS_PROC_CALL: 337 case I2C_SMBUS_WORD_DATA: 338 sis630_write(SMB_ADDR,((addr & 0x7f) << 1) | (read_write & 0x01)); 339 sis630_write(SMB_CMD, command); 340 if (read_write == I2C_SMBUS_WRITE) { 341 sis630_write(SMB_BYTE, data->word & 0xff); 342 sis630_write(SMB_BYTE + 1,(data->word & 0xff00) >> 8); 343 } 344 size = (size == I2C_SMBUS_PROC_CALL ? SIS630_PCALL : SIS630_WORD_DATA); 345 break; 346 case I2C_SMBUS_BLOCK_DATA: 347 sis630_write(SMB_ADDR,((addr & 0x7f) << 1) | (read_write & 0x01)); 348 sis630_write(SMB_CMD, command); 349 size = SIS630_BLOCK_DATA; 350 return sis630_block_data(adap, data, read_write); 351 default: 352 printk("Unsupported I2C size\n"); 353 return -1; 354 break; 355 } 356 357 if (sis630_transaction(adap, size)) 358 return -1; 359 360 if ((size != SIS630_PCALL) && 361 ((read_write == I2C_SMBUS_WRITE) || (size == SIS630_QUICK))) { 362 return 0; 363 } 364 365 switch(size) { 366 case SIS630_BYTE: 367 case SIS630_BYTE_DATA: 368 data->byte = sis630_read(SMB_BYTE); 369 break; 370 case SIS630_PCALL: 371 case SIS630_WORD_DATA: 372 data->word = sis630_read(SMB_BYTE) + (sis630_read(SMB_BYTE + 1) << 8); 373 break; 374 default: 375 return -1; 376 break; 377 } 378 379 return 0; 380 } 381 382 static u32 sis630_func(struct i2c_adapter *adapter) 383 { 384 return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE | I2C_FUNC_SMBUS_BYTE_DATA | 385 I2C_FUNC_SMBUS_WORD_DATA | I2C_FUNC_SMBUS_PROC_CALL | 386 I2C_FUNC_SMBUS_BLOCK_DATA; 387 } 388 389 static int sis630_setup(struct pci_dev *sis630_dev) 390 { 391 unsigned char b; 392 struct pci_dev *dummy = NULL; 393 int retval = -ENODEV, i; 394 395 /* check for supported SiS devices */ 396 for (i=0; supported[i] > 0 ; i++) { 397 if ((dummy = pci_get_device(PCI_VENDOR_ID_SI, supported[i], dummy))) 398 break; /* found */ 399 } 400 401 if (dummy) { 402 pci_dev_put(dummy); 403 } 404 else if (force) { 405 dev_err(&sis630_dev->dev, "WARNING: Can't detect SIS630 compatible device, but " 406 "loading because of force option enabled\n"); 407 } 408 else { 409 return -ENODEV; 410 } 411 412 /* 413 Enable ACPI first , so we can accsess reg 74-75 414 in acpi io space and read acpi base addr 415 */ 416 if (pci_read_config_byte(sis630_dev, SIS630_BIOS_CTL_REG,&b)) { 417 dev_err(&sis630_dev->dev, "Error: Can't read bios ctl reg\n"); 418 goto exit; 419 } 420 /* if ACPI already enabled , do nothing */ 421 if (!(b & 0x80) && 422 pci_write_config_byte(sis630_dev, SIS630_BIOS_CTL_REG, b | 0x80)) { 423 dev_err(&sis630_dev->dev, "Error: Can't enable ACPI\n"); 424 goto exit; 425 } 426 427 /* Determine the ACPI base address */ 428 if (pci_read_config_word(sis630_dev,SIS630_ACPI_BASE_REG,&acpi_base)) { 429 dev_err(&sis630_dev->dev, "Error: Can't determine ACPI base address\n"); 430 goto exit; 431 } 432 433 dev_dbg(&sis630_dev->dev, "ACPI base at 0x%04x\n", acpi_base); 434 435 /* Everything is happy, let's grab the memory and set things up. */ 436 if (!request_region(acpi_base + SMB_STS, SIS630_SMB_IOREGION, "sis630-smbus")) { 437 dev_err(&sis630_dev->dev, "SMBus registers 0x%04x-0x%04x already " 438 "in use!\n", acpi_base + SMB_STS, acpi_base + SMB_SAA); 439 goto exit; 440 } 441 442 retval = 0; 443 444 exit: 445 if (retval) 446 acpi_base = 0; 447 return retval; 448 } 449 450 451 static struct i2c_algorithm smbus_algorithm = { 452 .name = "Non-I2C SMBus adapter", 453 .id = I2C_ALGO_SMBUS, 454 .smbus_xfer = sis630_access, 455 .functionality = sis630_func, 456 }; 457 458 static struct i2c_adapter sis630_adapter = { 459 .owner = THIS_MODULE, 460 .class = I2C_CLASS_HWMON, 461 .name = "unset", 462 .algo = &smbus_algorithm, 463 }; 464 465 static struct pci_device_id sis630_ids[] __devinitdata = { 466 { PCI_DEVICE(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_503) }, 467 { PCI_DEVICE(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_LPC) }, 468 { 0, } 469 }; 470 471 MODULE_DEVICE_TABLE (pci, sis630_ids); 472 473 static int __devinit sis630_probe(struct pci_dev *dev, const struct pci_device_id *id) 474 { 475 if (sis630_setup(dev)) { 476 dev_err(&dev->dev, "SIS630 comp. bus not detected, module not inserted.\n"); 477 return -ENODEV; 478 } 479 480 /* set up the driverfs linkage to our parent device */ 481 sis630_adapter.dev.parent = &dev->dev; 482 483 sprintf(sis630_adapter.name, "SMBus SIS630 adapter at %04x", 484 acpi_base + SMB_STS); 485 486 return i2c_add_adapter(&sis630_adapter); 487 } 488 489 static void __devexit sis630_remove(struct pci_dev *dev) 490 { 491 if (acpi_base) { 492 i2c_del_adapter(&sis630_adapter); 493 release_region(acpi_base + SMB_STS, SIS630_SMB_IOREGION); 494 acpi_base = 0; 495 } 496 } 497 498 499 static struct pci_driver sis630_driver = { 500 .name = "sis630_smbus", 501 .id_table = sis630_ids, 502 .probe = sis630_probe, 503 .remove = __devexit_p(sis630_remove), 504 }; 505 506 static int __init i2c_sis630_init(void) 507 { 508 return pci_register_driver(&sis630_driver); 509 } 510 511 512 static void __exit i2c_sis630_exit(void) 513 { 514 pci_unregister_driver(&sis630_driver); 515 } 516 517 518 MODULE_LICENSE("GPL"); 519 MODULE_AUTHOR("Alexander Malysh <amalysh@web.de>"); 520 MODULE_DESCRIPTION("SIS630 SMBus driver"); 521 522 module_init(i2c_sis630_init); 523 module_exit(i2c_sis630_exit); 524