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

/*  linux/drivers/i2c/scx200_acb.c 

    Copyright (c) 2001,2002 Christer Weinigel <wingel@nano-system.com>

    National Semiconductor SCx200 ACCESS.bus support
    
    Based on i2c-keywest.c which is:
        Copyright (c) 2001 Benjamin Herrenschmidt <benh@kernel.crashing.org>
        Copyright (c) 2000 Philip Edelbrock <phil@stimpy.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.

*/

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

#include <linux/scx200.h>

#define NAME "scx200_acb"

MODULE_AUTHOR("Christer Weinigel <wingel@nano-system.com>");
MODULE_DESCRIPTION("NatSemi SCx200 ACCESS.bus Driver");
MODULE_LICENSE("GPL");

#define MAX_DEVICES 4
static int base[MAX_DEVICES] = { 0x820, 0x840 };
module_param_array(base, int, NULL, 0);
MODULE_PARM_DESC(base, "Base addresses for the ACCESS.bus controllers");

#ifdef DEBUG
#define DBG(x...) printk(KERN_DEBUG NAME ": " x)
#else
#define DBG(x...)
#endif

/* The hardware supports interrupt driven mode too, but I haven't
   implemented that. */
#define POLLED_MODE 1
#define POLL_TIMEOUT (HZ)

enum scx200_acb_state {
	state_idle,
	state_address,
	state_command,
	state_repeat_start,
	state_quick,
	state_read,
	state_write,
};

static const char *scx200_acb_state_name[] = {
	"idle",
	"address",
	"command",
	"repeat_start",
	"quick",
	"read",
	"write",
};

/* Physical interface */
struct scx200_acb_iface
{
	struct scx200_acb_iface *next;
	struct i2c_adapter adapter;
	unsigned base;
	struct semaphore sem;

	/* State machine data */
	enum scx200_acb_state state;
	int result;
	u8 address_byte;
	u8 command;
	u8 *ptr;
	char needs_reset;
	unsigned len;
};

/* Register Definitions */
#define ACBSDA		(iface->base + 0)
#define ACBST		(iface->base + 1)
#define    ACBST_SDAST		0x40 /* SDA Status */
#define    ACBST_BER		0x20 
#define    ACBST_NEGACK		0x10 /* Negative Acknowledge */
#define    ACBST_STASTR		0x08 /* Stall After Start */
#define    ACBST_MASTER		0x02
#define ACBCST		(iface->base + 2)
#define    ACBCST_BB		0x02
#define ACBCTL1		(iface->base + 3)
#define    ACBCTL1_STASTRE	0x80
#define    ACBCTL1_NMINTE	0x40
#define	   ACBCTL1_ACK		0x10
#define	   ACBCTL1_STOP		0x02
#define	   ACBCTL1_START	0x01
#define ACBADDR		(iface->base + 4)
#define ACBCTL2		(iface->base + 5)
#define    ACBCTL2_ENABLE	0x01

/************************************************************************/

