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

// SPDX-License-Identifier: GPL-2.0-or-later
/*
    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 - 2008  Jean Delvare <jdelvare@suse.de>

*/

/*
   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
   VT8237S            0x3372             yes
   VT8251             0x3287             yes
   CX700              0x8324             yes
   VX800/VX820        0x8353             yes
   VX855/VX875        0x8409             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 <linux/acpi.h>
#include <linux/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_PROC_CALL		0x10
#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 bool 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_hw(force_addr, ushort, ioport, 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 -EBUSY;
		}
	}

	/* 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 = -ETIMEDOUT;
		dev_err(&vt596_adapter.dev, "SMBus timeout!\n");
	}

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

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

	if (temp & 0x04) {
		result = -ENXIO;
		dev_dbg(&vt596_adapter.dev, "No response\n");
	}

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

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

	return result;
}

/* Return negative errno 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;
	int status;

	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_PROC_CALL:
		outb_p(command, SMBHSTCMD);
		outb_p(data->word & 0xff, SMBHSTDAT0);
		outb_p((data->word & 0xff00) >> 8, SMBHSTDAT1);
		size = VT596_PROC_CALL;
		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);

	status = vt596_transaction(size);
	if (status)
		return status;

	if (size == VT596_PROC_CALL)
		read_write = I2C_SMBUS_READ;

	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:
	case VT596_PROC_CALL:
		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 transaction %d\n",
		 size);
	return -EOPNOTSUPP;
}

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_SMBUS_PROC_CALL | 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,
	.class		= I2C_CLASS_HWMON | I2C_CLASS_SPD,
	.algo		= &smbus_algorithm,
};

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

	/* 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:
	error = acpi_check_region(vt596_smba, 8, vt596_driver.name);
	if (error)
		return -ENODEV;

	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");
			error = -ENODEV;
			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_VX800:
	case PCI_DEVICE_ID_VIA_VX855:
	case PCI_DEVICE_ID_VIA_VX900:
	case PCI_DEVICE_ID_VIA_8251:
	case PCI_DEVICE_ID_VIA_8237:
	case PCI_DEVICE_ID_VIA_8237A:
	case PCI_DEVICE_ID_VIA_8237S:
	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);
	error = i2c_add_adapter(&vt596_adapter);
	if (error) {
		pci_dev_put(vt596_pdev);
		vt596_pdev = NULL;
		goto release_region;
	}

	/* 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 const 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_8237S),
	  .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 },
	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_VX800),
	  .driver_data = SMBBA3 },
	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_VX855),
	  .driver_data = SMBBA3 },
	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_VX900),
	  .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 <jdelvare@suse.de>");
MODULE_DESCRIPTION("vt82c596 SMBus driver");
MODULE_LICENSE("GPL");

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