[mirror_ubuntu-zesty-kernel.git] / drivers / i2c / busses / i2c-viapro.c

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