i2c-algo-biths.c

I2C总线LINUX驱动程序

/* ------------------------------------------------------------------------- */
/* i2c-algo-biths.c i2c driver algorithms for bit-shift adapters	     */
/* ------------------------------------------------------------------------- */
/*   Copyright (C) 1995-2000 Simon G. Vogl
     Copyright (C) 2002-2003 Ky鰏ti M鋖kki

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

/* $Id: i2c-algo-biths.c,v 1.16 2005/03/11 20:37:33 khali Exp $ */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/delay.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/errno.h>
#include <linux/sched.h>
#include "i2c.h"
#include "i2c-algo-biths.h"

/* ----- global defines ----------------------------------------------- */

/* If non-zero, adapter code written for original i2c-algo-bit can be used unmodified. 
 * As this export same symbols, you should either remove i2c-algo-bit.o from depmod
 * directories, or load this module manually.
 */
#ifndef ALGO_BIT_COMPATIBILITY
#define ALGO_BIT_COMPATIBILITY 0
#endif

#define FATAL_BUS	0
#define MODULE_STATUS	1
#define FATAL_MSG	2
#define FATAL_PROTOCOL	3
#define ALL_MSG		4
#define ALL_PROTOCOL	5
#define BIT_LEVEL	9

#define DEB1(x)		if (i2c_debug>=MODULE_STATUS) (x);
static void proto_s(char *d, const char *s) { strcat(d, s); }
static void proto_x(char *d, const char *x, unsigned char y) { while (*d) d++; sprintf(d, x, y); }
#define PROTO_S(x)	if (adap->dstr) proto_s(adap->dstr, x)
#define PROTO_B(x)	if ((adap->dstr) && (i2c_debug>=BIT_LEVEL)) proto_s(adap->dstr, x)
#define PROTO_X(x,y)	if (adap->dstr) proto_x(adap->dstr, x, y)

#define PROTO_MAX_DUMP 1024  // 50 x ".oooooooo [xx] .i[xx]"

/* ----- global variables ---------------------------------------------	*/

/* module parameters:
 */
static int i2c_debug; 
static int bit_test;	/* see if the line-setting functions work	*/

/* Bus timing for 50/50 duty cycle :  T_setup + T_hold = T_scllo = T_sclhi */
/* Run setscl/setsda with a special flag */
#define T_min   0		/* after any SCL SDA change	*/
#define T_sclhi _HS_DBL_DT	/* SCL high			*/
#define T_scllo	_HS_DBL_DT	/* SCL low 			*/
#define T_setup 0		/* SDA change to SCL rise	*/
#define T_hold  0		/* SCL fall to SDA change	*/

#define _sf(a)		adap->ctrl|=(a)
#define _cf(a)		adap->ctrl&=~(a)
#define ___setscl(b)	if (b) _sf(_HS_SCL); else _cf(_HS_SCL); i2c_setscl(adap)
#define ___setsda(b)	if (b) _sf(_HS_SDA); else _cf(_HS_SDA); i2c_setsda(adap)

#define __setdt(x,dt)	if (dt) _sf(dt); x; if (dt) _cf(dt)
#define __setscl(b,dt)	__setdt(___setscl(b),dt)
#define __setsda(b,dt)	__setdt(___setsda(b),dt)
#define __getscl()	i2c_getscl(adap)
#define __getsda()	i2c_getsda(adap)

#define RETURN_ON_FAILURE(x)		x; if (adap->errors) return
#define TRY(x) RETURN_ON_FAILURE(x)

#define _setscl(b,dt)	RETURN_ON_FAILURE(__setscl(b,dt))
#define _setsda(b,dt)	RETURN_ON_FAILURE(__setsda(b,dt))
#define _getscl		__getscl
#define _getsda		__getsda

#define _sclhi(dt)	_setscl(1,dt)
#define _scllo(dt)	_setscl(0,dt)
#define _sdahi(dt)	_setsda(1,dt)
#define _sdalo(dt)	_setsda(0,dt)

/* --- setting states on the bus with the right timing: ---------------	*/

