[linux-block.git] / drivers / i2c / busses / i2c-viapro.c

/*
    i2c-viapro.c - Part of lm_sensors, Linux kernel modules for hardware
              monitoring
    Copyright (c) 1998 - 2002  Frodo Looijaard <frodol@dds.nl>,
    Philip Edelbrock <phil@netroedge.com>, Kyösti Mälkki <kmalkki@cc.hut.fi>,
    Mark D. Studebaker <mdsxyz123@yahoo.com>
    Copyright (C) 2005 - 2007  Jean Delvare <khali@linux-fr.org>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

/*
   Supports the following VIA south bridges:

   Chip name          PCI ID  REV     I2C block
   VT82C596A          0x3050             no
   VT82C596B          0x3051             no
   VT82C686A          0x3057  0x30       no
   VT82C686B          0x3057  0x40       yes
   VT8231             0x8235             no?
   VT8233             0x3074             yes
   VT8233A            0x3147             yes?
   VT8235             0x3177             yes
   VT8237R            0x3227             yes
   VT8237A            0x3337             yes
   VT8251             0x3287             yes
   CX700              0x8324             yes

   Note: we assume there can only be one device, with one SMBus interface.
*/

#include <linux/module.h>
#include <linux/delay.h>
#include <linux/pci.h>
#include <linux/kernel.h>
#include <linux/stddef.h>
#include <linux/ioport.h>
#include <linux/i2c.h>
#include <linux/init.h>
#include <asm/io.h>

static struct pci_dev *vt596_pdev;

#define SMBBA1		0x90
#define SMBBA2		0x80
#define SMBBA3		0xD0

/* SMBus address offsets */
static unsigned short vt596_smba;
#define SMBHSTSTS	(vt596_smba + 0)
#define SMBHSTCNT	(vt596_smba + 2)
#define SMBHSTCMD	(vt596_smba + 3)
#define SMBHSTADD	(vt596_smba + 4)
#define SMBHSTDAT0	(vt596_smba + 5)
#define SMBHSTDAT1	(vt596_smba + 6)
#define SMBBLKDAT	(vt596_smba + 7)

/* PCI Address Constants */

/* SMBus data in configuration space can be found in two places,
   We try to select the better one */

static unsigned short SMBHSTCFG = 0xD2;

/* Other settings */
#define MAX_TIMEOUT	500

/* VT82C596 constants */
#define VT596_QUICK		0x00
#define VT596_BYTE		0x04
#define VT596_BYTE_DATA		0x08
#define VT596_WORD_DATA		0x0C
#define VT596_BLOCK_DATA	0x14
#define VT596_I2C_BLOCK_DATA	0x34


/* If force is set to anything different from 0, we forcibly enable the
   VT596. DANGEROUS! */
static int force;
module_param(force, bool, 0);
MODULE_PARM_DESC(force, "Forcibly enable the SMBus. DANGEROUS!");

/* If force_addr is set to anything different from 0, we forcibly enable
   the VT596 at the given address. VERY DANGEROUS! */
static u16 force_addr;
module_param(force_addr, ushort, 0);
MODULE_PARM_DESC(force_addr,
		 "Forcibly enable the SMBus at the given address. "
		 "EXTREMELY DANGEROUS!");


static struct pci_driver vt596_driver;
static struct i2c_adapter vt596_adapter;

#define FEATURE_I2CBLOCK	(1<<0)
static unsigned int vt596_features;

#ifdef DEBUG
static void vt596_dump_regs(const char *msg, u8 size)
{
	dev_dbg(&vt596_adapter.dev, "%s: STS=%02x CNT=%02x CMD=%02x ADD=%02x "
		"DAT=%02x,%02x\n", msg, inb_p(SMBHSTSTS), inb_p(SMBHSTCNT),
		inb_p(SMBHSTCMD), inb_p(SMBHSTADD), inb_p(SMBHSTDAT0),
		inb_p(SMBHSTDAT1));

	if (size == VT596_BLOCK_DATA
	 || size == VT596_I2C_BLOCK_DATA) {
		int i;

		dev_dbg(&vt596_adapter.dev, "BLK=");
		for (i = 0; i < I2C_SMBUS_BLOCK_MAX / 2; i++)
			printk("%02x,", inb_p(SMBBLKDAT));
		printk("\n");
		dev_dbg(&vt596_adapter.dev, "    ");
		for (; i < I2C_SMBUS_BLOCK_MAX - 1; i++)
			printk("%02x,", inb_p(SMBBLKDAT));
		printk("%02x\n", inb_p(SMBBLKDAT));
	}
}
#else
static inline void vt596_dump_regs(const char *msg, u8 size) { }
#endif