static void scx200_acb_machine(struct scx200_acb_iface *iface, u8 status)
{
	const char *errmsg;

	DBG("state %s, status = 0x%02x\n", 
	    scx200_acb_state_name[iface->state], status);

	if (status & ACBST_BER) {
		errmsg = "bus error";
		goto error;
	}
	if (!(status & ACBST_MASTER)) {
		errmsg = "not master";
		goto error;
	}
	if (status & ACBST_NEGACK)
		goto negack;

	switch (iface->state) {
	case state_idle:
		dev_warn(&iface->adapter.dev, "interrupt in idle state\n");
		break;

	case state_address:
		/* Do a pointer write first */
		outb(iface->address_byte & ~1, ACBSDA);

		iface->state = state_command;
		break;

	case state_command:
		outb(iface->command, ACBSDA);

		if (iface->address_byte & 1)
			iface->state = state_repeat_start;
		else
			iface->state = state_write;
		break;

	case state_repeat_start:
		outb(inb(ACBCTL1) | ACBCTL1_START, ACBCTL1);
		/* fallthrough */
		
	case state_quick:
		if (iface->address_byte & 1) {
			if (iface->len == 1) 
				outb(inb(ACBCTL1) | ACBCTL1_ACK, ACBCTL1);
			else
				outb(inb(ACBCTL1) & ~ACBCTL1_ACK, ACBCTL1);
			outb(iface->address_byte, ACBSDA);

			iface->state = state_read;
		} else {
			outb(iface->address_byte, ACBSDA);

			iface->state = state_write;
		}
		break;

	case state_read:
		/* Set ACK if receiving the last byte */
		if (iface->len == 1)
			outb(inb(ACBCTL1) | ACBCTL1_ACK, ACBCTL1);
		else
			outb(inb(ACBCTL1) & ~ACBCTL1_ACK, ACBCTL1);

		*iface->ptr++ = inb(ACBSDA);
		--iface->len;

		if (iface->len == 0) {
			iface->result = 0;
			iface->state = state_idle;
			outb(inb(ACBCTL1) | ACBCTL1_STOP, ACBCTL1);
		}

		break;

	case state_write:
		if (iface->len == 0) {
			iface->result = 0;
			iface->state = state_idle;
			outb(inb(ACBCTL1) | ACBCTL1_STOP, ACBCTL1);
			break;
		}
		
		outb(*iface->ptr++, ACBSDA);
		--iface->len;
		
		break;
	}

	return;

 negack:
	DBG("negative acknowledge in state %s\n", 
	    scx200_acb_state_name[iface->state]);

	iface->state = state_idle;
	iface->result = -ENXIO;

	outb(inb(ACBCTL1) | ACBCTL1_STOP, ACBCTL1);
	outb(ACBST_STASTR | ACBST_NEGACK, ACBST);
	return;

 error:
	dev_err(&iface->adapter.dev, "%s in state %s\n", errmsg,
		scx200_acb_state_name[iface->state]);

	iface->state = state_idle;
	iface->result = -EIO;
	iface->needs_reset = 1;
}

static void scx200_acb_timeout(struct scx200_acb_iface *iface) 
{
	dev_err(&iface->adapter.dev, "timeout in state %s\n",
		scx200_acb_state_name[iface->state]);

	iface->state = state_idle;
	iface->result = -EIO;
	iface->needs_reset = 1;
}

#ifdef POLLED_MODE
static void scx200_acb_poll(struct scx200_acb_iface *iface)
{
	u8 status = 0;
	unsigned long timeout;

	timeout = jiffies + POLL_TIMEOUT;
	while (time_before(jiffies, timeout)) {
		status = inb(ACBST);
		if ((status & (ACBST_SDAST|ACBST_BER|ACBST_NEGACK)) != 0) {
			scx200_acb_machine(iface, status);
			return;
		}
		msleep(10);
	}

	scx200_acb_timeout(iface);
}
#endif /* POLLED_MODE */

static void scx200_acb_reset(struct scx200_acb_iface *iface)
{
	/* Disable the ACCESS.bus device and Configure the SCL
           frequency: 16 clock cycles */
	outb(0x70, ACBCTL2);
	/* Polling mode */
	outb(0, ACBCTL1);
	/* Disable slave address */
	outb(0, ACBADDR);
	/* Enable the ACCESS.bus device */
	outb(inb(ACBCTL2) | ACBCTL2_ENABLE, ACBCTL2);
	/* Free STALL after START */
	outb(inb(ACBCTL1) & ~(ACBCTL1_STASTRE | ACBCTL1_NMINTE), ACBCTL1);
	/* Send a STOP */
	outb(inb(ACBCTL1) | ACBCTL1_STOP, ACBCTL1);
	/* Clear BER, NEGACK and STASTR bits */
	outb(ACBST_BER | ACBST_NEGACK | ACBST_STASTR, ACBST);
	/* Clear BB bit */
	outb(inb(ACBCST) | ACBCST_BB, ACBCST);
}

static s32 scx200_acb_smbus_xfer(struct i2c_adapter *adapter,
				u16 address, unsigned short flags,	
				char rw, u8 command, int size, 
				union i2c_smbus_data *data)
{
	struct scx200_acb_iface *iface = i2c_get_adapdata(adapter);
	int len;
	u8 *buffer;
	u16 cur_word;
	int rc;