static int i2c_sda_set(struct i2c_algo_biths_data *adap, int rdcount)
{
	int sda;
	/* allow some rise/fall time */
	while ( rdcount-- ) {
		sda = adap->getsda(adap->hw_data);
		if (adap->ctrl & _HS_SDA) {
			if (sda)
				return 0;
			if (!rdcount) {
				adap->errors |= _HS_SDA_ARB;
				return -1;
			}
		} else { /* !(adap->ctrl & _HS_SDA) */
			if (!sda)
				return 0;
			if (!rdcount) {
				adap->errors |= _HS_HW_FAIL;
				return -1;
			}
		}
	}
	return 0;
}

static void i2c_setsda(struct i2c_algo_biths_data *adap)
{
	adap->setstate(adap); 
	adap->setsda(adap->hw_data, adap->hw_state);
	if ( !(adap->ctrl & _HS_SDA_FREE) && ! i2c_sda_set(adap, 10)) {
		return;
	}
	adap->set_timer(adap);
	adap->run_timer(adap);
}

static int i2c_getscl(struct i2c_algo_biths_data *adap)
{
	return adap->getscl(adap->hw_data);
}

static int i2c_getsda(struct i2c_algo_biths_data *adap)
{
	return adap->getsda(adap->hw_data);
}
/*
 * Raise scl line, and do check for delays. This is necessary for slower
 * devices.
 */

static void i2c_setscl(struct i2c_algo_biths_data *adap)
{
#ifndef HW_CANNOT_READ_SCL /* Not all adapters have scl sense line... */
	int rdcount = 10;
	adap->setstate(adap);
	adap->setscl(adap->hw_data, adap->hw_state);
	if (adap->ctrl & _HS_SCL) {
		unsigned long start;
		/* allow some rise time */
		while (rdcount && !adap->getscl(adap->hw_data)) rdcount--;
		/* else clock synchronisation, give more time */
		start = jiffies;
		while (!rdcount && !adap->getscl(adap->hw_data)) {
			if ( time_after(jiffies, start+adap->timeout) ) {
				adap->errors |= _HS_TIMEOUT; /* scl undef */
				return;
			}
#ifdef cond_resched
			cond_resched();
#else
			if (current->need_resched) {
				set_current_state(TASK_UNINTERRUPTIBLE);
				schedule_timeout(1);
			}
#endif
		}
		adap->set_timer(adap);
		/* test for SDA arbitration when SCL is high */
		if ( !(adap->ctrl & _HS_SDA_FREE) && ! i2c_sda_set(adap, 1)) {
			return;
		}
	} else {
		/* allow some fall time */
		while (rdcount && adap->getscl(adap->hw_data)) rdcount--;
		if ( !rdcount ) {
			adap->errors |= _HS_HW_FAIL;
			return;
		}
		adap->set_timer(adap);
	}
#else
	adap->setstate(adap);
	adap->setscl(adap->hw_data, adap->hw_state);
	adap->set_timer(adap);
#endif /* HW_CANNOT_READ_SCL */
	adap->run_timer(adap);
}


/* start, repstart */
static void i2c_start(struct i2c_algo_biths_data *adap)
{
	PROTO_S("S");
	/* assert: scl, sda undef */
	adap->errors = 0;
	_sdahi(T_setup);
	_sclhi(T_min);
	_sdalo(T_min);
	_scllo(T_hold);
	/* assert: scl, sda low */
}

static void i2c_stop(struct i2c_algo_biths_data *adap)
{
	PROTO_S(" P");
	/* scl undef after error, sda, scl freedom unknown */
	adap->ctrl &= ~(_HS_SDA_FREE | _HS_DBL_DT);
	if (adap->errors) {
		adap->errors = 0;
		_scllo(T_hold);
	}
	/* assert: scl low, sda undef */
	_sdalo(T_setup);
	_sclhi(T_min);
	_sdahi(T_min);
	/* assert: scl, sda high */
}


static void i2c_outbits(struct i2c_algo_biths_data *adap, int i) 
{
	/* assert: scl is low */
	PROTO_B(".");
	while  (i--) {
		PROTO_B("o");
		_setsda(adap->shiftreg & 0x80, T_setup);
		_sclhi(T_sclhi);
		_scllo(T_hold);
		adap->shiftreg<<=1;
	}
	/* assert: scl is low */
}