/* Return -1 on error, 0 on success */
static int vt596_transaction(u8 size)
{
	int temp;
	int result = 0;
	int timeout = 0;

	vt596_dump_regs("Transaction (pre)", size);

	/* Make sure the SMBus host is ready to start transmitting */
	if ((temp = inb_p(SMBHSTSTS)) & 0x1F) {
		dev_dbg(&vt596_adapter.dev, "SMBus busy (0x%02x). "
			"Resetting...\n", temp);

		outb_p(temp, SMBHSTSTS);
		if ((temp = inb_p(SMBHSTSTS)) & 0x1F) {
			dev_err(&vt596_adapter.dev, "SMBus reset failed! "
				"(0x%02x)\n", temp);
			return -1;
		}
	}

	/* Start the transaction by setting bit 6 */
	outb_p(0x40 | size, SMBHSTCNT);

	/* We will always wait for a fraction of a second */
	do {
		msleep(1);
		temp = inb_p(SMBHSTSTS);
	} while ((temp & 0x01) && (timeout++ < MAX_TIMEOUT));

	/* If the SMBus is still busy, we give up */
	if (timeout >= MAX_TIMEOUT) {
		result = -1;
		dev_err(&vt596_adapter.dev, "SMBus timeout!\n");
	}

	if (temp & 0x10) {
		result = -1;
		dev_err(&vt596_adapter.dev, "Transaction failed (0x%02x)\n",
			size);
	}

	if (temp & 0x08) {
		result = -1;
		dev_err(&vt596_adapter.dev, "SMBus collision!\n");
	}

	if (temp & 0x04) {
		int read = inb_p(SMBHSTADD) & 0x01;
		result = -1;
		/* The quick and receive byte commands are used to probe
		   for chips, so errors are expected, and we don't want
		   to frighten the user. */
		if (!((size == VT596_QUICK && !read) ||
		      (size == VT596_BYTE && read)))
			dev_err(&vt596_adapter.dev, "Transaction error!\n");
	}

	/* Resetting status register */
	if (temp & 0x1F)
		outb_p(temp, SMBHSTSTS);

	vt596_dump_regs("Transaction (post)", size);

	return result;
}