	switch (size) {
	case I2C_SMBUS_QUICK:
	    	len = 0;
	    	buffer = NULL;
	    	break;
	case I2C_SMBUS_BYTE:
		if (rw == I2C_SMBUS_READ) {
			len = 1;
			buffer = &data->byte;
		} else {
			len = 1;
			buffer = &command;
		}
	    	break;
	case I2C_SMBUS_BYTE_DATA:
	    	len = 1;
	    	buffer = &data->byte;
	    	break;
	case I2C_SMBUS_WORD_DATA:
		len = 2;
	    	cur_word = cpu_to_le16(data->word);
	    	buffer = (u8 *)&cur_word;
		break;
	case I2C_SMBUS_BLOCK_DATA:
	    	len = data->block[0];
	    	buffer = &data->block[1];
		break;
	default:
	    	return -EINVAL;
	}

	DBG("size=%d, address=0x%x, command=0x%x, len=%d, read=%d\n",
	    size, address, command, len, rw == I2C_SMBUS_READ);

	if (!len && rw == I2C_SMBUS_READ) {
		dev_warn(&adapter->dev, "zero length read\n");
		return -EINVAL;
	}

	if (len && !buffer) {
		dev_warn(&adapter->dev, "nonzero length but no buffer\n");
		return -EFAULT;
	}

	down(&iface->sem);

	iface->address_byte = address<<1;
	if (rw == I2C_SMBUS_READ)
		iface->address_byte |= 1;
	iface->command = command;
	iface->ptr = buffer;
	iface->len = len;
	iface->result = -EINVAL;
	iface->needs_reset = 0;

	outb(inb(ACBCTL1) | ACBCTL1_START, ACBCTL1);

	if (size == I2C_SMBUS_QUICK || size == I2C_SMBUS_BYTE)
		iface->state = state_quick;
	else
		iface->state = state_address;

#ifdef POLLED_MODE
	while (iface->state != state_idle)
		scx200_acb_poll(iface);
#else /* POLLED_MODE */
#error Interrupt driven mode not implemented
#endif /* POLLED_MODE */	

	if (iface->needs_reset)
		scx200_acb_reset(iface);

	rc = iface->result;

	up(&iface->sem);

	if (rc == 0 && size == I2C_SMBUS_WORD_DATA && rw == I2C_SMBUS_READ)
	    	data->word = le16_to_cpu(cur_word);

#ifdef DEBUG
	DBG(": transfer done, result: %d", rc);
	if (buffer) {
		int i;
		printk(" data:");
		for (i = 0; i < len; ++i)
			printk(" %02x", buffer[i]);
	}
	printk("\n");
#endif

	return rc;
}

static u32 scx200_acb_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_BLOCK_DATA;
}

/* For now, we only handle combined mode (smbus) */
static struct i2c_algorithm scx200_acb_algorithm = {
	.smbus_xfer	= scx200_acb_smbus_xfer,
	.functionality	= scx200_acb_func,
};

static struct scx200_acb_iface *scx200_acb_list;

static int scx200_acb_probe(struct scx200_acb_iface *iface)
{
	u8 val;

	/* Disable the ACCESS.bus device and Configure the SCL
           frequency: 16 clock cycles */
	outb(0x70, ACBCTL2);

	if (inb(ACBCTL2) != 0x70) {
		DBG("ACBCTL2 readback failed\n");
		return -ENXIO;
	}

	outb(inb(ACBCTL1) | ACBCTL1_NMINTE, ACBCTL1);

	val = inb(ACBCTL1);
	if (val) {
		DBG("disabled, but ACBCTL1=0x%02x\n", val);
		return -ENXIO;
	}

	outb(inb(ACBCTL2) | ACBCTL2_ENABLE, ACBCTL2);

	outb(inb(ACBCTL1) | ACBCTL1_NMINTE, ACBCTL1);

	val = inb(ACBCTL1);
	if ((val & ACBCTL1_NMINTE) != ACBCTL1_NMINTE) {
		DBG("enabled, but NMINTE won't be set, ACBCTL1=0x%02x\n", val);
		return -ENXIO;
	}

	return 0;
}

