[deliverable/linux.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

   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,
	.id		= I2C_HW_SMBUS_VIA2,
	.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 error;

	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_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 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 },
	{ 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
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>
54fb4a05	52	#include <linux/acpi.h>
1da177e4 LT	53	#include <asm/io.h>
	54
	55	static struct pci_dev *vt596_pdev;
	56
5f49ef8e JD	57	#define SMBBA1 0x90
	58	#define SMBBA2 0x80
	59	#define SMBBA3 0xD0
1da177e4 LT	60
	61	/* SMBus address offsets */
	62	static unsigned short vt596_smba;
	63	#define SMBHSTSTS (vt596_smba + 0)
1da177e4 LT	64	#define SMBHSTCNT (vt596_smba + 2)
	65	#define SMBHSTCMD (vt596_smba + 3)
	66	#define SMBHSTADD (vt596_smba + 4)
	67	#define SMBHSTDAT0 (vt596_smba + 5)
	68	#define SMBHSTDAT1 (vt596_smba + 6)
	69	#define SMBBLKDAT (vt596_smba + 7)
1da177e4 LT	70
	71	/* PCI Address Constants */
	72
	73	/* SMBus data in configuration space can be found in two places,
5f49ef8e	74	We try to select the better one */
1da177e4	75
c2f559d5	76	static unsigned short SMBHSTCFG = 0xD2;
1da177e4 LT	77
	78	/* Other settings */
	79	#define MAX_TIMEOUT 500
1da177e4 LT	80
1da177e4 LT	81	/* VT82C596 constants */
5f49ef8e JD	82	#define VT596_QUICK 0x00
	83	#define VT596_BYTE 0x04
	84	#define VT596_BYTE_DATA 0x08
	85	#define VT596_WORD_DATA 0x0C
a05f2c5a	86	#define VT596_PROC_CALL 0x10
5f49ef8e	87	#define VT596_BLOCK_DATA 0x14
f1183014	88	#define VT596_I2C_BLOCK_DATA 0x34
1da177e4 LT	89
	90
	91	/* If force is set to anything different from 0, we forcibly enable the
	92	VT596. DANGEROUS! */
	93	static int force;
	94	module_param(force, bool, 0);
	95	MODULE_PARM_DESC(force, "Forcibly enable the SMBus. DANGEROUS!");
	96
	97	/* If force_addr is set to anything different from 0, we forcibly enable
	98	the VT596 at the given address. VERY DANGEROUS! */
	99	static u16 force_addr;
	100	module_param(force_addr, ushort, 0);
	101	MODULE_PARM_DESC(force_addr,
	102	"Forcibly enable the SMBus at the given address. "
	103	"EXTREMELY DANGEROUS!");
	104
	105
c2f559d5	106	static struct pci_driver vt596_driver;
1da177e4 LT	107	static struct i2c_adapter vt596_adapter;
1da177e4 LT	108
f1183014 JD	109	#define FEATURE_I2CBLOCK (1<<0)
	110	static unsigned int vt596_features;
	111
ed5453e5 JD	112	#ifdef DEBUG
	113	static void vt596_dump_regs(const char *msg, u8 size)
	114	{
	115	dev_dbg(&vt596_adapter.dev, "%s: STS=%02x CNT=%02x CMD=%02x ADD=%02x "
	116	"DAT=%02x,%02x\n", msg, inb_p(SMBHSTSTS), inb_p(SMBHSTCNT),
	117	inb_p(SMBHSTCMD), inb_p(SMBHSTADD), inb_p(SMBHSTDAT0),
	118	inb_p(SMBHSTDAT1));
	119
	120	if (size == VT596_BLOCK_DATA
	121	\|\| size == VT596_I2C_BLOCK_DATA) {
	122	int i;
	123
	124	dev_dbg(&vt596_adapter.dev, "BLK=");
	125	for (i = 0; i < I2C_SMBUS_BLOCK_MAX / 2; i++)
	126	printk("%02x,", inb_p(SMBBLKDAT));
	127	printk("\n");
	128	dev_dbg(&vt596_adapter.dev, " ");
	129	for (; i < I2C_SMBUS_BLOCK_MAX - 1; i++)
	130	printk("%02x,", inb_p(SMBBLKDAT));
	131	printk("%02x\n", inb_p(SMBBLKDAT));
	132	}
	133	}
ca68f119 GK	134	#else
ca68f119 GK	135	static inline void vt596_dump_regs(const char *msg, u8 size) { }
ed5453e5 JD	136	#endif
ed5453e5 JD	137
c2f559d5	138	/* Return -1 on error, 0 on success */
50c1cc33	139	static int vt596_transaction(u8 size)
1da177e4 LT	140	{
	141	int temp;
	142	int result = 0;
	143	int timeout = 0;
	144
ed5453e5	145	vt596_dump_regs("Transaction (pre)", size);
1da177e4 LT	146
	147	/* Make sure the SMBus host is ready to start transmitting */
	148	if ((temp = inb_p(SMBHSTSTS)) & 0x1F) {
	149	dev_dbg(&vt596_adapter.dev, "SMBus busy (0x%02x). "
8750197f	150	"Resetting...\n", temp);
5f49ef8e	151
1da177e4 LT	152	outb_p(temp, SMBHSTSTS);
1da177e4 LT	153	if ((temp = inb_p(SMBHSTSTS)) & 0x1F) {
8750197f JD	154	dev_err(&vt596_adapter.dev, "SMBus reset failed! "
8750197f JD	155	"(0x%02x)\n", temp);
97140342	156	return -EBUSY;
1da177e4 LT	157	}
	158	}
	159
c2f559d5	160	/* Start the transaction by setting bit 6 */
8750197f	161	outb_p(0x40 \| size, SMBHSTCNT);
1da177e4	162
c2f559d5	163	/* We will always wait for a fraction of a second */
1da177e4 LT	164	do {
	165	msleep(1);
	166	temp = inb_p(SMBHSTSTS);
	167	} while ((temp & 0x01) && (timeout++ < MAX_TIMEOUT));
	168
	169	/* If the SMBus is still busy, we give up */
	170	if (timeout >= MAX_TIMEOUT) {
97140342	171	result = -ETIMEDOUT;
c2f559d5	172	dev_err(&vt596_adapter.dev, "SMBus timeout!\n");
1da177e4 LT	173	}
	174
	175	if (temp & 0x10) {
97140342	176	result = -EIO;
c2f559d5	177	dev_err(&vt596_adapter.dev, "Transaction failed (0x%02x)\n",
8750197f	178	size);
1da177e4 LT	179	}
	180
	181	if (temp & 0x08) {
97140342	182	result = -EIO;
c2f559d5	183	dev_err(&vt596_adapter.dev, "SMBus collision!\n");
1da177e4 LT	184	}
	185
	186	if (temp & 0x04) {
8750197f	187	int read = inb_p(SMBHSTADD) & 0x01;
97140342	188	result = -ENXIO;
8750197f JD	189	/* The quick and receive byte commands are used to probe
	190	for chips, so errors are expected, and we don't want
	191	to frighten the user. */
	192	if (!((size == VT596_QUICK && !read) \|\|
	193	(size == VT596_BYTE && read)))
c2f559d5	194	dev_err(&vt596_adapter.dev, "Transaction error!\n");
1da177e4 LT	195	}
1da177e4 LT	196
c2f559d5 JD	197	/* Resetting status register */
c2f559d5 JD	198	if (temp & 0x1F)
1da177e4	199	outb_p(temp, SMBHSTSTS);
1da177e4	200
ed5453e5	201	vt596_dump_regs("Transaction (post)", size);
5f49ef8e	202
1da177e4 LT	203	return result;
	204	}
	205
97140342	206	/* Return negative errno on error, 0 on success */
1da177e4	207	static s32 vt596_access(struct i2c_adapter *adap, u16 addr,
5f49ef8e JD	208	unsigned short flags, char read_write, u8 command,
5f49ef8e JD	209	int size, union i2c_smbus_data *data)
1da177e4	210	{
c2f559d5	211	int i;
97140342	212	int status;
1da177e4 LT	213
1da177e4 LT	214	switch (size) {
1da177e4	215	case I2C_SMBUS_QUICK:
1da177e4 LT	216	size = VT596_QUICK;
	217	break;
	218	case I2C_SMBUS_BYTE:
1da177e4 LT	219	if (read_write == I2C_SMBUS_WRITE)
	220	outb_p(command, SMBHSTCMD);
	221	size = VT596_BYTE;
	222	break;
	223	case I2C_SMBUS_BYTE_DATA:
1da177e4 LT	224	outb_p(command, SMBHSTCMD);
	225	if (read_write == I2C_SMBUS_WRITE)
	226	outb_p(data->byte, SMBHSTDAT0);
	227	size = VT596_BYTE_DATA;
	228	break;
	229	case I2C_SMBUS_WORD_DATA:
1da177e4 LT	230	outb_p(command, SMBHSTCMD);
	231	if (read_write == I2C_SMBUS_WRITE) {
	232	outb_p(data->word & 0xff, SMBHSTDAT0);
	233	outb_p((data->word & 0xff00) >> 8, SMBHSTDAT1);
	234	}
	235	size = VT596_WORD_DATA;
	236	break;
a05f2c5a PM	237	case I2C_SMBUS_PROC_CALL:
	238	outb_p(command, SMBHSTCMD);
	239	outb_p(data->word & 0xff, SMBHSTDAT0);
	240	outb_p((data->word & 0xff00) >> 8, SMBHSTDAT1);
	241	size = VT596_PROC_CALL;
	242	break;
f1183014 JD	243	case I2C_SMBUS_I2C_BLOCK_DATA:
f1183014 JD	244	if (!(vt596_features & FEATURE_I2CBLOCK))
c2f559d5	245	goto exit_unsupported;
f1183014	246	if (read_write == I2C_SMBUS_READ)
4b2643d7	247	outb_p(data->block[0], SMBHSTDAT0);
f1183014	248	/* Fall through */
1da177e4	249	case I2C_SMBUS_BLOCK_DATA:
1da177e4 LT	250	outb_p(command, SMBHSTCMD);
1da177e4 LT	251	if (read_write == I2C_SMBUS_WRITE) {
c2f559d5	252	u8 len = data->block[0];
1da177e4 LT	253	if (len > I2C_SMBUS_BLOCK_MAX)
	254	len = I2C_SMBUS_BLOCK_MAX;
	255	outb_p(len, SMBHSTDAT0);
c2f559d5	256	inb_p(SMBHSTCNT); /* Reset SMBBLKDAT */
1da177e4 LT	257	for (i = 1; i <= len; i++)
	258	outb_p(data->block[i], SMBBLKDAT);
	259	}
f1183014 JD	260	size = (size == I2C_SMBUS_I2C_BLOCK_DATA) ?
f1183014 JD	261	VT596_I2C_BLOCK_DATA : VT596_BLOCK_DATA;
1da177e4	262	break;
c2f559d5 JD	263	default:
c2f559d5 JD	264	goto exit_unsupported;
1da177e4 LT	265	}
1da177e4 LT	266
c2f559d5	267	outb_p(((addr & 0x7f) << 1) \| read_write, SMBHSTADD);
1da177e4	268
97140342 DB	269	status = vt596_transaction(size);
	270	if (status)
	271	return status;
1da177e4	272
a05f2c5a PM	273	if (size == VT596_PROC_CALL)
	274	read_write = I2C_SMBUS_READ;
	275
1da177e4 LT	276	if ((read_write == I2C_SMBUS_WRITE) \|\| (size == VT596_QUICK))
	277	return 0;
	278
	279	switch (size) {
	280	case VT596_BYTE:
1da177e4 LT	281	case VT596_BYTE_DATA:
	282	data->byte = inb_p(SMBHSTDAT0);
	283	break;
	284	case VT596_WORD_DATA:
a05f2c5a	285	case VT596_PROC_CALL:
1da177e4 LT	286	data->word = inb_p(SMBHSTDAT0) + (inb_p(SMBHSTDAT1) << 8);
1da177e4 LT	287	break;
f1183014	288	case VT596_I2C_BLOCK_DATA:
1da177e4 LT	289	case VT596_BLOCK_DATA:
	290	data->block[0] = inb_p(SMBHSTDAT0);
	291	if (data->block[0] > I2C_SMBUS_BLOCK_MAX)
	292	data->block[0] = I2C_SMBUS_BLOCK_MAX;
c2f559d5	293	inb_p(SMBHSTCNT); /* Reset SMBBLKDAT */
1da177e4 LT	294	for (i = 1; i <= data->block[0]; i++)
	295	data->block[i] = inb_p(SMBBLKDAT);
	296	break;
	297	}
	298	return 0;
c2f559d5 JD	299
c2f559d5 JD	300	exit_unsupported:
ac7fc4fb	301	dev_warn(&vt596_adapter.dev, "Unsupported transaction %d\n",
c2f559d5	302	size);
97140342	303	return -EOPNOTSUPP;
1da177e4 LT	304	}
	305
	306	static u32 vt596_func(struct i2c_adapter *adapter)
	307	{
f1183014	308	u32 func = I2C_FUNC_SMBUS_QUICK \| I2C_FUNC_SMBUS_BYTE \|
1da177e4	309	I2C_FUNC_SMBUS_BYTE_DATA \| I2C_FUNC_SMBUS_WORD_DATA \|
a05f2c5a	310	I2C_SMBUS_PROC_CALL \| I2C_FUNC_SMBUS_BLOCK_DATA;
f1183014 JD	311
	312	if (vt596_features & FEATURE_I2CBLOCK)
	313	func \|= I2C_FUNC_SMBUS_I2C_BLOCK;
	314	return func;
1da177e4 LT	315	}
1da177e4 LT	316
8f9082c5	317	static const struct i2c_algorithm smbus_algorithm = {
1da177e4 LT	318	.smbus_xfer = vt596_access,
	319	.functionality = vt596_func,
	320	};
	321
	322	static struct i2c_adapter vt596_adapter = {
	323	.owner = THIS_MODULE,
9ace555d	324	.id = I2C_HW_SMBUS_VIA2,
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);
	367	if (error)
	368	return error;
	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:
c243353a	408	case PCI_DEVICE_ID_VIA_8251:
f1183014	409	case PCI_DEVICE_ID_VIA_8237:
c243353a	410	case PCI_DEVICE_ID_VIA_8237A:
0d227a7e	411	case PCI_DEVICE_ID_VIA_8237S:
f1183014 JD	412	case PCI_DEVICE_ID_VIA_8235:
	413	case PCI_DEVICE_ID_VIA_8233A:
	414	case PCI_DEVICE_ID_VIA_8233_0:
	415	vt596_features \|= FEATURE_I2CBLOCK;
	416	break;
	417	case PCI_DEVICE_ID_VIA_82C686_4:
	418	/* The VT82C686B (rev 0x40) does support I2C block
	419	transactions, but the VT82C686A (rev 0x30) doesn't */
44c10138	420	if (pdev->revision >= 0x40)
f1183014 JD	421	vt596_features \|= FEATURE_I2CBLOCK;
	422	break;
	423	}
	424
