/* ------------------------------------------------------------------------- *//* i2c-algo-bit.c i2c driver algorithms for bit-shift adapters		     *//* ------------------------------------------------------------------------- *//*   Copyright (C) 1995-2000 Simon G. Vogl    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.		     *//* ------------------------------------------------------------------------- *//* With some changes from Ky鰏ti M鋖kki <kmalkki@cc.hut.fi> and even   Frodo Looijaard <frodol@dds.nl> *//* $Id: i2c-algo-bit.c,v 1.2 2004/02/06 13:19:45 laputa Exp $ */#include <linux/kernel.h>#include <linux/module.h>#include <linux/delay.h>#include <linux/slab.h>#include <linux/version.h>#include <linux/init.h>#include <asm/uaccess.h>#include <linux/ioport.h>#include <linux/errno.h>#include <linux/sched.h>#include <linux/i2c.h>#include <linux/i2c-algo-bit.h>/* ----- global defines ----------------------------------------------- */#define DEB(x) if (i2c_debug>=1) x;#define DEB2(x) if (i2c_debug>=2) x;#define DEBSTAT(x) if (i2c_debug>=3) x; /* print several statistical values*/#define DEBPROTO(x) if (i2c_debug>=9) { x; } 	/* debug the protocol by showing transferred bits *//* debugging - slow down transfer to have a look at the data .. 	*//* I use this with two leds&resistors, each one connected to sda,scl 	*//* respectively. This makes sure that the algorithm works. Some chips   *//* might not like this, as they have an internal timeout of some mils	*//*#define SLO_IO      jif=jiffies;while(jiffies<=jif+i2c_table[minor].veryslow)\                        if (need_resched) schedule();*//* ----- global variables ---------------------------------------------	*/#ifdef SLO_IO	int jif;#endif/* module parameters: */static int i2c_debug;static int bit_test;	/* see if the line-setting functions work	*/static int bit_scan;	/* have a look at what's hanging 'round		*//* --- setting states on the bus with the right timing: ---------------	*/#define setsda(adap,val) adap->setsda(adap->data, val)#define setscl(adap,val) adap->setscl(adap->data, val)#define getsda(adap) adap->getsda(adap->data)#define getscl(adap) adap->getscl(adap->data)static inline void sdalo(struct i2c_algo_bit_data *adap){	setsda(adap,0);	udelay(adap->udelay);}static inline void sdahi(struct i2c_algo_bit_data *adap){	setsda(adap,1);	udelay(adap->udelay);}static inline void scllo(struct i2c_algo_bit_data *adap){	setscl(adap,0);	udelay(adap->udelay);#ifdef SLO_IO	SLO_IO#endif}/* * Raise scl line, and do checking for delays. This is necessary for slower * devices. */static inline int sclhi(struct i2c_algo_bit_data *adap){	int start=jiffies;	setscl(adap,1);	udelay(adap->udelay);	/* Not all adapters have scl sense line... */	if (adap->getscl == NULL )		return 0; 	while (! getscl(adap) ) {	 		/* the hw knows how to read the clock line, 		 * so we wait until it actually gets high. 		 * This is safer as some chips may hold it low 		 * while they are processing data internally.  		 */		setscl(adap,1);		if (start+adap->timeout <= jiffies) {			return -ETIMEDOUT;		}		if (current->need_resched)			schedule();	}	DEBSTAT(printk("needed %ld jiffies\n", jiffies-start));#ifdef SLO_IO	SLO_IO#endif	return 0;} /* --- other auxiliary functions --------------------------------------	*/static void i2c_start(struct i2c_algo_bit_data *adap) {	/* assert: scl, sda are high */	DEBPROTO(printk("S "));	sdalo(adap);	scllo(adap);}static void i2c_repstart(struct i2c_algo_bit_data *adap) {	/* scl, sda may not be high */	DEBPROTO(printk(" Sr "));	setsda(adap,1);	setscl(adap,1);	udelay(adap->udelay);		sdalo(adap);	scllo(adap);}static void i2c_stop(struct i2c_algo_bit_data *adap) {	DEBPROTO(printk("P\n"));	/* assert: scl is low */	sdalo(adap);	sclhi(adap); 	sdahi(adap);}/* send a byte without start cond., look for arbitration,    check ackn. from slave *//* returns: * 1 if the device acknowledged * 0 if the device did not ack * -ETIMEDOUT if an error occurred (while raising the scl line) */static int i2c_outb(struct i2c_adapter *i2c_adap, char c){	int i;	int sb;	int ack;	struct i2c_algo_bit_data *adap = i2c_adap->algo_data;	/* assert: scl is low */	DEB2(printk(" i2c_outb:%2.2X\n",c&0xff));	for ( i=7 ; i>=0 ; i-- ) {		sb = c & ( 1 << i );		setsda(adap,sb);		udelay(adap->udelay);		DEBPROTO(printk("%d",sb!=0));		if (sclhi(adap)<0) { /* timed out */			sdahi(adap); /* we don't want to block the net */			return -ETIMEDOUT;		};		/* do arbitration here: 		 * if ( sb && ! getsda(adap) ) -> ouch! Get out of here.		 */		setscl(adap, 0 );		udelay(adap->udelay);	}	sdahi(adap);	if (sclhi(adap)<0){ /* timeout */		return -ETIMEDOUT;	};	/* read ack: SDA should be pulled down by slave */	ack=getsda(adap);	/* ack: sda is pulled low ->success.	 */	DEB2(printk(" i2c_outb: getsda() =  0x%2.2x\n", ~ack ));	DEBPROTO( printk("[%2.2x]",c&0xff) );	DEBPROTO(if (0==ack){ printk(" A ");} else printk(" NA ") );	scllo(adap);	return 0==ack;		/* return 1 if device acked	 */	/* assert: scl is low (sda undef) */}static int i2c_inb(struct i2c_adapter *i2c_adap) {	/* read byte via i2c port, without start/stop sequence	*/	/* acknowledge is sent in i2c_read.			*/	int i;	unsigned char indata=0;	struct i2c_algo_bit_data *adap = i2c_adap->algo_data;	/* assert: scl is low */	DEB2(printk("i2c_inb.\n"));	sdahi(adap);	for (i=0;i<8;i++) {		if (sclhi(adap)<0) { /* timeout */			return -ETIMEDOUT;		};		indata *= 2;		if ( getsda(adap) ) 			indata |= 0x01;		scllo(adap);	}	/* assert: scl is low */	DEBPROTO(printk(" %2.2x", indata & 0xff));	return (int) (indata & 0xff);}/* * Sanity check for the adapter hardware - check the reaction of * the bus lines only if it seems to be idle. */static int test_bus(struct i2c_algo_bit_data *adap, char* name) {	int scl,sda;	sda=getsda(adap);	if (adap->getscl==NULL) {		printk("i2c-algo-bit.o: Warning: Adapter can't read from clock line - skipping test.\n");		return 0;			}	scl=getscl(adap);	printk("i2c-algo-bit.o: Adapter: %s scl: %d  sda: %d -- testing...\n",	       name,getscl(adap),getsda(adap));	if (!scl || !sda ) {		printk("i2c-algo-bit.o: %s seems to be busy.\n",name);		goto bailout;	}	sdalo(adap);	printk("i2c-algo-bit.o:1 scl: %d  sda: %d \n",getscl(adap),	       getsda(adap));	if ( 0 != getsda(adap) ) {		printk("i2c-algo-bit.o: %s SDA stuck high!\n",name);		sdahi(adap);		goto bailout;	}	if ( 0 == getscl(adap) ) {		printk("i2c-algo-bit.o: %s SCL unexpected low while pulling SDA low!\n",			name);		goto bailout;	}			sdahi(adap);	printk("i2c-algo-bit.o:2 scl: %d  sda: %d \n",getscl(adap),	       getsda(adap));	if ( 0 == getsda(adap) ) {		printk("i2c-algo-bit.o: %s SDA stuck low!\n",name);		sdahi(adap);		goto bailout;	}	if ( 0 == getscl(adap) ) {		printk("i2c-algo-bit.o: %s SCL unexpected low while SDA high!\n",		       name);	goto bailout;	}	scllo(adap);	printk("i2c-algo-bit.o:3 scl: %d  sda: %d \n",getscl(adap),	       getsda(adap));	if ( 0 != getscl(adap) ) {		printk("i2c-algo-bit.o: %s SCL stuck high!\n",name);		sclhi(adap);		goto bailout;	}	if ( 0 == getsda(adap) ) {		printk("i2c-algo-bit.o: %s SDA unexpected low while pulling SCL low!\n",			name);		goto bailout;	}	sclhi(adap);	printk("i2c-algo-bit.o:4 scl: %d  sda: %d \n",getscl(adap),	       getsda(adap));	if ( 0 == getscl(adap) ) {		printk("i2c-algo-bit.o: %s SCL stuck low!\n",name);		sclhi(adap);		goto bailout;	}	if ( 0 == getsda(adap) ) {		printk("i2c-algo-bit.o: %s SDA unexpected low while SCL high!\n",			name);		goto bailout;	}	printk("i2c-algo-bit.o: %s passed test.\n",name);	return 0;bailout:	sdahi(adap);	sclhi(adap);	return -ENODEV;}