static int  __init scx200_acb_create(int base, int index)
{
	struct scx200_acb_iface *iface;
	struct i2c_adapter *adapter;
	int rc = 0;
	char description[64];

	iface = kmalloc(sizeof(*iface), GFP_KERNEL);
	if (!iface) {
		printk(KERN_ERR NAME ": can't allocate memory\n");
		rc = -ENOMEM;
		goto errout;
	}

	memset(iface, 0, sizeof(*iface));
	adapter = &iface->adapter;
	i2c_set_adapdata(adapter, iface);
	snprintf(adapter->name, I2C_NAME_SIZE, "SCx200 ACB%d", index);
	adapter->owner = THIS_MODULE;
	adapter->id = I2C_HW_SMBUS_SCX200;
	adapter->algo = &scx200_acb_algorithm;
	adapter->class = I2C_CLASS_HWMON;

	init_MUTEX(&iface->sem);

	snprintf(description, sizeof(description), "NatSemi SCx200 ACCESS.bus [%s]", adapter->name);
	if (request_region(base, 8, description) == 0) {
		dev_err(&adapter->dev, "can't allocate io 0x%x-0x%x\n",
			base, base + 8-1);
		rc = -EBUSY;
		goto errout;
	}
	iface->base = base;

	rc = scx200_acb_probe(iface);
	if (rc) {
		dev_warn(&adapter->dev, "probe failed\n");
		goto errout;
	}

	scx200_acb_reset(iface);

	if (i2c_add_adapter(adapter) < 0) {
		dev_err(&adapter->dev, "failed to register\n");
		rc = -ENODEV;
		goto errout;
	}

	lock_kernel();
	iface->next = scx200_acb_list;
	scx200_acb_list = iface;
	unlock_kernel();

	return 0;

 errout:
	if (iface) {
		if (iface->base)
			release_region(iface->base, 8);
		kfree(iface);
	}
	return rc;
}

static struct pci_device_id scx200[] = {
	{ PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_SCx200_BRIDGE) },
	{ PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_SC1100_BRIDGE) },
	{ },
};

static int __init scx200_acb_init(void)
{
	int i;
	int rc;

	pr_debug(NAME ": NatSemi SCx200 ACCESS.bus Driver\n");

	/* Verify that this really is a SCx200 processor */
	if (pci_dev_present(scx200) == 0)
		return -ENODEV;

	rc = -ENXIO;
	for (i = 0; i < MAX_DEVICES; ++i) {
		if (base[i] > 0)
			rc = scx200_acb_create(base[i], i);
	}
	if (scx200_acb_list)
		return 0;
	return rc;
}

static void __exit scx200_acb_cleanup(void)
{
	struct scx200_acb_iface *iface;
	lock_kernel();
	while ((iface = scx200_acb_list) != NULL) {
		scx200_acb_list = iface->next;
		unlock_kernel();

		i2c_del_adapter(&iface->adapter);
		release_region(iface->base, 8);
		kfree(iface);
		lock_kernel();
	}
	unlock_kernel();
}

module_init(scx200_acb_init);
module_exit(scx200_acb_cleanup);

/*
    Local variables:
        compile-command: "make -k -C ../.. SUBDIRS=drivers/i2c modules"
        c-basic-offset: 8
    End:
*/
Commit	Line	Data
1da177e4 LT	1	/* linux/drivers/i2c/scx200_acb.c
	2
	3	Copyright (c) 2001,2002 Christer Weinigel <wingel@nano-system.com>
	4
	5	National Semiconductor SCx200 ACCESS.bus support
	6
	7	Based on i2c-keywest.c which is:
	8	Copyright (c) 2001 Benjamin Herrenschmidt <benh@kernel.crashing.org>
	9	Copyright (c) 2000 Philip Edelbrock <phil@stimpy.netroedge.com>
	10
	11	This program is free software; you can redistribute it and/or
	12	modify it under the terms of the GNU General Public License as
	13	published by the Free Software Foundation; either version 2 of the
	14	License, or (at your option) any later version.
	15
	16	This program is distributed in the hope that it will be useful,
	17	but WITHOUT ANY WARRANTY; without even the implied warranty of
	18	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	19	General Public License for more details.
	20
	21	You should have received a copy of the GNU General Public License
	22	along with this program; if not, write to the Free Software
	23	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	24
	25	*/
	26