1da177e4	425	vt596_adapter.dev.parent = &pdev->dev;
2096b956	426	snprintf(vt596_adapter.name, sizeof(vt596_adapter.name),
5f49ef8e JD	427	"SMBus Via Pro adapter at %04x", vt596_smba);
5f49ef8e JD	428
1da177e4 LT	429	vt596_pdev = pci_dev_get(pdev);
	430	if (i2c_add_adapter(&vt596_adapter)) {
	431	pci_dev_put(vt596_pdev);
	432	vt596_pdev = NULL;
	433	}
	434
	435	/* Always return failure here. This is to allow other drivers to bind
	436	* to this pci device. We don't really want to have control over the
	437	* pci device, we only wanted to read as few register values from it.
	438	*/
	439	return -ENODEV;
	440
5f49ef8e	441	release_region:
1da177e4 LT	442	release_region(vt596_smba, 8);
	443	return error;
	444	}
	445
	446	static struct pci_device_id vt596_ids[] = {
	447	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C596_3),
	448	.driver_data = SMBBA1 },
	449	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C596B_3),
	450	.driver_data = SMBBA1 },
	451	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C686_4),
	452	.driver_data = SMBBA1 },
	453	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8233_0),
	454	.driver_data = SMBBA3 },
	455	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8233A),
	456	.driver_data = SMBBA3 },
	457	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8235),
	458	.driver_data = SMBBA3 },
	459	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8237),
	460	.driver_data = SMBBA3 },
