drivers/i2c/busses/i2c-viapro.c

   1 /*
   2     i2c-viapro.c - Part of lm_sensors, Linux kernel modules for hardware
   3               monitoring
   4     Copyright (c) 1998 - 2002  Frodo Looijaard <frodol@dds.nl>,
   5     Philip Edelbrock <phil@netroedge.com>, Kyösti Mälkki <kmalkki@cc.hut.fi>,
   6     Mark D. Studebaker <mdsxyz123@yahoo.com>
   7
   8     This program is free software; you can redistribute it and/or modify
   9     it under the terms of the GNU General Public License as published by
  10     the Free Software Foundation; either version 2 of the License, or
  11     (at your option) any later version.
  12
  13     This program is distributed in the hope that it will be useful,
  14     but WITHOUT ANY WARRANTY; without even the implied warranty of
  15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16     GNU General Public License for more details.
  17
  18     You should have received a copy of the GNU General Public License
  19     along with this program; if not, write to the Free Software
  20     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 /*
  24    Supports Via devices:
  25         82C596A/B (0x3050)
  26         82C596B (0x3051)
  27         82C686A/B
  28         8231
  29         8233
  30         8233A (0x3147 and 0x3177)
  31         8235
  32         8237
  33    Note: we assume there can only be one device, with one SMBus interface.
  34 */
  35
  36 #include <linux/module.h>
  37 #include <linux/delay.h>
  38 #include <linux/pci.h>
  39 #include <linux/kernel.h>
  40 #include <linux/stddef.h>
  41 #include <linux/sched.h>
  42 #include <linux/ioport.h>
  43 #include <linux/i2c.h>
  44 #include <linux/init.h>
  45 #include <asm/io.h>
  46
  47 static struct pci_dev *vt596_pdev;
  48
  49 #define SMBBA1           0x90
  50 #define SMBBA2           0x80
  51 #define SMBBA3           0xD0
  52
  53 /* SMBus address offsets */
  54 static unsigned short vt596_smba;
  55 #define SMBHSTSTS       (vt596_smba + 0)
  56 #define SMBHSLVSTS      (vt596_smba + 1)
  57 #define SMBHSTCNT       (vt596_smba + 2)
  58 #define SMBHSTCMD       (vt596_smba + 3)
  59 #define SMBHSTADD       (vt596_smba + 4)
  60 #define SMBHSTDAT0      (vt596_smba + 5)
  61 #define SMBHSTDAT1      (vt596_smba + 6)
  62 #define SMBBLKDAT       (vt596_smba + 7)
  63 #define SMBSLVCNT       (vt596_smba + 8)
  64 #define SMBSHDWCMD      (vt596_smba + 9)
  65 #define SMBSLVEVT       (vt596_smba + 0xA)
  66 #define SMBSLVDAT       (vt596_smba + 0xC)
  67
  68 /* PCI Address Constants */
  69
  70 /* SMBus data in configuration space can be found in two places,
  71    We try to select the better one*/
  72
  73 static unsigned short smb_cf_hstcfg = 0xD2;
  74
  75 #define SMBHSTCFG   (smb_cf_hstcfg)
  76 #define SMBSLVC     (smb_cf_hstcfg + 1)
  77 #define SMBSHDW1    (smb_cf_hstcfg + 2)
  78 #define SMBSHDW2    (smb_cf_hstcfg + 3)
  79 #define SMBREV      (smb_cf_hstcfg + 4)
  80
  81 /* Other settings */
  82 #define MAX_TIMEOUT     500
  83 #define ENABLE_INT9     0
  84
  85 /* VT82C596 constants */
  86 #define VT596_QUICK      0x00
  87 #define VT596_BYTE       0x04
  88 #define VT596_BYTE_DATA  0x08
  89 #define VT596_WORD_DATA  0x0C
  90 #define VT596_BLOCK_DATA 0x14
  91
  92
  93 /* If force is set to anything different from 0, we forcibly enable the
  94    VT596. DANGEROUS! */
  95 static int force;
  96 module_param(force, bool, 0);
  97 MODULE_PARM_DESC(force, "Forcibly enable the SMBus. DANGEROUS!");
  98
  99 /* If force_addr is set to anything different from 0, we forcibly enable
 100    the VT596 at the given address. VERY DANGEROUS! */
 101 static u16 force_addr;
 102 module_param(force_addr, ushort, 0);
 103 MODULE_PARM_DESC(force_addr,
 104                  "Forcibly enable the SMBus at the given address. "
 105                  "EXTREMELY DANGEROUS!");
 106
 107
 108 static struct i2c_adapter vt596_adapter;
 109
 110 /* Another internally used function */
 111 static int vt596_transaction(void)
 112 {
 113         int temp;
 114         int result = 0;
 115         int timeout = 0;
 116
 117         dev_dbg(&vt596_adapter.dev, "Transaction (pre): CNT=%02x, CMD=%02x, "
 118                 "ADD=%02x, DAT0=%02x, DAT1=%02x\n", inb_p(SMBHSTCNT),
 119                 inb_p(SMBHSTCMD), inb_p(SMBHSTADD), inb_p(SMBHSTDAT0),
 120                 inb_p(SMBHSTDAT1));
 121
 122         /* Make sure the SMBus host is ready to start transmitting */
 123         if ((temp = inb_p(SMBHSTSTS)) & 0x1F) {
 124                 dev_dbg(&vt596_adapter.dev, "SMBus busy (0x%02x). "
 125                                 "Resetting...\n", temp);
 126
 127                 outb_p(temp, SMBHSTSTS);
 128                 if ((temp = inb_p(SMBHSTSTS)) & 0x1F) {
 129                         dev_dbg(&vt596_adapter.dev, "Failed! (0x%02x)\n", temp);
 130
 131                         return -1;
 132                 } else {
 133                         dev_dbg(&vt596_adapter.dev, "Successfull!\n");
 134                 }
 135         }
 136
 137         /* start the transaction by setting bit 6 */
 138         outb_p(inb(SMBHSTCNT) | 0x040, SMBHSTCNT);
 139
 140         /* We will always wait for a fraction of a second!
 141            I don't know if VIA needs this, Intel did  */
 142         do {
 143                 msleep(1);
 144                 temp = inb_p(SMBHSTSTS);
 145         } while ((temp & 0x01) && (timeout++ < MAX_TIMEOUT));
 146
 147         /* If the SMBus is still busy, we give up */
 148         if (timeout >= MAX_TIMEOUT) {
 149                 result = -1;
 150                 dev_dbg(&vt596_adapter.dev, "SMBus Timeout!\n");
 151         }
 152
 153         if (temp & 0x10) {
 154                 result = -1;
 155                 dev_dbg(&vt596_adapter.dev, "Error: Failed bus transaction\n");
 156         }
 157
 158         if (temp & 0x08) {
 159                 result = -1;
 160                 dev_info(&vt596_adapter.dev, "Bus collision! SMBus may be "
 161                         "locked until next hard\nreset. (sorry!)\n");
 162                 /* Clock stops and slave is stuck in mid-transmission */
 163         }
 164
 165         if (temp & 0x04) {
 166                 result = -1;
 167                 dev_dbg(&vt596_adapter.dev, "Error: no response!\n");
 168         }
 169
 170         if ((temp = inb_p(SMBHSTSTS)) & 0x1F) {
 171                 outb_p(temp, SMBHSTSTS);
 172                 if ((temp = inb_p(SMBHSTSTS)) & 0x1F) {
 173                         dev_warn(&vt596_adapter.dev, "Failed reset at end "
 174                                  "of transaction (%02x)\n", temp);
 175                 }
 176         }
 177
 178         dev_dbg(&vt596_adapter.dev, "Transaction (post): CNT=%02x, CMD=%02x, "
 179                 "ADD=%02x, DAT0=%02x, DAT1=%02x\n", inb_p(SMBHSTCNT),
 180                 inb_p(SMBHSTCMD), inb_p(SMBHSTADD), inb_p(SMBHSTDAT0),
 181                 inb_p(SMBHSTDAT1));
 182
 183         return result;
 184 }
 185
 186 /* Return -1 on error. */
 187 static s32 vt596_access(struct i2c_adapter *adap, u16 addr,
 188                 unsigned short flags,  char read_write, u8 command,
 189                 int size,  union i2c_smbus_data *data)
 190 {
 191         int i, len;
 192
 193         switch (size) {
 194         case I2C_SMBUS_PROC_CALL:
 195                 dev_info(&vt596_adapter.dev,
 196                          "I2C_SMBUS_PROC_CALL not supported!\n");
 197                 return -1;
 198         case I2C_SMBUS_QUICK:
 199                 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
 200                        SMBHSTADD);
 201                 size = VT596_QUICK;
 202                 break;
 203         case I2C_SMBUS_BYTE:
 204                 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
 205                        SMBHSTADD);
 206                 if (read_write == I2C_SMBUS_WRITE)
 207                         outb_p(command, SMBHSTCMD);
 208                 size = VT596_BYTE;
 209                 break;
 210         case I2C_SMBUS_BYTE_DATA:
 211                 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
 212                        SMBHSTADD);
 213                 outb_p(command, SMBHSTCMD);
 214                 if (read_write == I2C_SMBUS_WRITE)
 215                         outb_p(data->byte, SMBHSTDAT0);
 216                 size = VT596_BYTE_DATA;
 217                 break;
 218         case I2C_SMBUS_WORD_DATA:
 219                 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
 220                        SMBHSTADD);
 221                 outb_p(command, SMBHSTCMD);
 222                 if (read_write == I2C_SMBUS_WRITE) {
 223                         outb_p(data->word & 0xff, SMBHSTDAT0);
 224                         outb_p((data->word & 0xff00) >> 8, SMBHSTDAT1);
 225                 }
 226                 size = VT596_WORD_DATA;
 227                 break;
 228         case I2C_SMBUS_BLOCK_DATA:
 229                 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
 230                        SMBHSTADD);
 231                 outb_p(command, SMBHSTCMD);
 232                 if (read_write == I2C_SMBUS_WRITE) {
 233                         len = data->block[0];
 234                         if (len < 0)
 235                                 len = 0;
 236                         if (len > I2C_SMBUS_BLOCK_MAX)
 237                                 len = I2C_SMBUS_BLOCK_MAX;
 238                         outb_p(len, SMBHSTDAT0);
 239                         i = inb_p(SMBHSTCNT);   /* Reset SMBBLKDAT */
 240                         for (i = 1; i <= len; i++)
 241                                 outb_p(data->block[i], SMBBLKDAT);
 242                 }
 243                 size = VT596_BLOCK_DATA;
 244                 break;
 245         }
 246
 247         outb_p((size & 0x1C) + (ENABLE_INT9 & 1), SMBHSTCNT);
 248
 249         if (vt596_transaction()) /* Error in transaction */
 250                 return -1;
 251
 252         if ((read_write == I2C_SMBUS_WRITE) || (size == VT596_QUICK))
 253                 return 0;
 254
 255         switch (size) {
 256         case VT596_BYTE:
 257                 /* Where is the result put? I assume here it is in
 258                  * SMBHSTDAT0 but it might just as well be in the
 259                  * SMBHSTCMD. No clue in the docs
 260                  */
 261                 data->byte = inb_p(SMBHSTDAT0);
 262                 break;
 263         case VT596_BYTE_DATA:
 264                 data->byte = inb_p(SMBHSTDAT0);
 265                 break;
 266         case VT596_WORD_DATA:
 267                 data->word = inb_p(SMBHSTDAT0) + (inb_p(SMBHSTDAT1) << 8);
 268                 break;
 269         case VT596_BLOCK_DATA:
 270                 data->block[0] = inb_p(SMBHSTDAT0);
 271                 if (data->block[0] > I2C_SMBUS_BLOCK_MAX)
 272                         data->block[0] = I2C_SMBUS_BLOCK_MAX;
 273                 i = inb_p(SMBHSTCNT);   /* Reset SMBBLKDAT */
 274                 for (i = 1; i <= data->block[0]; i++)
 275                         data->block[i] = inb_p(SMBBLKDAT);
 276                 break;
 277         }
 278         return 0;
 279 }
 280
 281 static u32 vt596_func(struct i2c_adapter *adapter)
 282 {
 283         return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
 284             I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
 285             I2C_FUNC_SMBUS_BLOCK_DATA;
 286 }
 287
 288 static struct i2c_algorithm smbus_algorithm = {
 289         .smbus_xfer     = vt596_access,
 290         .functionality  = vt596_func,
 291 };
 292
 293 static struct i2c_adapter vt596_adapter = {
 294         .owner          = THIS_MODULE,
 295         .class          = I2C_CLASS_HWMON,
 296         .algo           = &smbus_algorithm,
 297         .name           = "unset",
 298 };
 299
 300 static int __devinit vt596_probe(struct pci_dev *pdev,
 301                                  const struct pci_device_id *id)
 302 {
 303         unsigned char temp;
 304         int error = -ENODEV;
 305
 306         /* Determine the address of the SMBus areas */
 307         if (force_addr) {
 308                 vt596_smba = force_addr & 0xfff0;
 309                 force = 0;
 310                 goto found;
 311         }
 312
 313         if ((pci_read_config_word(pdev, id->driver_data, &vt596_smba)) ||
 314             !(vt596_smba & 0x1)) {
 315                 /* try 2nd address and config reg. for 596 */
 316                 if (id->device == PCI_DEVICE_ID_VIA_82C596_3 &&
 317                     !pci_read_config_word(pdev, SMBBA2, &vt596_smba) &&
 318                     (vt596_smba & 0x1)) {
 319                         smb_cf_hstcfg = 0x84;
 320                 } else {
 321                         /* no matches at all */
 322                         dev_err(&pdev->dev, "Cannot configure "
 323                                 "SMBus I/O Base address\n");
 324                         return -ENODEV;
 325                 }
 326         }
 327
 328         vt596_smba &= 0xfff0;
 329         if (vt596_smba == 0) {
 330                 dev_err(&pdev->dev, "SMBus base address "
 331                         "uninitialized - upgrade BIOS or use "
 332                         "force_addr=0xaddr\n");
 333                 return -ENODEV;
 334         }
 335
 336  found:
 337         if (!request_region(vt596_smba, 8, "viapro-smbus")) {
 338                 dev_err(&pdev->dev, "SMBus region 0x%x already in use!\n",
 339                         vt596_smba);
 340                 return -ENODEV;
 341         }
 342
 343         pci_read_config_byte(pdev, SMBHSTCFG, &temp);
 344         /* If force_addr is set, we program the new address here. Just to make
 345            sure, we disable the VT596 first. */
 346         if (force_addr) {
 347                 pci_write_config_byte(pdev, SMBHSTCFG, temp & 0xfe);
 348                 pci_write_config_word(pdev, id->driver_data, vt596_smba);
 349                 pci_write_config_byte(pdev, SMBHSTCFG, temp | 0x01);
 350                 dev_warn(&pdev->dev, "WARNING: SMBus interface set to new "
 351                      "address 0x%04x!\n", vt596_smba);
 352         } else if ((temp & 1) == 0) {
 353                 if (force) {
 354                         /* NOTE: This assumes I/O space and other allocations
 355                          * WERE done by the Bios!  Don't complain if your
 356                          * hardware does weird things after enabling this.
 357                          * :') Check for Bios updates before resorting to
 358                          * this.
 359                          */
 360                         pci_write_config_byte(pdev, SMBHSTCFG, temp | 1);
 361                         dev_info(&pdev->dev, "Enabling SMBus device\n");
 362                 } else {
 363                         dev_err(&pdev->dev, "SMBUS: Error: Host SMBus "
 364                                 "controller not enabled! - upgrade BIOS or "
 365                                 "use force=1\n");
 366                         goto release_region;
 367                 }
 368         }
 369
 370         if ((temp & 0x0E) == 8)
 371                 dev_dbg(&pdev->dev, "using Interrupt 9 for SMBus.\n");
 372         else if ((temp & 0x0E) == 0)
 373                 dev_dbg(&pdev->dev, "using Interrupt SMI# for SMBus.\n");
 374         else
 375                 dev_dbg(&pdev->dev, "Illegal Interrupt configuration "
 376                         "(or code out of date)!\n");
 377
 378         pci_read_config_byte(pdev, SMBREV, &temp);
 379         dev_dbg(&pdev->dev, "SMBREV = 0x%X\n", temp);
 380         dev_dbg(&pdev->dev, "VT596_smba = 0x%X\n", vt596_smba);
 381
 382         vt596_adapter.dev.parent = &pdev->dev;
 383         snprintf(vt596_adapter.name, I2C_NAME_SIZE,
 384                         "SMBus Via Pro adapter at %04x", vt596_smba);
 385
 386         vt596_pdev = pci_dev_get(pdev);
 387         if (i2c_add_adapter(&vt596_adapter)) {
 388                 pci_dev_put(vt596_pdev);
 389                 vt596_pdev = NULL;
 390         }
 391
 392         /* Always return failure here.  This is to allow other drivers to bind
 393          * to this pci device.  We don't really want to have control over the
 394          * pci device, we only wanted to read as few register values from it.
 395          */
 396         return -ENODEV;
 397
 398  release_region:
 399         release_region(vt596_smba, 8);
 400         return error;
 401 }
 402
 403 static struct pci_device_id vt596_ids[] = {
 404         { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C596_3),
 405           .driver_data = SMBBA1 },
 406         { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C596B_3),
 407           .driver_data = SMBBA1 },
 408         { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C686_4),
 409           .driver_data = SMBBA1 },
 410         { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8233_0),
 411           .driver_data = SMBBA3 },
 412         { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8233A),
 413           .driver_data = SMBBA3 },
 414         { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8235),
 415           .driver_data = SMBBA3 },
 416         { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8237),
 417           .driver_data = SMBBA3 },
 418         { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8231_4),
 419           .driver_data = SMBBA1 },
 420         { 0, }
 421 };
 422
 423 MODULE_DEVICE_TABLE (pci, vt596_ids);
 424
 425 static struct pci_driver vt596_driver = {
 426         .name           = "vt596_smbus",
 427         .id_table       = vt596_ids,
 428         .probe          = vt596_probe,
 429 };
 430
 431 static int __init i2c_vt596_init(void)
 432 {
 433         return pci_register_driver(&vt596_driver);
 434 }
 435
 436
 437 static void __exit i2c_vt596_exit(void)
 438 {
 439         pci_unregister_driver(&vt596_driver);
 440         if (vt596_pdev != NULL) {
 441                 i2c_del_adapter(&vt596_adapter);
 442                 release_region(vt596_smba, 8);
 443                 pci_dev_put(vt596_pdev);
 444                 vt596_pdev = NULL;
 445         }
 446 }
 447
 448 MODULE_AUTHOR(
 449     "Frodo Looijaard <frodol@dds.nl> and "
 450     "Philip Edelbrock <phil@netroedge.com>");
 451 MODULE_DESCRIPTION("vt82c596 SMBus driver");
 452 MODULE_LICENSE("GPL");
 453
 454 module_init(i2c_vt596_init);
 455 module_exit(i2c_vt596_exit);