1da177e4 LT	27	#include <linux/module.h>
	28	#include <linux/errno.h>
	29	#include <linux/kernel.h>
	30	#include <linux/init.h>
	31	#include <linux/i2c.h>
	32	#include <linux/smp_lock.h>
	33	#include <linux/pci.h>
	34	#include <linux/delay.h>
	35	#include <asm/io.h>
	36
	37	#include <linux/scx200.h>
	38
	39	#define NAME "scx200_acb"
	40
	41	MODULE_AUTHOR("Christer Weinigel <wingel@nano-system.com>");
	42	MODULE_DESCRIPTION("NatSemi SCx200 ACCESS.bus Driver");
	43	MODULE_LICENSE("GPL");
	44
	45	#define MAX_DEVICES 4
	46	static int base[MAX_DEVICES] = { 0x820, 0x840 };
	47	module_param_array(base, int, NULL, 0);
	48	MODULE_PARM_DESC(base, "Base addresses for the ACCESS.bus controllers");
	49
	50	#ifdef DEBUG
	51	#define DBG(x...) printk(KERN_DEBUG NAME ": " x)
	52	#else
	53	#define DBG(x...)
	54	#endif
	55
	56	/* The hardware supports interrupt driven mode too, but I haven't
	57	implemented that. */
	58	#define POLLED_MODE 1
	59	#define POLL_TIMEOUT (HZ)
	60
	61	enum scx200_acb_state {
	62	state_idle,
	63	state_address,
	64	state_command,
	65	state_repeat_start,
	66	state_quick,
	67	state_read,
	68	state_write,
	69	};
	70
	71	static const char *scx200_acb_state_name[] = {
	72	"idle",
	73	"address",
	74	"command",
	75	"repeat_start",
	76	"quick",
	77	"read",
	78	"write",
	79	};
	80
	81	/* Physical interface */
	82	struct scx200_acb_iface
	83	{
	84	struct scx200_acb_iface *next;
	85	struct i2c_adapter adapter;
	86	unsigned base;
	87	struct semaphore sem;
	88
	89	/* State machine data */
	90	enum scx200_acb_state state;
91	int result;
92	u8 address_byte;
93	u8 command;
94	u8 *ptr;
95	char needs_reset;
96	unsigned len;
97	};
98
99	/* Register Definitions */
100	#define ACBSDA (iface->base + 0)
101	#define ACBST (iface->base + 1)
102	#define ACBST_SDAST 0x40 /* SDA Status */
103	#define ACBST_BER 0x20
104	#define ACBST_NEGACK 0x10 /* Negative Acknowledge */
105	#define ACBST_STASTR 0x08 /* Stall After Start */
106	#define ACBST_MASTER 0x02
107	#define ACBCST (iface->base + 2)
108	#define ACBCST_BB 0x02
109	#define ACBCTL1 (iface->base + 3)
110	#define ACBCTL1_STASTRE 0x80
111	#define ACBCTL1_NMINTE 0x40
112	#define ACBCTL1_ACK 0x10
113	#define ACBCTL1_STOP 0x02
114	#define ACBCTL1_START 0x01
115	#define ACBADDR (iface->base + 4)
116	#define ACBCTL2 (iface->base + 5)
117	#define ACBCTL2_ENABLE 0x01
118
119	/************************************************************************/
120
121	static void scx200_acb_machine(struct scx200_acb_iface *iface, u8 status)
122	{
123	const char *errmsg;
124
125	DBG("state %s, status = 0x%02x\n",
126	scx200_acb_state_name[iface->state], status);
127
128	if (status & ACBST_BER) {
129	errmsg = "bus error";
130	goto error;
131	}
132	if (!(status & ACBST_MASTER)) {
133	errmsg = "not master";
134	goto error;
135	}
136	if (status & ACBST_NEGACK)
137	goto negack;
138
139	switch (iface->state) {
140	case state_idle:
141	dev_warn(&iface->adapter.dev, "interrupt in idle state\n");
142	break;
143
144	case state_address:
145	/* Do a pointer write first */
146	outb(iface->address_byte & ~1, ACBSDA);
147
148	iface->state = state_command;
149	break;
150
151	case state_command:
152	outb(iface->command, ACBSDA);
153
154	if (iface->address_byte & 1)
155	iface->state = state_repeat_start;
156	else
157	iface->state = state_write;
158	break;
159
160	case state_repeat_start:
161	outb(inb(ACBCTL1) \| ACBCTL1_START, ACBCTL1);
162	/* fallthrough */
163
164	case state_quick:
165	if (iface->address_byte & 1) {
166	if (iface->len == 1)
167	outb(inb(ACBCTL1) \| ACBCTL1_ACK, ACBCTL1);
168	else
169	outb(inb(ACBCTL1) & ~ACBCTL1_ACK, ACBCTL1);
170	outb(iface->address_byte, ACBSDA);
171
172	iface->state = state_read;
173	} else {
174	outb(iface->address_byte, ACBSDA);
175
176	iface->state = state_write;
177	}
178	break;
179
180	case state_read:
181	/* Set ACK if receiving the last byte */
182	if (iface->len == 1)
183	outb(inb(ACBCTL1) \| ACBCTL1_ACK, ACBCTL1);
184	else
185	outb(inb(ACBCTL1) & ~ACBCTL1_ACK, ACBCTL1);
186
187	*iface->ptr++ = inb(ACBSDA);
188	--iface->len;
189
190	if (iface->len == 0) {
191	iface->result = 0;
192	iface->state = state_idle;
193	outb(inb(ACBCTL1) \| ACBCTL1_STOP, ACBCTL1);
194	}
195
196	break;
197
198	case state_write:
199	if (iface->len == 0) {
200	iface->result = 0;
201	iface->state = state_idle;
202	outb(inb(ACBCTL1) \| ACBCTL1_STOP, ACBCTL1);
203	break;
204	}
205
206	outb(*iface->ptr++, ACBSDA);
207	--iface->len;
208
209	break;
210	}
211
212	return;
213
214	negack:
215	DBG("negative acknowledge in state %s\n",
216	scx200_acb_state_name[iface->state]);
217
218	iface->state = state_idle;
219	iface->result = -ENXIO;
220
221	outb(inb(ACBCTL1) \| ACBCTL1_STOP, ACBCTL1);
222	outb(ACBST_STASTR \| ACBST_NEGACK, ACBST);
223	return;
224
225	error:
226	dev_err(&iface->adapter.dev, "%s in state %s\n", errmsg,
227	scx200_acb_state_name[iface->state]);
228
229	iface->state = state_idle;
230	iface->result = -EIO;
231	iface->needs_reset = 1;
232	}
233
234	static void scx200_acb_timeout(struct scx200_acb_iface *iface)
235	{
236	dev_err(&iface->adapter.dev, "timeout in state %s\n",
237	scx200_acb_state_name[iface->state]);
238
239	iface->state = state_idle;
240	iface->result = -EIO;
241	iface->needs_reset = 1;
242	}
243
244	#ifdef POLLED_MODE
245	static void scx200_acb_poll(struct scx200_acb_iface *iface)
246	{
247	u8 status = 0;
248	unsigned long timeout;
249
250	timeout = jiffies + POLL_TIMEOUT;
251	while (time_before(jiffies, timeout)) {
252	status = inb(ACBST);
253	if ((status & (ACBST_SDAST\|ACBST_BER\|ACBST_NEGACK)) != 0) {
254	scx200_acb_machine(iface, status);
255	return;
256	}
257	msleep(10);
258	}
259
260	scx200_acb_timeout(iface);
261	}
262	#endif /* POLLED_MODE */
263
264	static void scx200_acb_reset(struct scx200_acb_iface *iface)
265	{
266	/* Disable the ACCESS.bus device and Configure the SCL
267	frequency: 16 clock cycles */
268	outb(0x70, ACBCTL2);
269	/* Polling mode */
270	outb(0, ACBCTL1);
271	/* Disable slave address */
272	outb(0, ACBADDR);
273	/* Enable the ACCESS.bus device */
274	outb(inb(ACBCTL2) \| ACBCTL2_ENABLE, ACBCTL2);
275	/* Free STALL after START */
276	outb(inb(ACBCTL1) & ~(ACBCTL1_STASTRE \| ACBCTL1_NMINTE), ACBCTL1);
277	/* Send a STOP */
278	outb(inb(ACBCTL1) \| ACBCTL1_STOP, ACBCTL1);
279	/* Clear BER, NEGACK and STASTR bits */
280	outb(ACBST_BER \| ACBST_NEGACK \| ACBST_STASTR, ACBST);
281	/* Clear BB bit */
282	outb(inb(ACBCST) \| ACBCST_BB, ACBCST);
283	}
284
285	static s32 scx200_acb_smbus_xfer(struct i2c_adapter *adapter,
286	u16 address, unsigned short flags,
287	char rw, u8 command, int size,
288	union i2c_smbus_data *data)
289	{
290	struct scx200_acb_iface *iface = i2c_get_adapdata(adapter);
291	int len;
292	u8 *buffer;
293	u16 cur_word;
294	int rc;
295
296	switch (size) {
297	case I2C_SMBUS_QUICK:
298	len = 0;
299	buffer = NULL;
300	break;
301	case I2C_SMBUS_BYTE:
302	if (rw == I2C_SMBUS_READ) {
303	len = 1;
304	buffer = &data->byte;
305	} else {
306	len = 1;
307	buffer = &command;
308	}
309	break;
310	case I2C_SMBUS_BYTE_DATA:
311	len = 1;
312	buffer = &data->byte;
313	break;
314	case I2C_SMBUS_WORD_DATA:
315	len = 2;
316	cur_word = cpu_to_le16(data->word);
317	buffer = (u8 *)&cur_word;
318	break;
319	case I2C_SMBUS_BLOCK_DATA:
320	len = data->block[0];
321	buffer = &data->block[1];
322	break;
323	default:
324	return -EINVAL;
325	}
326
327	DBG("size=%d, address=0x%x, command=0x%x, len=%d, read=%d\n",
328	size, address, command, len, rw == I2C_SMBUS_READ);
329
330	if (!len && rw == I2C_SMBUS_READ) {
331	dev_warn(&adapter->dev, "zero length read\n");
332	return -EINVAL;
333	}
334
335	if (len && !buffer) {
336	dev_warn(&adapter->dev, "nonzero length but no buffer\n");
337	return -EFAULT;
338	}
339
340	down(&iface->sem);
341
342	iface->address_byte = address<<1;
343	if (rw == I2C_SMBUS_READ)
344	iface->address_byte \|= 1;
345	iface->command = command;
346	iface->ptr = buffer;
347	iface->len = len;
348	iface->result = -EINVAL;
349	iface->needs_reset = 0;
350
351	outb(inb(ACBCTL1) \| ACBCTL1_START, ACBCTL1);
352
353	if (size == I2C_SMBUS_QUICK \|\| size == I2C_SMBUS_BYTE)
354	iface->state = state_quick;
355	else
356	iface->state = state_address;
357
358	#ifdef POLLED_MODE
359	while (iface->state != state_idle)
360	scx200_acb_poll(iface);
361	#else /* POLLED_MODE */
362	#error Interrupt driven mode not implemented
363	#endif /* POLLED_MODE */
364
365	if (iface->needs_reset)
366	scx200_acb_reset(iface);
367
368	rc = iface->result;
369
370	up(&iface->sem);
371
372	if (rc == 0 && size == I2C_SMBUS_WORD_DATA && rw == I2C_SMBUS_READ)
373	data->word = le16_to_cpu(cur_word);
374
375	#ifdef DEBUG
376	DBG(": transfer done, result: %d", rc);
377	if (buffer) {
378	int i;
379	printk(" data:");
380	for (i = 0; i < len; ++i)
381	printk(" %02x", buffer[i]);
382	}
383	printk("\n");
384	#endif
385
386	return rc;
387	}
388
389	static u32 scx200_acb_func(struct i2c_adapter *adapter)
390	{
391	return I2C_FUNC_SMBUS_QUICK \| I2C_FUNC_SMBUS_BYTE \|
392	I2C_FUNC_SMBUS_BYTE_DATA \| I2C_FUNC_SMBUS_WORD_DATA \|
393	I2C_FUNC_SMBUS_BLOCK_DATA;
394	}
395
396	/* For now, we only handle combined mode (smbus) */
397	static struct i2c_algorithm scx200_acb_algorithm = {
1da177e4 LT	398	.smbus_xfer = scx200_acb_smbus_xfer,
	399	.functionality = scx200_acb_func,
	400	};
	401
	402	static struct scx200_acb_iface *scx200_acb_list;
	403
	404	static int scx200_acb_probe(struct scx200_acb_iface *iface)
	405	{
	406	u8 val;
	407
	408	/* Disable the ACCESS.bus device and Configure the SCL
	409	frequency: 16 clock cycles */
	410	outb(0x70, ACBCTL2);
	411
	412	if (inb(ACBCTL2) != 0x70) {
	413	DBG("ACBCTL2 readback failed\n");
	414	return -ENXIO;
	415	}
	416
	417	outb(inb(ACBCTL1) \| ACBCTL1_NMINTE, ACBCTL1);
	418
	419	val = inb(ACBCTL1);
	420	if (val) {
	421	DBG("disabled, but ACBCTL1=0x%02x\n", val);
	422	return -ENXIO;
	423	}
	424
	425	outb(inb(ACBCTL2) \| ACBCTL2_ENABLE, ACBCTL2);
	426
	427	outb(inb(ACBCTL1) \| ACBCTL1_NMINTE, ACBCTL1);
	428
	429	val = inb(ACBCTL1);
	430	if ((val & ACBCTL1_NMINTE) != ACBCTL1_NMINTE) {
	431	DBG("enabled, but NMINTE won't be set, ACBCTL1=0x%02x\n", val);
	432	return -ENXIO;
	433	}
	434
	435	return 0;
	436	}
	437
	438	static int __init scx200_acb_create(int base, int index)
	439	{
	440	struct scx200_acb_iface *iface;
	441	struct i2c_adapter *adapter;
	442	int rc = 0;
	443	char description[64];
	444
	445	iface = kmalloc(sizeof(*iface), GFP_KERNEL);
	446	if (!iface) {
	447	printk(KERN_ERR NAME ": can't allocate memory\n");
	448	rc = -ENOMEM;
	449	goto errout;
	450	}
	451
	452	memset(iface, 0, sizeof(*iface));
	453	adapter = &iface->adapter;
	454	i2c_set_adapdata(adapter, iface);
	455	snprintf(adapter->name, I2C_NAME_SIZE, "SCx200 ACB%d", index);
	456	adapter->owner = THIS_MODULE;
1684a984	457	adapter->id = I2C_HW_SMBUS_SCX200;
1da177e4 LT	458	adapter->algo = &scx200_acb_algorithm;
	459	adapter->class = I2C_CLASS_HWMON;
	460
	461	init_MUTEX(&iface->sem);
	462
	463	snprintf(description, sizeof(description), "NatSemi SCx200 ACCESS.bus [%s]", adapter->name);
	464	if (request_region(base, 8, description) == 0) {
	465	dev_err(&adapter->dev, "can't allocate io 0x%x-0x%x\n",
	466	base, base + 8-1);
	467	rc = -EBUSY;
	468	goto errout;
	469	}
	470	iface->base = base;
	471
	472	rc = scx200_acb_probe(iface);
	473	if (rc) {
	474	dev_warn(&adapter->dev, "probe failed\n");
	475	goto errout;
	476	}
	477
	478	scx200_acb_reset(iface);
	479
	480	if (i2c_add_adapter(adapter) < 0) {
	481	dev_err(&adapter->dev, "failed to register\n");
	482	rc = -ENODEV;
	483	goto errout;
	484	}
	485
	486	lock_kernel();
	487	iface->next = scx200_acb_list;
	488	scx200_acb_list = iface;
	489	unlock_kernel();
	490
	491	return 0;
	492
	493	errout:
	494	if (iface) {
	495	if (iface->base)
	496	release_region(iface->base, 8);
	497	kfree(iface);
	498	}
	499	return rc;
	500	}
	501
	502	static struct pci_device_id scx200[] = {
	503	{ PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_SCx200_BRIDGE) },
	504	{ PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_SC1100_BRIDGE) },
	505	{ },
	506	};
	507
	508	static int __init scx200_acb_init(void)
	509	{
	510	int i;
	511	int rc;
	512
	513	pr_debug(NAME ": NatSemi SCx200 ACCESS.bus Driver\n");
	514
	515	/* Verify that this really is a SCx200 processor */
	516	if (pci_dev_present(scx200) == 0)
	517	return -ENODEV;
	518
	519	rc = -ENXIO;
	520	for (i = 0; i < MAX_DEVICES; ++i) {
	521	if (base[i] > 0)
522	rc = scx200_acb_create(base[i], i);
523	}
524	if (scx200_acb_list)
525	return 0;
526	return rc;
527	}
528
529	static void __exit scx200_acb_cleanup(void)
530	{
531	struct scx200_acb_iface *iface;
532	lock_kernel();
533	while ((iface = scx200_acb_list) != NULL) {
534	scx200_acb_list = iface->next;
535	unlock_kernel();
536
537	i2c_del_adapter(&iface->adapter);
538	release_region(iface->base, 8);
539	kfree(iface);
540	lock_kernel();
541	}
542	unlock_kernel();
543	}
544
545	module_init(scx200_acb_init);
546	module_exit(scx200_acb_cleanup);
547
548	/*
549	Local variables:
550	compile-command: "make -k -C ../.. SUBDIRS=drivers/i2c modules"
551	c-basic-offset: 8
552	End:
553	*/
554