c243353a RM	461	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8237A),
c243353a RM	462	.driver_data = SMBBA3 },
0d227a7e JD	463	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8237S),
0d227a7e JD	464	.driver_data = SMBBA3 },
1da177e4 LT	465	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8231_4),
1da177e4 LT	466	.driver_data = SMBBA1 },
c243353a RM	467	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8251),
c243353a RM	468	.driver_data = SMBBA3 },
ab6a6ed2 JD	469	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_CX700),
ab6a6ed2 JD	470	.driver_data = SMBBA3 },
b806a71a RM	471	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_VX800),
b806a71a RM	472	.driver_data = SMBBA3 },
1da177e4 LT	473	{ 0, }
	474	};
	475
5f49ef8e	476	MODULE_DEVICE_TABLE(pci, vt596_ids);
1da177e4 LT	477
	478	static struct pci_driver vt596_driver = {
	479	.name = "vt596_smbus",
	480	.id_table = vt596_ids,
	481	.probe = vt596_probe,
	482	};
	483
	484	static int __init i2c_vt596_init(void)
	485	{
	486	return pci_register_driver(&vt596_driver);
	487	}
	488
	489
	490	static void __exit i2c_vt596_exit(void)
	491	{
	492	pci_unregister_driver(&vt596_driver);
	493	if (vt596_pdev != NULL) {
	494	i2c_del_adapter(&vt596_adapter);
	495	release_region(vt596_smba, 8);
	496	pci_dev_put(vt596_pdev);
	497	vt596_pdev = NULL;
	498	}
	499	}
	500
8750197f JD	501	MODULE_AUTHOR("Kyosti Malkki <kmalkki@cc.hut.fi>, "
	502	"Mark D. Studebaker <mdsxyz123@yahoo.com> and "
	503	"Jean Delvare <khali@linux-fr.org>");
1da177e4 LT	504	MODULE_DESCRIPTION("vt82c596 SMBus driver");
	505	MODULE_LICENSE("GPL");
	506
	507	module_init(i2c_vt596_init);
	508	module_exit(i2c_vt596_exit);