drivers/i2c/busses/i2c-sis5595.c - kernel/msm-4.19 - Gitiles

 /*
     Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl> and
     Philip Edelbrock <phil@netroedge.com>

     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.
 */

 /* Note: we assume there can only be one SIS5595 with one SMBus interface */

 /*
    Note: all have mfr. ID 0x1039.
    SUPPORTED		PCI ID
 	5595		0008

    Note: these chips contain a 0008 device which is incompatible with the
          5595. We recognize these by the presence of the listed
          "blacklist" PCI ID and refuse to load.

    NOT SUPPORTED	PCI ID		BLACKLIST PCI ID
 	 540		0008		0540
 	 550		0008		0550
 	5513		0008		5511
 	5581		0008		5597
 	5582		0008		5597
 	5597		0008		5597
 	5598		0008		5597/5598
 	 630		0008		0630
 	 645		0008		0645
 	 646		0008		0646
 	 648		0008		0648
 	 650		0008		0650
 	 651		0008		0651
 	 730		0008		0730
 	 735		0008		0735
 	 745		0008		0745
 	 746		0008		0746
 */

 /* TO DO:
  * Add Block Transfers (ugly, but supported by the adapter)
  * Add adapter resets
  */

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

 static int blacklist[] = {
 	PCI_DEVICE_ID_SI_540,
 	PCI_DEVICE_ID_SI_550,
 	PCI_DEVICE_ID_SI_630,
 	PCI_DEVICE_ID_SI_645,
 	PCI_DEVICE_ID_SI_646,
 	PCI_DEVICE_ID_SI_648,
 	PCI_DEVICE_ID_SI_650,
 	PCI_DEVICE_ID_SI_651,
 	PCI_DEVICE_ID_SI_730,
 	PCI_DEVICE_ID_SI_735,
 	PCI_DEVICE_ID_SI_745,
 	PCI_DEVICE_ID_SI_746,
 	PCI_DEVICE_ID_SI_5511,	/* 5513 chip has the 0008 device but that ID
 				   shows up in other chips so we use the 5511
 				   ID for recognition */
 	PCI_DEVICE_ID_SI_5597,
 	PCI_DEVICE_ID_SI_5598,
 	0,			/* terminates the list */
 };

 /* Length of ISA address segment */
 #define SIS5595_EXTENT		8
 /* SIS5595 SMBus registers */
 #define SMB_STS_LO		0x00
 #define SMB_STS_HI		0x01
 #define SMB_CTL_LO		0x02
 #define SMB_CTL_HI		0x03
 #define SMB_ADDR		0x04
 #define SMB_CMD			0x05
 #define SMB_PCNT		0x06
 #define SMB_CNT			0x07
 #define SMB_BYTE		0x08
 #define SMB_DEV			0x10
 #define SMB_DB0			0x11
 #define SMB_DB1			0x12
 #define SMB_HAA			0x13

 /* PCI Address Constants */
 #define SMB_INDEX		0x38
 #define SMB_DAT			0x39
 #define SIS5595_ENABLE_REG	0x40
 #define ACPI_BASE		0x90

 /* Other settings */
 #define MAX_TIMEOUT		500

 /* SIS5595 constants */
 #define SIS5595_QUICK		0x00
 #define SIS5595_BYTE		0x02
 #define SIS5595_BYTE_DATA	0x04
 #define SIS5595_WORD_DATA	0x06
 #define SIS5595_PROC_CALL	0x08
 #define SIS5595_BLOCK_DATA	0x0A

 /* insmod parameters */

 /* If force_addr is set to anything different from 0, we forcibly enable
    the device at the given address. */
 static u16 force_addr;
 module_param(force_addr, ushort, 0);
 MODULE_PARM_DESC(force_addr, "Initialize the base address of the i2c controller");

 static struct pci_driver sis5595_driver;
 static unsigned short sis5595_base;
 static struct pci_dev *sis5595_pdev;

 static u8 sis5595_read(u8 reg)
 {
 	outb(reg, sis5595_base + SMB_INDEX);
 	return inb(sis5595_base + SMB_DAT);
 }

 static void sis5595_write(u8 reg, u8 data)
 {
 	outb(reg, sis5595_base + SMB_INDEX);
 	outb(data, sis5595_base + SMB_DAT);
 }

 static int sis5595_setup(struct pci_dev *SIS5595_dev)
 {
 	u16 a;
 	u8 val;
 	int *i;
 	int retval = -ENODEV;

 	/* Look for imposters */
 	for (i = blacklist; *i != 0; i++) {
 		struct pci_dev *dev;
 		dev = pci_get_device(PCI_VENDOR_ID_SI, *i, NULL);
 		if (dev) {
 			dev_err(&SIS5595_dev->dev, "Looked for SIS5595 but found unsupported device %.4x\n", *i);
 			pci_dev_put(dev);
 			return -ENODEV;
 		}
 	}

 	/* Determine the address of the SMBus areas */
 	pci_read_config_word(SIS5595_dev, ACPI_BASE, &sis5595_base);
 	if (sis5595_base == 0 && force_addr == 0) {
 		dev_err(&SIS5595_dev->dev, "ACPI base address uninitialized - upgrade BIOS or use force_addr=0xaddr\n");
 		return -ENODEV;
 	}

 	if (force_addr)
 		sis5595_base = force_addr & ~(SIS5595_EXTENT - 1);
 	dev_dbg(&SIS5595_dev->dev, "ACPI Base address: %04x\n", sis5595_base);

 	/* NB: We grab just the two SMBus registers here, but this may still
 	 * interfere with ACPI :-(  */
 	retval = acpi_check_region(sis5595_base + SMB_INDEX, 2,
 				   sis5595_driver.name);
 	if (retval)
 		return retval;

 	if (!request_region(sis5595_base + SMB_INDEX, 2,
 			    sis5595_driver.name)) {
 		dev_err(&SIS5595_dev->dev, "SMBus registers 0x%04x-0x%04x already in use!\n",
 			sis5595_base + SMB_INDEX, sis5595_base + SMB_INDEX + 1);
 		return -ENODEV;
 	}

 	if (force_addr) {
 		dev_info(&SIS5595_dev->dev, "forcing ISA address 0x%04X\n", sis5595_base);
 		if (pci_write_config_word(SIS5595_dev, ACPI_BASE, sis5595_base)
 		    != PCIBIOS_SUCCESSFUL)
 			goto error;
 		if (pci_read_config_word(SIS5595_dev, ACPI_BASE, &a)
 		    != PCIBIOS_SUCCESSFUL)
 			goto error;
 		if ((a & ~(SIS5595_EXTENT - 1)) != sis5595_base) {
 			/* doesn't work for some chips! */
 			dev_err(&SIS5595_dev->dev, "force address failed - not supported?\n");
 			goto error;
 		}
 	}

 	if (pci_read_config_byte(SIS5595_dev, SIS5595_ENABLE_REG, &val)
 	    != PCIBIOS_SUCCESSFUL)
 		goto error;
 	if ((val & 0x80) == 0) {
 		dev_info(&SIS5595_dev->dev, "enabling ACPI\n");
 		if (pci_write_config_byte(SIS5595_dev, SIS5595_ENABLE_REG, val | 0x80)
 		    != PCIBIOS_SUCCESSFUL)
 			goto error;
 		if (pci_read_config_byte(SIS5595_dev, SIS5595_ENABLE_REG, &val)
 		    != PCIBIOS_SUCCESSFUL)
 			goto error;
 		if ((val & 0x80) == 0) {
 			/* doesn't work for some chips? */
 			dev_err(&SIS5595_dev->dev, "ACPI enable failed - not supported?\n");
 			goto error;
 		}
 	}

 	/* Everything is happy */
 	return 0;

 error:
 	release_region(sis5595_base + SMB_INDEX, 2);
 	return retval;
 }

 static int sis5595_transaction(struct i2c_adapter *adap)
 {
 	int temp;
 	int result = 0;
 	int timeout = 0;

 	/* Make sure the SMBus host is ready to start transmitting */
 	temp = sis5595_read(SMB_STS_LO) + (sis5595_read(SMB_STS_HI) << 8);
 	if (temp != 0x00) {
 		dev_dbg(&adap->dev, "SMBus busy (%04x). Resetting...\n", temp);
 		sis5595_write(SMB_STS_LO, temp & 0xff);
 		sis5595_write(SMB_STS_HI, temp >> 8);
 		if ((temp = sis5595_read(SMB_STS_LO) + (sis5595_read(SMB_STS_HI) << 8)) != 0x00) {
 			dev_dbg(&adap->dev, "Failed! (%02x)\n", temp);
 			return -EBUSY;
 		} else {
 			dev_dbg(&adap->dev, "Successful!\n");
 		}
 	}

 	/* start the transaction by setting bit 4 */
 	sis5595_write(SMB_CTL_LO, sis5595_read(SMB_CTL_LO) | 0x10);

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

 	/* If the SMBus is still busy, we give up */
 	if (timeout >= MAX_TIMEOUT) {
 		dev_dbg(&adap->dev, "SMBus Timeout!\n");
 		result = -ETIMEDOUT;
 	}

 	if (temp & 0x10) {
 		dev_dbg(&adap->dev, "Error: Failed bus transaction\n");
 		result = -ENXIO;
 	}

 	if (temp & 0x20) {
 		dev_err(&adap->dev, "Bus collision! SMBus may be locked until "
 			"next hard reset (or not...)\n");
 		/* Clock stops and slave is stuck in mid-transmission */
 		result = -EIO;
 	}

 	temp = sis5595_read(SMB_STS_LO) + (sis5595_read(SMB_STS_HI) << 8);
 	if (temp != 0x00) {
 		sis5595_write(SMB_STS_LO, temp & 0xff);
 		sis5595_write(SMB_STS_HI, temp >> 8);
 	}

 	temp = sis5595_read(SMB_STS_LO) + (sis5595_read(SMB_STS_HI) << 8);
 	if (temp != 0x00)
 		dev_dbg(&adap->dev, "Failed reset at end of transaction (%02x)\n", temp);

 	return result;
 }

 /* Return negative errno on error. */
 static s32 sis5595_access(struct i2c_adapter *adap, u16 addr,
 			  unsigned short flags, char read_write,
 			  u8 command, int size, union i2c_smbus_data *data)
 {
 	int status;

 	switch (size) {
 	case I2C_SMBUS_QUICK:
 		sis5595_write(SMB_ADDR, ((addr & 0x7f) << 1) | (read_write & 0x01));
 		size = SIS5595_QUICK;
 		break;
 	case I2C_SMBUS_BYTE:
 		sis5595_write(SMB_ADDR, ((addr & 0x7f) << 1) | (read_write & 0x01));
 		if (read_write == I2C_SMBUS_WRITE)
 			sis5595_write(SMB_CMD, command);
 		size = SIS5595_BYTE;
 		break;
 	case I2C_SMBUS_BYTE_DATA:
 		sis5595_write(SMB_ADDR, ((addr & 0x7f) << 1) | (read_write & 0x01));
 		sis5595_write(SMB_CMD, command);
 		if (read_write == I2C_SMBUS_WRITE)
 			sis5595_write(SMB_BYTE, data->byte);
 		size = SIS5595_BYTE_DATA;
 		break;
 	case I2C_SMBUS_PROC_CALL:
 	case I2C_SMBUS_WORD_DATA:
 		sis5595_write(SMB_ADDR, ((addr & 0x7f) << 1) | (read_write & 0x01));
 		sis5595_write(SMB_CMD, command);
 		if (read_write == I2C_SMBUS_WRITE) {
 			sis5595_write(SMB_BYTE, data->word & 0xff);
 			sis5595_write(SMB_BYTE + 1,
 				      (data->word & 0xff00) >> 8);
 		}
 		size = (size == I2C_SMBUS_PROC_CALL) ? SIS5595_PROC_CALL : SIS5595_WORD_DATA;
 		break;
 	default:
 		dev_warn(&adap->dev, "Unsupported transaction %d\n", size);
 		return -EOPNOTSUPP;
 	}

 	sis5595_write(SMB_CTL_LO, ((size & 0x0E)));

 	status = sis5595_transaction(adap);
 	if (status)
 		return status;

 	if ((size != SIS5595_PROC_CALL) &&
 	    ((read_write == I2C_SMBUS_WRITE) || (size == SIS5595_QUICK)))
 		return 0;


 	switch (size) {
 	case SIS5595_BYTE:
 	case SIS5595_BYTE_DATA:
 		data->byte = sis5595_read(SMB_BYTE);
 		break;
 	case SIS5595_WORD_DATA:
 	case SIS5595_PROC_CALL:
 		data->word = sis5595_read(SMB_BYTE) + (sis5595_read(SMB_BYTE + 1) << 8);
 		break;
 	}
 	return 0;
 }

 static u32 sis5595_func(struct i2c_adapter *adapter)
 {
 	return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
 	    I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
 	    I2C_FUNC_SMBUS_PROC_CALL;
 }

 static const struct i2c_algorithm smbus_algorithm = {
 	.smbus_xfer	= sis5595_access,
 	.functionality	= sis5595_func,
 };

 static struct i2c_adapter sis5595_adapter = {
 	.owner		= THIS_MODULE,
 	.id		= I2C_HW_SMBUS_SIS5595,
 	.class          = I2C_CLASS_HWMON | I2C_CLASS_SPD,
 	.algo		= &smbus_algorithm,
 };

 static struct pci_device_id sis5595_ids[] __devinitdata = {
 	{ PCI_DEVICE(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_503) },
 	{ 0, }
 };

 MODULE_DEVICE_TABLE (pci, sis5595_ids);

 static int __devinit sis5595_probe(struct pci_dev *dev, const struct pci_device_id *id)
 {
 	int err;

 	if (sis5595_setup(dev)) {
 		dev_err(&dev->dev, "SIS5595 not detected, module not inserted.\n");
 		return -ENODEV;
 	}

 	/* set up the sysfs linkage to our parent device */
 	sis5595_adapter.dev.parent = &dev->dev;

 	snprintf(sis5595_adapter.name, sizeof(sis5595_adapter.name),
 		 "SMBus SIS5595 adapter at %04x", sis5595_base + SMB_INDEX);
 	err = i2c_add_adapter(&sis5595_adapter);
 	if (err) {
 		release_region(sis5595_base + SMB_INDEX, 2);
 		return err;
 	}

 	/* 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.
 	 */
 	sis5595_pdev =  pci_dev_get(dev);
 	return -ENODEV;
 }

 static struct pci_driver sis5595_driver = {
 	.name		= "sis5595_smbus",
 	.id_table	= sis5595_ids,
 	.probe		= sis5595_probe,
 };

 static int __init i2c_sis5595_init(void)
 {
 	return pci_register_driver(&sis5595_driver);
 }

 static void __exit i2c_sis5595_exit(void)
 {
 	pci_unregister_driver(&sis5595_driver);
 	if (sis5595_pdev) {
 		i2c_del_adapter(&sis5595_adapter);
 		release_region(sis5595_base + SMB_INDEX, 2);
 		pci_dev_put(sis5595_pdev);
 		sis5595_pdev = NULL;
 	}
 }

 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
 MODULE_DESCRIPTION("SIS5595 SMBus driver");
 MODULE_LICENSE("GPL");

 module_init(i2c_sis5595_init);
 module_exit(i2c_sis5595_exit);
	/*
	Copyright (c) 1998, 1999 Frodo Looijaard <frodol@dds.nl> and
	Philip Edelbrock <phil@netroedge.com>

	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.
	*/

	/* Note: we assume there can only be one SIS5595 with one SMBus interface */

	/*
	Note: all have mfr. ID 0x1039.
	SUPPORTED PCI ID
	5595 0008

	Note: these chips contain a 0008 device which is incompatible with the
	5595. We recognize these by the presence of the listed
	"blacklist" PCI ID and refuse to load.

	NOT SUPPORTED PCI ID BLACKLIST PCI ID
	540 0008 0540
	550 0008 0550
	5513 0008 5511
	5581 0008 5597
	5582 0008 5597
	5597 0008 5597
	5598 0008 5597/5598
	630 0008 0630
	645 0008 0645
	646 0008 0646
	648 0008 0648
	650 0008 0650
	651 0008 0651
	730 0008 0730
	735 0008 0735
	745 0008 0745
	746 0008 0746
	*/

	/* TO DO:
	* Add Block Transfers (ugly, but supported by the adapter)
	* Add adapter resets
	*/

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

	static int blacklist[] = {
	PCI_DEVICE_ID_SI_540,
	PCI_DEVICE_ID_SI_550,
	PCI_DEVICE_ID_SI_630,
	PCI_DEVICE_ID_SI_645,
	PCI_DEVICE_ID_SI_646,
	PCI_DEVICE_ID_SI_648,
	PCI_DEVICE_ID_SI_650,
	PCI_DEVICE_ID_SI_651,
	PCI_DEVICE_ID_SI_730,
	PCI_DEVICE_ID_SI_735,
	PCI_DEVICE_ID_SI_745,
	PCI_DEVICE_ID_SI_746,
	PCI_DEVICE_ID_SI_5511, /* 5513 chip has the 0008 device but that ID
	shows up in other chips so we use the 5511
	ID for recognition */
	PCI_DEVICE_ID_SI_5597,
	PCI_DEVICE_ID_SI_5598,
	0, /* terminates the list */
	};

	/* Length of ISA address segment */
	#define SIS5595_EXTENT 8
	/* SIS5595 SMBus registers */
	#define SMB_STS_LO 0x00
	#define SMB_STS_HI 0x01
	#define SMB_CTL_LO 0x02
	#define SMB_CTL_HI 0x03
	#define SMB_ADDR 0x04
	#define SMB_CMD 0x05
	#define SMB_PCNT 0x06
	#define SMB_CNT 0x07
	#define SMB_BYTE 0x08
	#define SMB_DEV 0x10
	#define SMB_DB0 0x11
	#define SMB_DB1 0x12
	#define SMB_HAA 0x13

	/* PCI Address Constants */
	#define SMB_INDEX 0x38
	#define SMB_DAT 0x39
	#define SIS5595_ENABLE_REG 0x40
	#define ACPI_BASE 0x90

	/* Other settings */
	#define MAX_TIMEOUT 500

	/* SIS5595 constants */
	#define SIS5595_QUICK 0x00
	#define SIS5595_BYTE 0x02
	#define SIS5595_BYTE_DATA 0x04
	#define SIS5595_WORD_DATA 0x06
	#define SIS5595_PROC_CALL 0x08
	#define SIS5595_BLOCK_DATA 0x0A

	/* insmod parameters */

	/* If force_addr is set to anything different from 0, we forcibly enable
	the device at the given address. */
	static u16 force_addr;
	module_param(force_addr, ushort, 0);
	MODULE_PARM_DESC(force_addr, "Initialize the base address of the i2c controller");

	static struct pci_driver sis5595_driver;
	static unsigned short sis5595_base;
	static struct pci_dev *sis5595_pdev;

	static u8 sis5595_read(u8 reg)
	{
	outb(reg, sis5595_base + SMB_INDEX);
	return inb(sis5595_base + SMB_DAT);
	}

	static void sis5595_write(u8 reg, u8 data)
	{
	outb(reg, sis5595_base + SMB_INDEX);
	outb(data, sis5595_base + SMB_DAT);
	}

	static int sis5595_setup(struct pci_dev *SIS5595_dev)
	{
	u16 a;
	u8 val;
	int *i;
	int retval = -ENODEV;

	/* Look for imposters */
	for (i = blacklist; *i != 0; i++) {
	struct pci_dev *dev;
	dev = pci_get_device(PCI_VENDOR_ID_SI, *i, NULL);
	if (dev) {
	dev_err(&SIS5595_dev->dev, "Looked for SIS5595 but found unsupported device %.4x\n", *i);
	pci_dev_put(dev);
	return -ENODEV;
	}
	}

	/* Determine the address of the SMBus areas */
	pci_read_config_word(SIS5595_dev, ACPI_BASE, &sis5595_base);
	if (sis5595_base == 0 && force_addr == 0) {
	dev_err(&SIS5595_dev->dev, "ACPI base address uninitialized - upgrade BIOS or use force_addr=0xaddr\n");
	return -ENODEV;
	}

	if (force_addr)
	sis5595_base = force_addr & ~(SIS5595_EXTENT - 1);
	dev_dbg(&SIS5595_dev->dev, "ACPI Base address: %04x\n", sis5595_base);

	/* NB: We grab just the two SMBus registers here, but this may still
	* interfere with ACPI :-( */
	retval = acpi_check_region(sis5595_base + SMB_INDEX, 2,
	sis5595_driver.name);
	if (retval)
	return retval;

	if (!request_region(sis5595_base + SMB_INDEX, 2,
	sis5595_driver.name)) {
	dev_err(&SIS5595_dev->dev, "SMBus registers 0x%04x-0x%04x already in use!\n",
	sis5595_base + SMB_INDEX, sis5595_base + SMB_INDEX + 1);
	return -ENODEV;
	}

	if (force_addr) {
	dev_info(&SIS5595_dev->dev, "forcing ISA address 0x%04X\n", sis5595_base);
	if (pci_write_config_word(SIS5595_dev, ACPI_BASE, sis5595_base)
	!= PCIBIOS_SUCCESSFUL)
	goto error;
	if (pci_read_config_word(SIS5595_dev, ACPI_BASE, &a)
	!= PCIBIOS_SUCCESSFUL)
	goto error;
	if ((a & ~(SIS5595_EXTENT - 1)) != sis5595_base) {
	/* doesn't work for some chips! */
	dev_err(&SIS5595_dev->dev, "force address failed - not supported?\n");
	goto error;
	}
	}

	if (pci_read_config_byte(SIS5595_dev, SIS5595_ENABLE_REG, &val)
	!= PCIBIOS_SUCCESSFUL)
	goto error;
	if ((val & 0x80) == 0) {
	dev_info(&SIS5595_dev->dev, "enabling ACPI\n");
	if (pci_write_config_byte(SIS5595_dev, SIS5595_ENABLE_REG, val \| 0x80)
	!= PCIBIOS_SUCCESSFUL)
	goto error;
	if (pci_read_config_byte(SIS5595_dev, SIS5595_ENABLE_REG, &val)
	!= PCIBIOS_SUCCESSFUL)
	goto error;
	if ((val & 0x80) == 0) {
	/* doesn't work for some chips? */
	dev_err(&SIS5595_dev->dev, "ACPI enable failed - not supported?\n");
	goto error;
	}
	}

	/* Everything is happy */
	return 0;

	error:
	release_region(sis5595_base + SMB_INDEX, 2);
	return retval;
	}

	static int sis5595_transaction(struct i2c_adapter *adap)
	{
	int temp;
	int result = 0;
	int timeout = 0;

	/* Make sure the SMBus host is ready to start transmitting */
	temp = sis5595_read(SMB_STS_LO) + (sis5595_read(SMB_STS_HI) << 8);
	if (temp != 0x00) {
	dev_dbg(&adap->dev, "SMBus busy (%04x). Resetting...\n", temp);
	sis5595_write(SMB_STS_LO, temp & 0xff);
	sis5595_write(SMB_STS_HI, temp >> 8);
	if ((temp = sis5595_read(SMB_STS_LO) + (sis5595_read(SMB_STS_HI) << 8)) != 0x00) {
	dev_dbg(&adap->dev, "Failed! (%02x)\n", temp);
	return -EBUSY;
	} else {
	dev_dbg(&adap->dev, "Successful!\n");
	}
	}

	/* start the transaction by setting bit 4 */
	sis5595_write(SMB_CTL_LO, sis5595_read(SMB_CTL_LO) \| 0x10);

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

	/* If the SMBus is still busy, we give up */
	if (timeout >= MAX_TIMEOUT) {
	dev_dbg(&adap->dev, "SMBus Timeout!\n");
	result = -ETIMEDOUT;
	}

	if (temp & 0x10) {
	dev_dbg(&adap->dev, "Error: Failed bus transaction\n");
	result = -ENXIO;
	}

	if (temp & 0x20) {
	dev_err(&adap->dev, "Bus collision! SMBus may be locked until "
	"next hard reset (or not...)\n");
	/* Clock stops and slave is stuck in mid-transmission */
	result = -EIO;
	}

	temp = sis5595_read(SMB_STS_LO) + (sis5595_read(SMB_STS_HI) << 8);
	if (temp != 0x00) {
	sis5595_write(SMB_STS_LO, temp & 0xff);
	sis5595_write(SMB_STS_HI, temp >> 8);
	}

	temp = sis5595_read(SMB_STS_LO) + (sis5595_read(SMB_STS_HI) << 8);
	if (temp != 0x00)
	dev_dbg(&adap->dev, "Failed reset at end of transaction (%02x)\n", temp);

	return result;
	}

	/* Return negative errno on error. */
	static s32 sis5595_access(struct i2c_adapter *adap, u16 addr,
	unsigned short flags, char read_write,
	u8 command, int size, union i2c_smbus_data *data)
	{
	int status;

	switch (size) {
	case I2C_SMBUS_QUICK:
	sis5595_write(SMB_ADDR, ((addr & 0x7f) << 1) \| (read_write & 0x01));
	size = SIS5595_QUICK;
	break;
	case I2C_SMBUS_BYTE:
	sis5595_write(SMB_ADDR, ((addr & 0x7f) << 1) \| (read_write & 0x01));
	if (read_write == I2C_SMBUS_WRITE)
	sis5595_write(SMB_CMD, command);
	size = SIS5595_BYTE;
	break;
	case I2C_SMBUS_BYTE_DATA:
	sis5595_write(SMB_ADDR, ((addr & 0x7f) << 1) \| (read_write & 0x01));
	sis5595_write(SMB_CMD, command);
	if (read_write == I2C_SMBUS_WRITE)
	sis5595_write(SMB_BYTE, data->byte);
	size = SIS5595_BYTE_DATA;
	break;
	case I2C_SMBUS_PROC_CALL:
	case I2C_SMBUS_WORD_DATA:
	sis5595_write(SMB_ADDR, ((addr & 0x7f) << 1) \| (read_write & 0x01));
	sis5595_write(SMB_CMD, command);
	if (read_write == I2C_SMBUS_WRITE) {
	sis5595_write(SMB_BYTE, data->word & 0xff);
	sis5595_write(SMB_BYTE + 1,
	(data->word & 0xff00) >> 8);
	}
	size = (size == I2C_SMBUS_PROC_CALL) ? SIS5595_PROC_CALL : SIS5595_WORD_DATA;
	break;
	default:
	dev_warn(&adap->dev, "Unsupported transaction %d\n", size);
	return -EOPNOTSUPP;
	}

	sis5595_write(SMB_CTL_LO, ((size & 0x0E)));

	status = sis5595_transaction(adap);
	if (status)
	return status;

	if ((size != SIS5595_PROC_CALL) &&
	((read_write == I2C_SMBUS_WRITE) \|\| (size == SIS5595_QUICK)))
	return 0;


	switch (size) {
	case SIS5595_BYTE:
	case SIS5595_BYTE_DATA:
	data->byte = sis5595_read(SMB_BYTE);
	break;
	case SIS5595_WORD_DATA:
	case SIS5595_PROC_CALL:
	data->word = sis5595_read(SMB_BYTE) + (sis5595_read(SMB_BYTE + 1) << 8);
	break;
	}
	return 0;
	}

	static u32 sis5595_func(struct i2c_adapter *adapter)
	{
	return I2C_FUNC_SMBUS_QUICK \| I2C_FUNC_SMBUS_BYTE \|
	I2C_FUNC_SMBUS_BYTE_DATA \| I2C_FUNC_SMBUS_WORD_DATA \|
	I2C_FUNC_SMBUS_PROC_CALL;
	}

	static const struct i2c_algorithm smbus_algorithm = {
	.smbus_xfer = sis5595_access,
	.functionality = sis5595_func,
	};

	static struct i2c_adapter sis5595_adapter = {
	.owner = THIS_MODULE,
	.id = I2C_HW_SMBUS_SIS5595,
	.class = I2C_CLASS_HWMON \| I2C_CLASS_SPD,
	.algo = &smbus_algorithm,
	};

	static struct pci_device_id sis5595_ids[] __devinitdata = {
	{ PCI_DEVICE(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_503) },
	{ 0, }
	};

	MODULE_DEVICE_TABLE (pci, sis5595_ids);

	static int __devinit sis5595_probe(struct pci_dev dev, const struct pci_device_id id)
	{
	int err;

	if (sis5595_setup(dev)) {
	dev_err(&dev->dev, "SIS5595 not detected, module not inserted.\n");
	return -ENODEV;
	}

	/* set up the sysfs linkage to our parent device */
	sis5595_adapter.dev.parent = &dev->dev;

	snprintf(sis5595_adapter.name, sizeof(sis5595_adapter.name),
	"SMBus SIS5595 adapter at %04x", sis5595_base + SMB_INDEX);
	err = i2c_add_adapter(&sis5595_adapter);
	if (err) {
	release_region(sis5595_base + SMB_INDEX, 2);
	return err;
	}

	/* 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.
	*/
	sis5595_pdev = pci_dev_get(dev);
	return -ENODEV;
	}

	static struct pci_driver sis5595_driver = {
	.name = "sis5595_smbus",
	.id_table = sis5595_ids,
	.probe = sis5595_probe,
	};

	static int __init i2c_sis5595_init(void)
	{
	return pci_register_driver(&sis5595_driver);
	}

	static void __exit i2c_sis5595_exit(void)
	{
	pci_unregister_driver(&sis5595_driver);
	if (sis5595_pdev) {
	i2c_del_adapter(&sis5595_adapter);
	release_region(sis5595_base + SMB_INDEX, 2);
	pci_dev_put(sis5595_pdev);
	sis5595_pdev = NULL;
	}
	}

	MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
	MODULE_DESCRIPTION("SIS5595 SMBus driver");
	MODULE_LICENSE("GPL");

	module_init(i2c_sis5595_init);
	module_exit(i2c_sis5595_exit);