static void i2c_inbits(struct i2c_algo_biths_data *adap, int i)
{
	/* assert: scl is low, sda undef */
	adap->ctrl |= _HS_SDA_FREE;
	PROTO_B(".");
	while  (i--) {
		PROTO_B("i");
		_sdahi(T_setup); 
		_sclhi(T_sclhi);	
		adap->shiftreg<<=1;
		if (_getsda())
			adap->shiftreg |= 0x01;
		_scllo(T_hold);
	}
	adap->ctrl &= ~_HS_SDA_FREE;
	/* assert: scl is low */
}

static void i2c_outb(struct i2c_algo_biths_data *adap, unsigned short flags,
		     char *buf, int *count) 
{
	while (*count) {
		adap->shiftreg = *buf;
		TRY(i2c_outbits(adap, 8));
		PROTO_X(" %02X ", *buf);
		buf++;
	    
		/* read ack: SDA should be pulled down by slave */
		TRY(i2c_inbits(adap, 1));
	    
		if (! (adap->shiftreg & 0x01)) { 
			PROTO_S("[A]");
		} else if (flags & I2C_M_IGNORE_NAK) {
			PROTO_S("[NA]");
		} else {
			PROTO_S("[NA]");
			adap->errors |= _HS_NAK;
		}
		if (adap->errors) return;
		(*count)--;
	}
}

static void i2c_inb(struct i2c_algo_biths_data *adap, unsigned short flags,
		    char *buf, int *count) 
{
	while (*count) {
		TRY(i2c_inbits(adap, 8));
		*buf = adap->shiftreg;
		PROTO_X(" [%02X] ", *buf);
		buf++;
	    
		if (! (flags & I2C_M_NO_RD_ACK)) {
			if (*count == 1) /* was last */
				adap->shiftreg = 0x80;
			else
				adap->shiftreg = 0x00;
			TRY(i2c_outbits(adap,1));

			if (*count == 1) {
				PROTO_S("NA");
			} else {
				PROTO_S("A");
			}
		}
		(*count)--;
	}
}


static void debug_protocol(struct i2c_algo_biths_data *adap, int retval)
{
	if (! adap->dstr) return;

	if ( ((retval<0) && (i2c_debug>=FATAL_PROTOCOL)) || 
	     (i2c_debug>=ALL_PROTOCOL) ) {
		printk(KERN_DEBUG "i2c-algo-biths.o: %s: %s\n", adap->name, adap->dstr); 
	}
	*adap->dstr = 0;
}

static const char * i2c_strerr(int retval)
{ 
	switch (retval) {
	    case 2:
		    return "ack";
		
	    case 1:
		    return "no ack (ignored)";

	    case 0:
		    return "not reached";

	    case -EREMOTEIO:
		    return "no ack";

	    case -ETIMEDOUT:
		    return "SCL rise timeout";
	 
	    case -ECOMM:
		    return "SDA arbitration";

	    case -ENODEV:
		    return "SCL/SDA failure";

	    default:
		    return "unknown";
	}
}

static int errflag(int flags)
{
	if (! flags)
		return 2;
	if (flags & _HS_HW_FAIL)
		return -ENODEV;
	if (flags & _HS_SDA_ARB)
		return -ECOMM;
	if (flags & _HS_TIMEOUT)
		return -ETIMEDOUT;
	if (flags & _HS_NAK)
		return -EREMOTEIO;

	return -1;
}

static void debug_printout(struct i2c_adapter *i2c_adap, int num, int retval)
{ 
	if ( ((retval<0) && (i2c_debug>=FATAL_MSG)) ||
	     (i2c_debug>=ALL_MSG) ) {
		printk(KERN_ERR "i2c-algo-biths.o: %s: msg #%d %s\n", i2c_adap->name, num, i2c_strerr(retval));
	}
}

/*
 * Sanity check for the adapter hardware
 */
static int test_bus(struct i2c_algo_biths_data *adap)
{

	int sscl, ssda, gscl, gsda, i=0;
	int errors;
	int test[][2] = {{1,1}, {0,1}, {1,1}, {1,0}, {1,1}, {-1,-1}}; // SDA, SCL pair