/* Return -1 on error, 0 on success */
static s32 vt596_access(struct i2c_adapter *adap, u16 addr,
		unsigned short flags, char read_write, u8 command,
		int size, union i2c_smbus_data *data)
{
	int i;

	switch (size) {
	case I2C_SMBUS_QUICK:
		size = VT596_QUICK;
		break;
	case I2C_SMBUS_BYTE:
		if (read_write == I2C_SMBUS_WRITE)
			outb_p(command, SMBHSTCMD);
		size = VT596_BYTE;
		break;
	case I2C_SMBUS_BYTE_DATA:
		outb_p(command, SMBHSTCMD);
		if (read_write == I2C_SMBUS_WRITE)
			outb_p(data->byte, SMBHSTDAT0);
		size = VT596_BYTE_DATA;
		break;
	case I2C_SMBUS_WORD_DATA:
		outb_p(command, SMBHSTCMD);
		if (read_write == I2C_SMBUS_WRITE) {
			outb_p(data->word & 0xff, SMBHSTDAT0);
			outb_p((data->word & 0xff00) >> 8, SMBHSTDAT1);
		}
		size = VT596_WORD_DATA;
		break;
	case I2C_SMBUS_I2C_BLOCK_DATA:
		if (!(vt596_features & FEATURE_I2CBLOCK))
			goto exit_unsupported;
		if (read_write == I2C_SMBUS_READ)
			outb_p(data->block[0], SMBHSTDAT0);
		/* Fall through */
	case I2C_SMBUS_BLOCK_DATA:
		outb_p(command, SMBHSTCMD);
		if (read_write == I2C_SMBUS_WRITE) {
			u8 len = data->block[0];
			if (len > I2C_SMBUS_BLOCK_MAX)
				len = I2C_SMBUS_BLOCK_MAX;
			outb_p(len, SMBHSTDAT0);
			inb_p(SMBHSTCNT);	/* Reset SMBBLKDAT */
			for (i = 1; i <= len; i++)
				outb_p(data->block[i], SMBBLKDAT);
		}
		size = (size == I2C_SMBUS_I2C_BLOCK_DATA) ?
		       VT596_I2C_BLOCK_DATA : VT596_BLOCK_DATA;
		break;
	default:
		goto exit_unsupported;
	}

	outb_p(((addr & 0x7f) << 1) | read_write, SMBHSTADD);

	if (vt596_transaction(size)) /* Error in transaction */
		return -1;

	if ((read_write == I2C_SMBUS_WRITE) || (size == VT596_QUICK))
		return 0;

	switch (size) {
	case VT596_BYTE:
	case VT596_BYTE_DATA:
		data->byte = inb_p(SMBHSTDAT0);
		break;
	case VT596_WORD_DATA:
		data->word = inb_p(SMBHSTDAT0) + (inb_p(SMBHSTDAT1) << 8);
		break;
	case VT596_I2C_BLOCK_DATA:
	case VT596_BLOCK_DATA:
		data->block[0] = inb_p(SMBHSTDAT0);
		if (data->block[0] > I2C_SMBUS_BLOCK_MAX)
			data->block[0] = I2C_SMBUS_BLOCK_MAX;
		inb_p(SMBHSTCNT);	/* Reset SMBBLKDAT */
		for (i = 1; i <= data->block[0]; i++)
			data->block[i] = inb_p(SMBBLKDAT);
		break;
	}
	return 0;

exit_unsupported:
	dev_warn(&vt596_adapter.dev, "Unsupported command invoked! (0x%02x)\n",
		 size);
	return -1;
}

static u32 vt596_func(struct i2c_adapter *adapter)
{
	u32 func = I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
	    I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
	    I2C_FUNC_SMBUS_BLOCK_DATA;

	if (vt596_features & FEATURE_I2CBLOCK)
		func |= I2C_FUNC_SMBUS_I2C_BLOCK;
	return func;
}

static const struct i2c_algorithm smbus_algorithm = {
	.smbus_xfer	= vt596_access,
	.functionality	= vt596_func,
};

static struct i2c_adapter vt596_adapter = {
	.owner		= THIS_MODULE,
	.id		= I2C_HW_SMBUS_VIA2,
	.class		= I2C_CLASS_HWMON,
	.algo		= &smbus_algorithm,
};

