1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 Copyright (c) 1998, 1999 Frodo Looijaard <frodol@dds.nl> and 4 Philip Edelbrock <phil@netroedge.com> 5 6 */ 7 8 /* Note: we assume there can only be one SIS5595 with one SMBus interface */ 9 10 /* 11 Note: all have mfr. ID 0x1039. 12 SUPPORTED PCI ID 13 5595 0008 14 15 Note: these chips contain a 0008 device which is incompatible with the 16 5595. We recognize these by the presence of the listed 17 "blacklist" PCI ID and refuse to load. 18 19 NOT SUPPORTED PCI ID BLACKLIST PCI ID 20 540 0008 0540 21 550 0008 0550 22 5513 0008 5511 23 5581 0008 5597 24 5582 0008 5597 25 5597 0008 5597 26 5598 0008 5597/5598 27 630 0008 0630 28 645 0008 0645 29 646 0008 0646 30 648 0008 0648 31 650 0008 0650 32 651 0008 0651 33 730 0008 0730 34 735 0008 0735 35 745 0008 0745 36 746 0008 0746 37 */ 38 39 /* TO DO: 40 * Add Block Transfers (ugly, but supported by the adapter) 41 * Add adapter resets 42 */ 43 44 #include <linux/kernel.h> 45 #include <linux/module.h> 46 #include <linux/delay.h> 47 #include <linux/pci.h> 48 #include <linux/ioport.h> 49 #include <linux/init.h> 50 #include <linux/i2c.h> 51 #include <linux/acpi.h> 52 #include <linux/io.h> 53 54 static int blacklist[] = { 55 PCI_DEVICE_ID_SI_540, 56 PCI_DEVICE_ID_SI_550, 57 PCI_DEVICE_ID_SI_630, 58 PCI_DEVICE_ID_SI_645, 59 PCI_DEVICE_ID_SI_646, 60 PCI_DEVICE_ID_SI_648, 61 PCI_DEVICE_ID_SI_650, 62 PCI_DEVICE_ID_SI_651, 63 PCI_DEVICE_ID_SI_730, 64 PCI_DEVICE_ID_SI_735, 65 PCI_DEVICE_ID_SI_745, 66 PCI_DEVICE_ID_SI_746, 67 PCI_DEVICE_ID_SI_5511, /* 5513 chip has the 0008 device but that ID 68 shows up in other chips so we use the 5511 69 ID for recognition */ 70 PCI_DEVICE_ID_SI_5597, 71 PCI_DEVICE_ID_SI_5598, 72 0, /* terminates the list */ 73 }; 74 75 /* Length of ISA address segment */ 76 #define SIS5595_EXTENT 8 77 /* SIS5595 SMBus registers */ 78 #define SMB_STS_LO 0x00 79 #define SMB_STS_HI 0x01 80 #define SMB_CTL_LO 0x02 81 #define SMB_CTL_HI 0x03 82 #define SMB_ADDR 0x04 83 #define SMB_CMD 0x05 84 #define SMB_PCNT 0x06 85 #define SMB_CNT 0x07 86 #define SMB_BYTE 0x08 87 #define SMB_DEV 0x10 88 #define SMB_DB0 0x11 89 #define SMB_DB1 0x12 90 #define SMB_HAA 0x13 91 92 /* PCI Address Constants */ 93 #define SMB_INDEX 0x38 94 #define SMB_DAT 0x39 95 #define SIS5595_ENABLE_REG 0x40 96 #define ACPI_BASE 0x90 97 98 /* Other settings */ 99 #define MAX_TIMEOUT 500 100 101 /* SIS5595 constants */ 102 #define SIS5595_QUICK 0x00 103 #define SIS5595_BYTE 0x02 104 #define SIS5595_BYTE_DATA 0x04 105 #define SIS5595_WORD_DATA 0x06 106 #define SIS5595_PROC_CALL 0x08 107 #define SIS5595_BLOCK_DATA 0x0A 108 109 /* insmod parameters */ 110 111 /* If force_addr is set to anything different from 0, we forcibly enable 112 the device at the given address. */ 113 static u16 force_addr; 114 module_param_hw(force_addr, ushort, ioport, 0); 115 MODULE_PARM_DESC(force_addr, "Initialize the base address of the i2c controller"); 116 117 static struct pci_driver sis5595_driver; 118 static unsigned short sis5595_base; 119 static struct pci_dev *sis5595_pdev; 120 121 static u8 sis5595_read(u8 reg) 122 { 123 outb(reg, sis5595_base + SMB_INDEX); 124 return inb(sis5595_base + SMB_DAT); 125 } 126 127 static void sis5595_write(u8 reg, u8 data) 128 { 129 outb(reg, sis5595_base + SMB_INDEX); 130 outb(data, sis5595_base + SMB_DAT); 131 } 132 133 static int sis5595_setup(struct pci_dev *SIS5595_dev) 134 { 135 u16 a; 136 u8 val; 137 int *i; 138 int retval; 139 140 /* Look for imposters */ 141 for (i = blacklist; *i != 0; i++) { 142 struct pci_dev *dev; 143 dev = pci_get_device(PCI_VENDOR_ID_SI, *i, NULL); 144 if (dev) { 145 dev_err(&SIS5595_dev->dev, "Looked for SIS5595 but found unsupported device %.4x\n", *i); 146 pci_dev_put(dev); 147 return -ENODEV; 148 } 149 } 150 151 /* Determine the address of the SMBus areas */ 152 pci_read_config_word(SIS5595_dev, ACPI_BASE, &sis5595_base); 153 if (sis5595_base == 0 && force_addr == 0) { 154 dev_err(&SIS5595_dev->dev, "ACPI base address uninitialized - upgrade BIOS or use force_addr=0xaddr\n"); 155 return -ENODEV; 156 } 157 158 if (force_addr) 159 sis5595_base = force_addr & ~(SIS5595_EXTENT - 1); 160 dev_dbg(&SIS5595_dev->dev, "ACPI Base address: %04x\n", sis5595_base); 161 162 /* NB: We grab just the two SMBus registers here, but this may still 163 * interfere with ACPI :-( */ 164 retval = acpi_check_region(sis5595_base + SMB_INDEX, 2, 165 sis5595_driver.name); 166 if (retval) 167 return retval; 168 169 if (!request_region(sis5595_base + SMB_INDEX, 2, 170 sis5595_driver.name)) { 171 dev_err(&SIS5595_dev->dev, "SMBus registers 0x%04x-0x%04x already in use!\n", 172 sis5595_base + SMB_INDEX, sis5595_base + SMB_INDEX + 1); 173 return -ENODEV; 174 } 175 176 if (force_addr) { 177 dev_info(&SIS5595_dev->dev, "forcing ISA address 0x%04X\n", sis5595_base); 178 retval = pci_write_config_word(SIS5595_dev, ACPI_BASE, sis5595_base); 179 if (retval != PCIBIOS_SUCCESSFUL) 180 goto error; 181 retval = pci_read_config_word(SIS5595_dev, ACPI_BASE, &a); 182 if (retval != PCIBIOS_SUCCESSFUL) 183 goto error; 184 if ((a & ~(SIS5595_EXTENT - 1)) != sis5595_base) { 185 /* doesn't work for some chips! */ 186 dev_err(&SIS5595_dev->dev, "force address failed - not supported?\n"); 187 goto error; 188 } 189 } 190 191 retval = pci_read_config_byte(SIS5595_dev, SIS5595_ENABLE_REG, &val); 192 if (retval != PCIBIOS_SUCCESSFUL) 193 goto error; 194 if ((val & 0x80) == 0) { 195 dev_info(&SIS5595_dev->dev, "enabling ACPI\n"); 196 retval = pci_write_config_byte(SIS5595_dev, SIS5595_ENABLE_REG, val | 0x80); 197 if (retval != PCIBIOS_SUCCESSFUL) 198 goto error; 199 retval = pci_read_config_byte(SIS5595_dev, SIS5595_ENABLE_REG, &val); 200 if (retval != PCIBIOS_SUCCESSFUL) 201 goto error; 202 if ((val & 0x80) == 0) { 203 /* doesn't work for some chips? */ 204 dev_err(&SIS5595_dev->dev, "ACPI enable failed - not supported?\n"); 205 goto error; 206 } 207 } 208 209 /* Everything is happy */ 210 return 0; 211 212 error: 213 release_region(sis5595_base + SMB_INDEX, 2); 214 return -ENODEV; 215 } 216 217 static int sis5595_transaction(struct i2c_adapter *adap) 218 { 219 int temp; 220 int result = 0; 221 int timeout = 0; 222 223 /* Make sure the SMBus host is ready to start transmitting */ 224 temp = sis5595_read(SMB_STS_LO) + (sis5595_read(SMB_STS_HI) << 8); 225 if (temp != 0x00) { 226 dev_dbg(&adap->dev, "SMBus busy (%04x). Resetting...\n", temp); 227 sis5595_write(SMB_STS_LO, temp & 0xff); 228 sis5595_write(SMB_STS_HI, temp >> 8); 229 if ((temp = sis5595_read(SMB_STS_LO) + (sis5595_read(SMB_STS_HI) << 8)) != 0x00) { 230 dev_dbg(&adap->dev, "Failed! (%02x)\n", temp); 231 return -EBUSY; 232 } else { 233 dev_dbg(&adap->dev, "Successful!\n"); 234 } 235 } 236 237 /* start the transaction by setting bit 4 */ 238 sis5595_write(SMB_CTL_LO, sis5595_read(SMB_CTL_LO) | 0x10); 239 240 /* We will always wait for a fraction of a second! */ 241 do { 242 msleep(1); 243 temp = sis5595_read(SMB_STS_LO); 244 } while (!(temp & 0x40) && (timeout++ < MAX_TIMEOUT)); 245 246 /* If the SMBus is still busy, we give up */ 247 if (timeout > MAX_TIMEOUT) { 248 dev_dbg(&adap->dev, "SMBus Timeout!\n"); 249 result = -ETIMEDOUT; 250 } 251 252 if (temp & 0x10) { 253 dev_dbg(&adap->dev, "Error: Failed bus transaction\n"); 254 result = -ENXIO; 255 } 256 257 if (temp & 0x20) { 258 dev_err(&adap->dev, "Bus collision! SMBus may be locked until " 259 "next hard reset (or not...)\n"); 260 /* Clock stops and target is stuck in mid-transmission */ 261 result = -EIO; 262 } 263 264 temp = sis5595_read(SMB_STS_LO) + (sis5595_read(SMB_STS_HI) << 8); 265 if (temp != 0x00) { 266 sis5595_write(SMB_STS_LO, temp & 0xff); 267 sis5595_write(SMB_STS_HI, temp >> 8); 268 } 269 270 temp = sis5595_read(SMB_STS_LO) + (sis5595_read(SMB_STS_HI) << 8); 271 if (temp != 0x00) 272 dev_dbg(&adap->dev, "Failed reset at end of transaction (%02x)\n", temp); 273 274 return result; 275 } 276 277 /* Return negative errno on error. */ 278 static s32 sis5595_access(struct i2c_adapter *adap, u16 addr, 279 unsigned short flags, char read_write, 280 u8 command, int size, union i2c_smbus_data *data) 281 { 282 int status; 283 284 switch (size) { 285 case I2C_SMBUS_QUICK: 286 sis5595_write(SMB_ADDR, ((addr & 0x7f) << 1) | (read_write & 0x01)); 287 size = SIS5595_QUICK; 288 break; 289 case I2C_SMBUS_BYTE: 290 sis5595_write(SMB_ADDR, ((addr & 0x7f) << 1) | (read_write & 0x01)); 291 if (read_write == I2C_SMBUS_WRITE) 292 sis5595_write(SMB_CMD, command); 293 size = SIS5595_BYTE; 294 break; 295 case I2C_SMBUS_BYTE_DATA: 296 sis5595_write(SMB_ADDR, ((addr & 0x7f) << 1) | (read_write & 0x01)); 297 sis5595_write(SMB_CMD, command); 298 if (read_write == I2C_SMBUS_WRITE) 299 sis5595_write(SMB_BYTE, data->byte); 300 size = SIS5595_BYTE_DATA; 301 break; 302 case I2C_SMBUS_PROC_CALL: 303 case I2C_SMBUS_WORD_DATA: 304 sis5595_write(SMB_ADDR, ((addr & 0x7f) << 1) | (read_write & 0x01)); 305 sis5595_write(SMB_CMD, command); 306 if (read_write == I2C_SMBUS_WRITE) { 307 sis5595_write(SMB_BYTE, data->word & 0xff); 308 sis5595_write(SMB_BYTE + 1, 309 (data->word & 0xff00) >> 8); 310 } 311 size = (size == I2C_SMBUS_PROC_CALL) ? SIS5595_PROC_CALL : SIS5595_WORD_DATA; 312 break; 313 default: 314 dev_warn(&adap->dev, "Unsupported transaction %d\n", size); 315 return -EOPNOTSUPP; 316 } 317 318 sis5595_write(SMB_CTL_LO, ((size & 0x0E))); 319 320 status = sis5595_transaction(adap); 321 if (status) 322 return status; 323 324 if ((size != SIS5595_PROC_CALL) && 325 ((read_write == I2C_SMBUS_WRITE) || (size == SIS5595_QUICK))) 326 return 0; 327 328 329 switch (size) { 330 case SIS5595_BYTE: 331 case SIS5595_BYTE_DATA: 332 data->byte = sis5595_read(SMB_BYTE); 333 break; 334 case SIS5595_WORD_DATA: 335 case SIS5595_PROC_CALL: 336 data->word = sis5595_read(SMB_BYTE) + (sis5595_read(SMB_BYTE + 1) << 8); 337 break; 338 } 339 return 0; 340 } 341 342 static u32 sis5595_func(struct i2c_adapter *adapter) 343 { 344 return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE | 345 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA | 346 I2C_FUNC_SMBUS_PROC_CALL; 347 } 348 349 static const struct i2c_algorithm smbus_algorithm = { 350 .smbus_xfer = sis5595_access, 351 .functionality = sis5595_func, 352 }; 353 354 static struct i2c_adapter sis5595_adapter = { 355 .owner = THIS_MODULE, 356 .class = I2C_CLASS_HWMON, 357 .algo = &smbus_algorithm, 358 }; 359 360 static const struct pci_device_id sis5595_ids[] = { 361 { PCI_DEVICE(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_503) }, 362 { 0, } 363 }; 364 365 MODULE_DEVICE_TABLE (pci, sis5595_ids); 366 367 static int sis5595_probe(struct pci_dev *dev, const struct pci_device_id *id) 368 { 369 int err; 370 371 if (sis5595_setup(dev)) { 372 dev_err(&dev->dev, "SIS5595 not detected, module not inserted.\n"); 373 return -ENODEV; 374 } 375 376 /* set up the sysfs linkage to our parent device */ 377 sis5595_adapter.dev.parent = &dev->dev; 378 379 snprintf(sis5595_adapter.name, sizeof(sis5595_adapter.name), 380 "SMBus SIS5595 adapter at %04x", sis5595_base + SMB_INDEX); 381 err = i2c_add_adapter(&sis5595_adapter); 382 if (err) { 383 release_region(sis5595_base + SMB_INDEX, 2); 384 return err; 385 } 386 387 /* Always return failure here. This is to allow other drivers to bind 388 * to this pci device. We don't really want to have control over the 389 * pci device, we only wanted to read as few register values from it. 390 */ 391 sis5595_pdev = pci_dev_get(dev); 392 return -ENODEV; 393 } 394 395 static struct pci_driver sis5595_driver = { 396 .name = "sis5595_smbus", 397 .id_table = sis5595_ids, 398 .probe = sis5595_probe, 399 }; 400 401 static int __init i2c_sis5595_init(void) 402 { 403 return pci_register_driver(&sis5595_driver); 404 } 405 406 static void __exit i2c_sis5595_exit(void) 407 { 408 pci_unregister_driver(&sis5595_driver); 409 if (sis5595_pdev) { 410 i2c_del_adapter(&sis5595_adapter); 411 release_region(sis5595_base + SMB_INDEX, 2); 412 pci_dev_put(sis5595_pdev); 413 sis5595_pdev = NULL; 414 } 415 } 416 417 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>"); 418 MODULE_DESCRIPTION("SIS5595 SMBus driver"); 419 MODULE_LICENSE("GPL"); 420 421 module_init(i2c_sis5595_init); 422 module_exit(i2c_sis5595_exit); 423