1 /* 2 i2c-ali1535.c - Part of lm_sensors, Linux kernel modules for hardware 3 monitoring 4 Copyright (c) 2000 Frodo Looijaard <frodol@dds.nl>, 5 Philip Edelbrock <phil@netroedge.com>, 6 Mark D. Studebaker <mdsxyz123@yahoo.com>, 7 Dan Eaton <dan.eaton@rocketlogix.com> and 8 Stephen Rousset<stephen.rousset@rocketlogix.com> 9 10 This program is free software; you can redistribute it and/or modify 11 it under the terms of the GNU General Public License as published by 12 the Free Software Foundation; either version 2 of the License, or 13 (at your option) any later version. 14 15 This program is distributed in the hope that it will be useful, 16 but WITHOUT ANY WARRANTY; without even the implied warranty of 17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 GNU General Public License for more details. 19 20 You should have received a copy of the GNU General Public License 21 along with this program; if not, write to the Free Software 22 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 23 */ 24 25 /* 26 This is the driver for the SMB Host controller on 27 Acer Labs Inc. (ALI) M1535 South Bridge. 28 29 The M1535 is a South bridge for portable systems. 30 It is very similar to the M15x3 South bridges also produced 31 by Acer Labs Inc. Some of the registers within the part 32 have moved and some have been redefined slightly. Additionally, 33 the sequencing of the SMBus transactions has been modified 34 to be more consistent with the sequencing recommended by 35 the manufacturer and observed through testing. These 36 changes are reflected in this driver and can be identified 37 by comparing this driver to the i2c-ali15x3 driver. 38 For an overview of these chips see http://www.acerlabs.com 39 40 The SMB controller is part of the 7101 device, which is an 41 ACPI-compliant Power Management Unit (PMU). 42 43 The whole 7101 device has to be enabled for the SMB to work. 44 You can't just enable the SMB alone. 45 The SMB and the ACPI have separate I/O spaces. 46 We make sure that the SMB is enabled. We leave the ACPI alone. 47 48 This driver controls the SMB Host only. 49 50 This driver does not use interrupts. 51 */ 52 53 54 /* Note: we assume there can only be one ALI1535, with one SMBus interface */ 55 56 #include <linux/config.h> 57 #include <linux/module.h> 58 #include <linux/pci.h> 59 #include <linux/kernel.h> 60 #include <linux/stddef.h> 61 #include <linux/sched.h> 62 #include <linux/delay.h> 63 #include <linux/ioport.h> 64 #include <linux/i2c.h> 65 #include <linux/init.h> 66 #include <asm/io.h> 67 #include <asm/semaphore.h> 68 69 70 /* ALI1535 SMBus address offsets */ 71 #define SMBHSTSTS (0 + ali1535_smba) 72 #define SMBHSTTYP (1 + ali1535_smba) 73 #define SMBHSTPORT (2 + ali1535_smba) 74 #define SMBHSTCMD (7 + ali1535_smba) 75 #define SMBHSTADD (3 + ali1535_smba) 76 #define SMBHSTDAT0 (4 + ali1535_smba) 77 #define SMBHSTDAT1 (5 + ali1535_smba) 78 #define SMBBLKDAT (6 + ali1535_smba) 79 80 /* PCI Address Constants */ 81 #define SMBCOM 0x004 82 #define SMBREV 0x008 83 #define SMBCFG 0x0D1 84 #define SMBBA 0x0E2 85 #define SMBHSTCFG 0x0F0 86 #define SMBCLK 0x0F2 87 88 /* Other settings */ 89 #define MAX_TIMEOUT 500 /* times 1/100 sec */ 90 #define ALI1535_SMB_IOSIZE 32 91 92 #define ALI1535_SMB_DEFAULTBASE 0x8040 93 94 /* ALI1535 address lock bits */ 95 #define ALI1535_LOCK 0x06 /* dwe */ 96 97 /* ALI1535 command constants */ 98 #define ALI1535_QUICK 0x00 99 #define ALI1535_BYTE 0x10 100 #define ALI1535_BYTE_DATA 0x20 101 #define ALI1535_WORD_DATA 0x30 102 #define ALI1535_BLOCK_DATA 0x40 103 #define ALI1535_I2C_READ 0x60 104 105 #define ALI1535_DEV10B_EN 0x80 /* Enable 10-bit addressing in */ 106 /* I2C read */ 107 #define ALI1535_T_OUT 0x08 /* Time-out Command (write) */ 108 #define ALI1535_A_HIGH_BIT9 0x08 /* Bit 9 of 10-bit address in */ 109 /* Alert-Response-Address */ 110 /* (read) */ 111 #define ALI1535_KILL 0x04 /* Kill Command (write) */ 112 #define ALI1535_A_HIGH_BIT8 0x04 /* Bit 8 of 10-bit address in */ 113 /* Alert-Response-Address */ 114 /* (read) */ 115 116 #define ALI1535_D_HI_MASK 0x03 /* Mask for isolating bits 9-8 */ 117 /* of 10-bit address in I2C */ 118 /* Read Command */ 119 120 /* ALI1535 status register bits */ 121 #define ALI1535_STS_IDLE 0x04 122 #define ALI1535_STS_BUSY 0x08 /* host busy */ 123 #define ALI1535_STS_DONE 0x10 /* transaction complete */ 124 #define ALI1535_STS_DEV 0x20 /* device error */ 125 #define ALI1535_STS_BUSERR 0x40 /* bus error */ 126 #define ALI1535_STS_FAIL 0x80 /* failed bus transaction */ 127 #define ALI1535_STS_ERR 0xE0 /* all the bad error bits */ 128 129 #define ALI1535_BLOCK_CLR 0x04 /* reset block data index */ 130 131 /* ALI1535 device address register bits */ 132 #define ALI1535_RD_ADDR 0x01 /* Read/Write Bit in Device */ 133 /* Address field */ 134 /* -> Write = 0 */ 135 /* -> Read = 1 */ 136 #define ALI1535_SMBIO_EN 0x04 /* SMB I/O Space enable */ 137 138 139 static unsigned short ali1535_smba; 140 static DECLARE_MUTEX(i2c_ali1535_sem); 141 142 /* Detect whether a ALI1535 can be found, and initialize it, where necessary. 143 Note the differences between kernels with the old PCI BIOS interface and 144 newer kernels with the real PCI interface. In compat.h some things are 145 defined to make the transition easier. */ 146 static int ali1535_setup(struct pci_dev *dev) 147 { 148 int retval = -ENODEV; 149 unsigned char temp; 150 151 /* Check the following things: 152 - SMB I/O address is initialized 153 - Device is enabled 154 - We can use the addresses 155 */ 156 157 /* Determine the address of the SMBus area */ 158 pci_read_config_word(dev, SMBBA, &ali1535_smba); 159 ali1535_smba &= (0xffff & ~(ALI1535_SMB_IOSIZE - 1)); 160 if (ali1535_smba == 0) { 161 dev_warn(&dev->dev, 162 "ALI1535_smb region uninitialized - upgrade BIOS?\n"); 163 goto exit; 164 } 165 166 if (!request_region(ali1535_smba, ALI1535_SMB_IOSIZE, "ali1535-smb")) { 167 dev_err(&dev->dev, "ALI1535_smb region 0x%x already in use!\n", 168 ali1535_smba); 169 goto exit; 170 } 171 172 /* check if whole device is enabled */ 173 pci_read_config_byte(dev, SMBCFG, &temp); 174 if ((temp & ALI1535_SMBIO_EN) == 0) { 175 dev_err(&dev->dev, "SMB device not enabled - upgrade BIOS?\n"); 176 goto exit_free; 177 } 178 179 /* Is SMB Host controller enabled? */ 180 pci_read_config_byte(dev, SMBHSTCFG, &temp); 181 if ((temp & 1) == 0) { 182 dev_err(&dev->dev, "SMBus controller not enabled - upgrade BIOS?\n"); 183 goto exit_free; 184 } 185 186 /* set SMB clock to 74KHz as recommended in data sheet */ 187 pci_write_config_byte(dev, SMBCLK, 0x20); 188 189 /* 190 The interrupt routing for SMB is set up in register 0x77 in the 191 1533 ISA Bridge device, NOT in the 7101 device. 192 Don't bother with finding the 1533 device and reading the register. 193 if ((....... & 0x0F) == 1) 194 dev_dbg(&dev->dev, "ALI1535 using Interrupt 9 for SMBus.\n"); 195 */ 196 pci_read_config_byte(dev, SMBREV, &temp); 197 dev_dbg(&dev->dev, "SMBREV = 0x%X\n", temp); 198 dev_dbg(&dev->dev, "ALI1535_smba = 0x%X\n", ali1535_smba); 199 200 retval = 0; 201 exit: 202 return retval; 203 204 exit_free: 205 release_region(ali1535_smba, ALI1535_SMB_IOSIZE); 206 return retval; 207 } 208 209 static int ali1535_transaction(struct i2c_adapter *adap) 210 { 211 int temp; 212 int result = 0; 213 int timeout = 0; 214 215 dev_dbg(&adap->dev, "Transaction (pre): STS=%02x, TYP=%02x, " 216 "CMD=%02x, ADD=%02x, DAT0=%02x, DAT1=%02x\n", 217 inb_p(SMBHSTSTS), inb_p(SMBHSTTYP), inb_p(SMBHSTCMD), 218 inb_p(SMBHSTADD), inb_p(SMBHSTDAT0), inb_p(SMBHSTDAT1)); 219 220 /* get status */ 221 temp = inb_p(SMBHSTSTS); 222 223 /* Make sure the SMBus host is ready to start transmitting */ 224 /* Check the busy bit first */ 225 if (temp & ALI1535_STS_BUSY) { 226 /* If the host controller is still busy, it may have timed out 227 * in the previous transaction, resulting in a "SMBus Timeout" 228 * printk. I've tried the following to reset a stuck busy bit. 229 * 1. Reset the controller with an KILL command. (this 230 * doesn't seem to clear the controller if an external 231 * device is hung) 232 * 2. Reset the controller and the other SMBus devices with a 233 * T_OUT command. (this clears the host busy bit if an 234 * external device is hung, but it comes back upon a new 235 * access to a device) 236 * 3. Disable and reenable the controller in SMBHSTCFG. Worst 237 * case, nothing seems to work except power reset. 238 */ 239 240 /* Try resetting entire SMB bus, including other devices - This 241 * may not work either - it clears the BUSY bit but then the 242 * BUSY bit may come back on when you try and use the chip 243 * again. If that's the case you are stuck. 244 */ 245 dev_info(&adap->dev, 246 "Resetting entire SMB Bus to clear busy condition (%02x)\n", 247 temp); 248 outb_p(ALI1535_T_OUT, SMBHSTTYP); 249 temp = inb_p(SMBHSTSTS); 250 } 251 252 /* now check the error bits and the busy bit */ 253 if (temp & (ALI1535_STS_ERR | ALI1535_STS_BUSY)) { 254 /* do a clear-on-write */ 255 outb_p(0xFF, SMBHSTSTS); 256 if ((temp = inb_p(SMBHSTSTS)) & 257 (ALI1535_STS_ERR | ALI1535_STS_BUSY)) { 258 /* This is probably going to be correctable only by a 259 * power reset as one of the bits now appears to be 260 * stuck */ 261 /* This may be a bus or device with electrical problems. */ 262 dev_err(&adap->dev, 263 "SMBus reset failed! (0x%02x) - controller or " 264 "device on bus is probably hung\n", temp); 265 return -1; 266 } 267 } else { 268 /* check and clear done bit */ 269 if (temp & ALI1535_STS_DONE) { 270 outb_p(temp, SMBHSTSTS); 271 } 272 } 273 274 /* start the transaction by writing anything to the start register */ 275 outb_p(0xFF, SMBHSTPORT); 276 277 /* We will always wait for a fraction of a second! */ 278 timeout = 0; 279 do { 280 msleep(1); 281 temp = inb_p(SMBHSTSTS); 282 } while (((temp & ALI1535_STS_BUSY) && !(temp & ALI1535_STS_IDLE)) 283 && (timeout++ < MAX_TIMEOUT)); 284 285 /* If the SMBus is still busy, we give up */ 286 if (timeout >= MAX_TIMEOUT) { 287 result = -1; 288 dev_err(&adap->dev, "SMBus Timeout!\n"); 289 } 290 291 if (temp & ALI1535_STS_FAIL) { 292 result = -1; 293 dev_dbg(&adap->dev, "Error: Failed bus transaction\n"); 294 } 295 296 /* Unfortunately the ALI SMB controller maps "no response" and "bus 297 * collision" into a single bit. No reponse is the usual case so don't 298 * do a printk. This means that bus collisions go unreported. 299 */ 300 if (temp & ALI1535_STS_BUSERR) { 301 result = -1; 302 dev_dbg(&adap->dev, 303 "Error: no response or bus collision ADD=%02x\n", 304 inb_p(SMBHSTADD)); 305 } 306 307 /* haven't ever seen this */ 308 if (temp & ALI1535_STS_DEV) { 309 result = -1; 310 dev_err(&adap->dev, "Error: device error\n"); 311 } 312 313 /* check to see if the "command complete" indication is set */ 314 if (!(temp & ALI1535_STS_DONE)) { 315 result = -1; 316 dev_err(&adap->dev, "Error: command never completed\n"); 317 } 318 319 dev_dbg(&adap->dev, "Transaction (post): STS=%02x, TYP=%02x, " 320 "CMD=%02x, ADD=%02x, DAT0=%02x, DAT1=%02x\n", 321 inb_p(SMBHSTSTS), inb_p(SMBHSTTYP), inb_p(SMBHSTCMD), 322 inb_p(SMBHSTADD), inb_p(SMBHSTDAT0), inb_p(SMBHSTDAT1)); 323 324 /* take consequent actions for error conditions */ 325 if (!(temp & ALI1535_STS_DONE)) { 326 /* issue "kill" to reset host controller */ 327 outb_p(ALI1535_KILL,SMBHSTTYP); 328 outb_p(0xFF,SMBHSTSTS); 329 } else if (temp & ALI1535_STS_ERR) { 330 /* issue "timeout" to reset all devices on bus */ 331 outb_p(ALI1535_T_OUT,SMBHSTTYP); 332 outb_p(0xFF,SMBHSTSTS); 333 } 334 335 return result; 336 } 337 338 /* Return -1 on error. */ 339 static s32 ali1535_access(struct i2c_adapter *adap, u16 addr, 340 unsigned short flags, char read_write, u8 command, 341 int size, union i2c_smbus_data *data) 342 { 343 int i, len; 344 int temp; 345 int timeout; 346 s32 result = 0; 347 348 down(&i2c_ali1535_sem); 349 /* make sure SMBus is idle */ 350 temp = inb_p(SMBHSTSTS); 351 for (timeout = 0; 352 (timeout < MAX_TIMEOUT) && !(temp & ALI1535_STS_IDLE); 353 timeout++) { 354 msleep(1); 355 temp = inb_p(SMBHSTSTS); 356 } 357 if (timeout >= MAX_TIMEOUT) 358 dev_warn(&adap->dev, "Idle wait Timeout! STS=0x%02x\n", temp); 359 360 /* clear status register (clear-on-write) */ 361 outb_p(0xFF, SMBHSTSTS); 362 363 switch (size) { 364 case I2C_SMBUS_PROC_CALL: 365 dev_err(&adap->dev, "I2C_SMBUS_PROC_CALL not supported!\n"); 366 result = -1; 367 goto EXIT; 368 case I2C_SMBUS_QUICK: 369 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01), 370 SMBHSTADD); 371 size = ALI1535_QUICK; 372 outb_p(size, SMBHSTTYP); /* output command */ 373 break; 374 case I2C_SMBUS_BYTE: 375 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01), 376 SMBHSTADD); 377 size = ALI1535_BYTE; 378 outb_p(size, SMBHSTTYP); /* output command */ 379 if (read_write == I2C_SMBUS_WRITE) 380 outb_p(command, SMBHSTCMD); 381 break; 382 case I2C_SMBUS_BYTE_DATA: 383 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01), 384 SMBHSTADD); 385 size = ALI1535_BYTE_DATA; 386 outb_p(size, SMBHSTTYP); /* output command */ 387 outb_p(command, SMBHSTCMD); 388 if (read_write == I2C_SMBUS_WRITE) 389 outb_p(data->byte, SMBHSTDAT0); 390 break; 391 case I2C_SMBUS_WORD_DATA: 392 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01), 393 SMBHSTADD); 394 size = ALI1535_WORD_DATA; 395 outb_p(size, SMBHSTTYP); /* output command */ 396 outb_p(command, SMBHSTCMD); 397 if (read_write == I2C_SMBUS_WRITE) { 398 outb_p(data->word & 0xff, SMBHSTDAT0); 399 outb_p((data->word & 0xff00) >> 8, SMBHSTDAT1); 400 } 401 break; 402 case I2C_SMBUS_BLOCK_DATA: 403 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01), 404 SMBHSTADD); 405 size = ALI1535_BLOCK_DATA; 406 outb_p(size, SMBHSTTYP); /* output command */ 407 outb_p(command, SMBHSTCMD); 408 if (read_write == I2C_SMBUS_WRITE) { 409 len = data->block[0]; 410 if (len < 0) { 411 len = 0; 412 data->block[0] = len; 413 } 414 if (len > 32) { 415 len = 32; 416 data->block[0] = len; 417 } 418 outb_p(len, SMBHSTDAT0); 419 /* Reset SMBBLKDAT */ 420 outb_p(inb_p(SMBHSTTYP) | ALI1535_BLOCK_CLR, SMBHSTTYP); 421 for (i = 1; i <= len; i++) 422 outb_p(data->block[i], SMBBLKDAT); 423 } 424 break; 425 } 426 427 if (ali1535_transaction(adap)) { 428 /* Error in transaction */ 429 result = -1; 430 goto EXIT; 431 } 432 433 if ((read_write == I2C_SMBUS_WRITE) || (size == ALI1535_QUICK)) { 434 result = 0; 435 goto EXIT; 436 } 437 438 switch (size) { 439 case ALI1535_BYTE: /* Result put in SMBHSTDAT0 */ 440 data->byte = inb_p(SMBHSTDAT0); 441 break; 442 case ALI1535_BYTE_DATA: 443 data->byte = inb_p(SMBHSTDAT0); 444 break; 445 case ALI1535_WORD_DATA: 446 data->word = inb_p(SMBHSTDAT0) + (inb_p(SMBHSTDAT1) << 8); 447 break; 448 case ALI1535_BLOCK_DATA: 449 len = inb_p(SMBHSTDAT0); 450 if (len > 32) 451 len = 32; 452 data->block[0] = len; 453 /* Reset SMBBLKDAT */ 454 outb_p(inb_p(SMBHSTTYP) | ALI1535_BLOCK_CLR, SMBHSTTYP); 455 for (i = 1; i <= data->block[0]; i++) { 456 data->block[i] = inb_p(SMBBLKDAT); 457 dev_dbg(&adap->dev, "Blk: len=%d, i=%d, data=%02x\n", 458 len, i, data->block[i]); 459 } 460 break; 461 } 462 EXIT: 463 up(&i2c_ali1535_sem); 464 return result; 465 } 466 467 468 static u32 ali1535_func(struct i2c_adapter *adapter) 469 { 470 return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE | 471 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA | 472 I2C_FUNC_SMBUS_BLOCK_DATA; 473 } 474 475 static struct i2c_algorithm smbus_algorithm = { 476 .name = "Non-i2c SMBus adapter", 477 .id = I2C_ALGO_SMBUS, 478 .smbus_xfer = ali1535_access, 479 .functionality = ali1535_func, 480 }; 481 482 static struct i2c_adapter ali1535_adapter = { 483 .owner = THIS_MODULE, 484 .class = I2C_CLASS_HWMON, 485 .algo = &smbus_algorithm, 486 .name = "unset", 487 }; 488 489 static struct pci_device_id ali1535_ids[] = { 490 { PCI_DEVICE(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M7101) }, 491 { }, 492 }; 493 494 MODULE_DEVICE_TABLE (pci, ali1535_ids); 495 496 static int __devinit ali1535_probe(struct pci_dev *dev, const struct pci_device_id *id) 497 { 498 if (ali1535_setup(dev)) { 499 dev_warn(&dev->dev, 500 "ALI1535 not detected, module not inserted.\n"); 501 return -ENODEV; 502 } 503 504 /* set up the driverfs linkage to our parent device */ 505 ali1535_adapter.dev.parent = &dev->dev; 506 507 snprintf(ali1535_adapter.name, I2C_NAME_SIZE, 508 "SMBus ALI1535 adapter at %04x", ali1535_smba); 509 return i2c_add_adapter(&ali1535_adapter); 510 } 511 512 static void __devexit ali1535_remove(struct pci_dev *dev) 513 { 514 i2c_del_adapter(&ali1535_adapter); 515 release_region(ali1535_smba, ALI1535_SMB_IOSIZE); 516 } 517 518 static struct pci_driver ali1535_driver = { 519 .name = "ali1535_smbus", 520 .id_table = ali1535_ids, 521 .probe = ali1535_probe, 522 .remove = __devexit_p(ali1535_remove), 523 }; 524 525 static int __init i2c_ali1535_init(void) 526 { 527 return pci_register_driver(&ali1535_driver); 528 } 529 530 static void __exit i2c_ali1535_exit(void) 531 { 532 pci_unregister_driver(&ali1535_driver); 533 } 534 535 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>, " 536 "Philip Edelbrock <phil@netroedge.com>, " 537 "Mark D. Studebaker <mdsxyz123@yahoo.com> " 538 "and Dan Eaton <dan.eaton@rocketlogix.com>"); 539 MODULE_DESCRIPTION("ALI1535 SMBus driver"); 540 MODULE_LICENSE("GPL"); 541 542 module_init(i2c_ali1535_init); 543 module_exit(i2c_ali1535_exit); 544