static int __devinit vt596_probe(struct pci_dev *pdev,
				 const struct pci_device_id *id)
{
	unsigned char temp;
	int error = -ENODEV;

	/* Determine the address of the SMBus areas */
	if (force_addr) {
		vt596_smba = force_addr & 0xfff0;
		force = 0;
		goto found;
	}

	if ((pci_read_config_word(pdev, id->driver_data, &vt596_smba)) ||
	    !(vt596_smba & 0x0001)) {
		/* try 2nd address and config reg. for 596 */
		if (id->device == PCI_DEVICE_ID_VIA_82C596_3 &&
		    !pci_read_config_word(pdev, SMBBA2, &vt596_smba) &&
		    (vt596_smba & 0x0001)) {
			SMBHSTCFG = 0x84;
		} else {
			/* no matches at all */
			dev_err(&pdev->dev, "Cannot configure "
				"SMBus I/O Base address\n");
			return -ENODEV;
		}
	}

	vt596_smba &= 0xfff0;
	if (vt596_smba == 0) {
		dev_err(&pdev->dev, "SMBus base address "
			"uninitialized - upgrade BIOS or use "
			"force_addr=0xaddr\n");
		return -ENODEV;
	}

found:
	if (!request_region(vt596_smba, 8, vt596_driver.name)) {
		dev_err(&pdev->dev, "SMBus region 0x%x already in use!\n",
			vt596_smba);
		return -ENODEV;
	}

	pci_read_config_byte(pdev, SMBHSTCFG, &temp);
	/* If force_addr is set, we program the new address here. Just to make
	   sure, we disable the VT596 first. */
	if (force_addr) {
		pci_write_config_byte(pdev, SMBHSTCFG, temp & 0xfe);
		pci_write_config_word(pdev, id->driver_data, vt596_smba);
		pci_write_config_byte(pdev, SMBHSTCFG, temp | 0x01);
		dev_warn(&pdev->dev, "WARNING: SMBus interface set to new "
			 "address 0x%04x!\n", vt596_smba);
	} else if (!(temp & 0x01)) {
		if (force) {
			/* NOTE: This assumes I/O space and other allocations
			 * WERE done by the Bios!  Don't complain if your
			 * hardware does weird things after enabling this.
			 * :') Check for Bios updates before resorting to
			 * this.
			 */
			pci_write_config_byte(pdev, SMBHSTCFG, temp | 0x01);
			dev_info(&pdev->dev, "Enabling SMBus device\n");
		} else {
			dev_err(&pdev->dev, "SMBUS: Error: Host SMBus "
				"controller not enabled! - upgrade BIOS or "
				"use force=1\n");
			goto release_region;
		}
	}

	dev_dbg(&pdev->dev, "VT596_smba = 0x%X\n", vt596_smba);

	switch (pdev->device) {
	case PCI_DEVICE_ID_VIA_CX700:
	case PCI_DEVICE_ID_VIA_8251:
	case PCI_DEVICE_ID_VIA_8237:
	case PCI_DEVICE_ID_VIA_8237A:
	case PCI_DEVICE_ID_VIA_8235:
	case PCI_DEVICE_ID_VIA_8233A:
	case PCI_DEVICE_ID_VIA_8233_0:
		vt596_features |= FEATURE_I2CBLOCK;
		break;
	case PCI_DEVICE_ID_VIA_82C686_4:
		/* The VT82C686B (rev 0x40) does support I2C block
		   transactions, but the VT82C686A (rev 0x30) doesn't */
		if (pdev->revision >= 0x40)
			vt596_features |= FEATURE_I2CBLOCK;
		break;
	}

	vt596_adapter.dev.parent = &pdev->dev;
	snprintf(vt596_adapter.name, sizeof(vt596_adapter.name),
		 "SMBus Via Pro adapter at %04x", vt596_smba);

	vt596_pdev = pci_dev_get(pdev);
	if (i2c_add_adapter(&vt596_adapter)) {
		pci_dev_put(vt596_pdev);
		vt596_pdev = NULL;
	}

	/* Always return failure here.  This is to allow other drivers to bind
	 * to this pci device.  We don't really want to have control over the
	 * pci device, we only wanted to read as few register values from it.
	 */
	return -ENODEV;

release_region:
	release_region(vt596_smba, 8);
	return error;
}

static struct pci_device_id vt596_ids[] = {
	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C596_3),
	  .driver_data = SMBBA1 },
	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C596B_3),
	  .driver_data = SMBBA1 },
	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C686_4),
	  .driver_data = SMBBA1 },
	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8233_0),
	  .driver_data = SMBBA3 },
	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8233A),
	  .driver_data = SMBBA3 },
	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8235),
	  .driver_data = SMBBA3 },
	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8237),
	  .driver_data = SMBBA3 },
	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8237A),
	  .driver_data = SMBBA3 },
	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8231_4),
	  .driver_data = SMBBA1 },
	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8251),
	  .driver_data = SMBBA3 },
	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_CX700),
	  .driver_data = SMBBA3 },
	{ 0, }
};

MODULE_DEVICE_TABLE(pci, vt596_ids);

static struct pci_driver vt596_driver = {
	.name		= "vt596_smbus",
	.id_table	= vt596_ids,
	.probe		= vt596_probe,
};

static int __init i2c_vt596_init(void)
{
	return pci_register_driver(&vt596_driver);
}


static void __exit i2c_vt596_exit(void)
{
	pci_unregister_driver(&vt596_driver);
	if (vt596_pdev != NULL) {
		i2c_del_adapter(&vt596_adapter);
		release_region(vt596_smba, 8);
		pci_dev_put(vt596_pdev);
		vt596_pdev = NULL;
	}
}

MODULE_AUTHOR("Kyosti Malkki <kmalkki@cc.hut.fi>, "
	      "Mark D. Studebaker <mdsxyz123@yahoo.com> and "
	      "Jean Delvare <khali@linux-fr.org>");
MODULE_DESCRIPTION("vt82c596 SMBus driver");
MODULE_LICENSE("GPL");

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