Changeset 3749

Timestamp:

12/22/02 14:24:32 (10 years ago)

Author:

kmalkki

Message:

(Kyösti) Use rdtscl() on x86 machines to get better resolution for bus

speed. Currently running this at 1 MHz (250ns delay) on a BT848
board with no problems so far. Falls back to udelay() with maximum
bus clock of 250 kHz if rdtscl() not defined.

Byte and bit level access functions now loop internally over write
and read buffer to remove a considerable amount of stack operations.

Divide flags to ctrl and errors, and other changes in
i2c_algo_biths_data.

Location:

i2c/trunk/kernel

Files:

• i2c-algo-biths.c (modified) (30 diffs)
• i2c-algo-biths.h (modified) (5 diffs)

i2c/trunk/kernel/i2c-algo-biths.c

@@ -3 +3 @@
 /* ------------------------------------------------------------------------- */
 /*   Copyright (C) 1995-2000 Simon G. Vogl
+     Copyright (C) 2002-2003 Kyösti Mälkki
 
     This program is free software; you can redistribute it and/or modify
@@ -18 +19 @@
     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                */
 /* ------------------------------------------------------------------------- */
-
-/* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and even
-   Frodo Looijaard <frodol@dds.nl> */
 
 /* $Id$ */
@@ -43 +41 @@
  * directories, or load this module manually.
  */
+#ifndef ALGO_BIT_COMPATIBILITY
 #define ALGO_BIT_COMPATIBILITY 0
+#endif
 
 #define FATAL_BUS       0
@@ -74 +74 @@
 
 /* Bus timing for 50/50 duty cycle :  T_setup + T_hold = T_scllo = T_sclhi */
-/* Where to use 2 x adap->udelay */
-#define T_min   0       /* after any SCL SDA change     */
-#define T_sclhi 1       /* SCL high                     */
-#define T_scllo 1       /* SCL low                      */
-#define T_setup 0       /* SDA change to SCL rise       */
-#define T_hold  0       /* SCL fall to SDA change       */
-
-#define _sf(a)          adap->flags|=(a)
-#define _cf(a)          adap->flags&=~(a)
-#define ___setscl(b)    if (b) _sf(_HS_SCL); else _cf(_HS_SCL); adap->setscl(adap) 
-#define ___setsda(b)    if (b) _sf(_HS_SDA); else _cf(_HS_SDA); adap->setsda(adap)
-
-#define __setdt(x,dt)   if (dt) _sf(_HS_DBL_DT); x;     /* cleared after use */
+/* 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);\
+                        adap->setstate(adap); adap->setscl(adap) 
+#define ___setsda(b)    if (b) _sf(_HS_SDA); else _cf(_HS_SDA);\
+                        adap->setstate(adap); adap->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)  ___setsda(b);                   /* fixed post-SDA delay */
+#define __setsda(b,dt)  __setdt(___setsda(b),dt);
 #define __getscl()      adap->getscl(adap)
 #define __getsda()      adap->getsda(adap)
 
 
-#define RETURN_ON_FAILURE(x)            x; if (adap->flags & _HS_ERROR) return
+#define RETURN_ON_FAILURE(x)            x; if (adap->errors) return
 #define TRY(x) RETURN_ON_FAILURE(x)
-#define TRY0(x) RETURN_ON_FAILURE(x) 0
 
 #define _setscl(b,dt)   RETURN_ON_FAILURE(__setscl(b,dt))
@@ -113 +114 @@
         PROTO_S("S");
         /* assert: scl, sda undef */
-        adap->flags &= ~_HS_ERROR;
+        adap->errors = 0;
         _sdahi(T_setup);
         _sclhi(T_min);
@@ -125 +126 @@
         PROTO_S(" P");
         /* scl undef after error, sda, scl freedom unknown */
-        adap->flags &= ~(_HS_SDA_FREE | _HS_DBL_DT);
-        if (adap->flags & _HS_ERROR) {
-            adap->flags &= ~_HS_ERROR;
+        adap->ctrl &= ~(_HS_SDA_FREE | _HS_DBL_DT);
+        if (adap->errors) {
+            adap->errors = 0;
             _scllo(T_hold);
         }
@@ -137 +138 @@
 }
 
-static void i2c_outbit(struct i2c_algo_biths_data *adap, int sda) 
-{
-        PROTO_B("o");
+
+static void i2c_outbits(struct i2c_algo_biths_data *adap, int i) 
+{
         /* assert: scl is low */
-        _setsda(sda, T_setup);
-        _sclhi(T_sclhi);
-        _scllo(T_hold);
+        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_inbit(struct i2c_algo_biths_data *adap, int *sda)
-{
-        PROTO_B("i");
+static void i2c_inbits(struct i2c_algo_biths_data *adap, int i)
+{
         /* assert: scl is low, sda undef */
-        _sdahi(T_setup); 
-        _sclhi(T_sclhi);        
-        *sda = _getsda();
-        _scllo(T_hold);
+        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 c) 
-{
-        int i, sda;
-
-        PROTO_B(".");
-        for ( i=7 ; i>=0 ; i-- ) {
-            TRY(i2c_outbit(adap, (c>>i) & 1));
-        }
-        PROTO_X(" %02X ", c & 0xff);
-
-        /* assert: scl is low */
-        /* read ack: SDA should be pulled down by slave */
-        PROTO_B(".");
-        adap->flags |= _HS_SDA_FREE;
-        TRY(i2c_inbit(adap, &sda));
-        adap->flags &= ~_HS_SDA_FREE;
-
-        if (sda==0) { /* ack: sda is pulled low ->success.       */
-            PROTO_S("[A]");
-        } else if (flags & I2C_M_IGNORE_NAK) {
-            PROTO_S("[NA]");
-        } else {
-            PROTO_S("[NA]");
-            adap->flags |= _HS_NAK;
-        }
-}
-
-static int i2c_inb(struct i2c_algo_biths_data *adap, unsigned short flags, int ack) 
-{
-        /* read byte via i2c port, without start/stop sequence  */
-        int i, sda;
-        char indata=0;
-
-        PROTO_B(".");
-        adap->flags |= _HS_SDA_FREE;
-        for ( i=7 ; i>=0 ; i--) {
-            TRY0(i2c_inbit(adap, &sda));
-            if ( sda )
-                indata |= (1<<i);
-        }
-        adap->flags &= ~_HS_SDA_FREE;
-        PROTO_X(" [%02X] ", indata & 0xff);
-
-        if (! (flags & I2C_M_NO_RD_ACK)) {
-            PROTO_B(".");
-            TRY0(i2c_outbit(adap, !ack));               /* send ack */
-            if ( ack ) {
-                PROTO_S("A");
+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 ", adap->shiftreg);
+            
+            /* 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");
+                PROTO_S("[NA]");
+                adap->errors |= _HS_NAK;
             }
-        }
-
-        /* assert: scl is low , sda undef */
-        return indata;
-}
+            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] ", adap->shiftreg);
+            
+            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)
@@ -257 +263 @@
 static int errflag(int flags)
 {
-    if (! (flags & _HS_ERROR))
+    if (! flags)
         return 2;
     if (flags & _HS_HW_FAIL)
@@ -278 +284 @@
 
 /*
- * Sanity check for the adapter hardware - check the reaction of
- * the bus lines only if it seems to be idle.
+ * Sanity check for the adapter hardware
  */
 static int test_bus(struct i2c_algo_biths_data *adap)
@@ -294 +299 @@
         sscl = test[i][1];
 
-        adap->flags &= ~_HS_ERROR;
+        adap->errors = 0;
         __setsda(ssda, T_min);
         gsda = __getsda() ? 1 : 0;
-        errors = adap->flags & (_HS_HW_FAIL | _HS_SDA_ARB);
+        errors = adap->errors & (_HS_HW_FAIL | _HS_SDA_ARB);
         if (errors)
             printk(KERN_WARNING "i2c-algo-biths.o: %s %s\n", adap->name,
@@ -304 +309 @@
         __setscl(sscl, T_min);
         gscl = __getscl() ? 1 : 0;
-        errors = adap->flags & (_HS_HW_FAIL | _HS_TIMEOUT);
+        errors = adap->errors & (_HS_HW_FAIL | _HS_TIMEOUT);
         if (errors)
             printk(KERN_WARNING "i2c-algo-biths.o: %s %s\n", adap->name,
@@ -314 +319 @@
         if ( ssda!=gsda )
             printk(KERN_WARNING "i2c-algo-biths.o: %s SDA set %d, got %d!\n", adap->name, ssda, gsda);
-        if ( (adap->flags & _HS_ERROR) || sscl!=gscl || ssda!=gsda )
+        if ( (adap->errors) || sscl!=gscl || ssda!=gsda )
             break;
         i++;
@@ -321 +326 @@
     __setsda(1,0);
     __setscl(1,0);
-    adap->flags &= ~_HS_ERROR;
+    adap->errors = 0;
 
     if (test[i][0]==-1) {
@@ -332 +337 @@
 }
 
-/* ----- Utility functions
- */
-
-static void doDataBytes(struct i2c_algo_biths_data *adap, struct i2c_msg *msg)
-{
-    char *temp = msg->buf;
-
-    msg->done = 0;
-    while (msg->done < msg->len) {
-        if ( msg->flags & I2C_M_RD ) {
-            TRY(*temp++ = i2c_inb(adap, msg->flags, msg->done < msg->len-1) );
-        } else {
-            TRY(i2c_outb(adap, msg->flags, *temp++));
-        }
-        msg->done++;
-    }
-}
-
-/* doAddress initiates the transfer by generating the start condition (in
- * try_address) and transmits the address in the necessary format to handle
+
+/* doAddress transmits the address in the necessary format to handle
  * reads, writes as well as 10bit-addresses.
  */
@@ -357 +344 @@
 static void doAddress(struct i2c_algo_biths_data *adap, struct i2c_msg *msg) 
 {
-        unsigned char addr;
-
-        if ( (msg->flags & I2C_M_TEN)  ) { 
+        unsigned char addr[2];
+        int count;
+
+        if ( msg->flags & I2C_M_TEN ) { 
                 /* a ten bit address */
-                addr = 0xf0 | (( msg->addr >> 7) & 0x03);
-
-                /* try extended address code...*/
-                TRY(i2c_outb(adap, msg->flags, addr));
-
-                /* the remaining 8 bit address */
-                TRY(i2c_outb(adap, msg->flags, msg->addr & 0x7f));
+                count = 2;
+                addr[0] = 0xf0 | (( msg->addr >> 7) & 0x03);
+                addr[1] = msg->addr & 0x7f;
+
+                /* try extended address code ... and the remaining 8 bit address */
+                TRY(i2c_outb(adap, msg->flags, addr, &count));
 
                 if ( msg->flags & I2C_M_RD ) {
@@ -373 +360 @@
                         
                         /* okay, now switch into reading mode */
-                        addr |= 0x01;
-                        TRY(i2c_outb(adap, msg->flags, addr));
+                        count = 1;
+                        addr[0] |= 0x01;
+                        TRY(i2c_outb(adap, msg->flags, addr, &count));
                 }
         } else {                /* normal 7bit address  */
-                addr = ( msg->addr << 1 );
+                count = 1;
+                addr[0] = ( msg->addr << 1 );
                 if (msg->flags & I2C_M_RD )
-                        addr |= 1;
+                        addr[0] |= 1;
                 if (msg->flags & I2C_M_REV_DIR_ADDR )
-                        addr ^= 1;
-                TRY(i2c_outb(adap, msg->flags, addr));
+                        addr[0] ^= 1;
+                TRY(i2c_outb(adap, msg->flags, addr, &count));
         }
 }
@@ -400 +389 @@
         struct i2c_msg *msg = msgs;
         struct i2c_algo_biths_data *adap = i2c_adap->algo_data;
-        int i, j, state;
+        int mn, j, state;
         enum { MSG_INIT, MSG_START, MSG_ADDRESS, MSG_DATA, MSG_READY, MSG_STOP, MSG_EXIT };
 
         state = MSG_INIT;
-        i=0;
+        mn=0;
 
         adap->dstr=NULL;
@@ -421 +410 @@
             
             case MSG_INIT:
-                msg = &msgs[i];
-                if ((msg->flags & I2C_M_NOSTART) && (i)) {
+                msg = &msgs[mn];
+                if ((msg->flags & I2C_M_NOSTART) && (mn)) {
                     state = MSG_DATA;
                     break;
@@ -429 +418 @@
             case MSG_START:     
                 i2c_start(adap);
-                if (adap->flags & _HS_ERROR) {
+                if (adap->errors) {
                     state = MSG_STOP;   
                     break;
@@ -436 +425 @@
             case MSG_ADDRESS:
                 doAddress(adap, msg);
-                if (adap->flags & _HS_ERROR) {
+                if (adap->errors) {
                     state = MSG_STOP;
                     break;
@@ -442 +431 @@
 
             case MSG_DATA:
-                doDataBytes(adap, msg);
-                if (adap->flags & _HS_ERROR) {
+                j = msg->len;
+                if ( msg->flags & I2C_M_RD ) {
+                    i2c_inb(adap, msg->flags, msg->buf, &j);
+                } else {
+                    i2c_outb(adap, msg->flags, msg->buf, &j);
+                }
+                msg->done = msg->len - j;
+                if (adap->errors) {
                     state = MSG_STOP;
                     break;
@@ -449 +444 @@
         
             case MSG_READY:
-                i++;
-                if (i<num) {
-                    msg->err = errflag(adap->flags);
+                mn++;
+                if (mn<num) {
+                    msg->err = errflag(adap->errors);
                     debug_protocol(adap, msg->err);
                     state = MSG_INIT;
@@ -458 +453 @@
 
             case MSG_STOP:
-                msg->err = errflag(adap->flags);
+                msg->err = errflag(adap->errors);
                 i2c_stop(adap);
                 j = 0;
-                while (adap->flags & _HS_ERROR) {
+                while (adap->errors) {
                     if ( ++j > 10) {
                         msg->err = -ENODEV;
@@ -484 +479 @@
             debug_printout(i2c_adap, j, msgs[j].err);
 
-        return (msg->err < 0) ? msg->err : i;
+        return (msg->err < 0) ? msg->err : mn;
 }
 
@@ -519 +514 @@
 static inline void _hw_setscl(struct i2c_algo_bit_data *old, int state)
 {
-    old->setscl(old->data, state & _HS_SCL);
+        old->setscl(old->data, state & _HS_SCL);
 }
 
 static inline void _hw_setsda(struct i2c_algo_bit_data *old, int state)
 {
-    old->setsda(old->data, state & _HS_SDA);
+        old->setsda(old->data, state & _HS_SDA);
 }
 
 static inline int _hw_getscl(struct i2c_algo_bit_data *old)
 {
-    return old->getscl(old->data);
+        return old->getscl(old->data);
 }
 
 static inline int _hw_getsda(struct i2c_algo_bit_data *old)
 {
-    return old->getsda(old->data);
-}
-
-static inline void _hw_timer(int dt)
-{
-    udelay(dt);
+        return old->getsda(old->data);
 }
 
 #define INCLUDE_BITHS_INLINES
 #include "i2c-algo-biths.h"
-static void _ba_setscl(struct i2c_algo_biths_data *adap)
-{
-    adap->state = adap->flags;
-    i2c_bit_setscl(adap);
-}
-static void _ba_setsda(struct i2c_algo_biths_data *adap)
-{
-    adap->state = adap->flags;
-    i2c_bit_setsda(adap);
-}
-static int _ba_getscl(struct i2c_algo_biths_data *adap)
-{
-    return i2c_bit_getscl(adap);
-}
-static int _ba_getsda(struct i2c_algo_biths_data *adap)
-{
-    return i2c_bit_getsda(adap);
-}
-
-static struct i2c_algo_biths_data _ba_template = {
-        setsda:  _ba_setsda,
-        setscl:  _ba_setscl,
-        getsda:  _ba_getsda,
-        getscl:  _ba_getscl,
+static  _HS_ATTR_ void _old_setstate(struct i2c_algo_biths_data *adap)
+{
+        adap->hw_state = adap->ctrl;
+}
+
+static _HS_ATTR_ void _old_setscl(struct i2c_algo_biths_data *adap)
+{
+        i2c_bit_setscl(adap);
+}
+static _HS_ATTR_ void _old_setsda(struct i2c_algo_biths_data *adap)
+{
+        i2c_bit_setsda(adap);
+}
+static _HS_ATTR_ int _old_getscl(struct i2c_algo_biths_data *adap)
+{
+        return i2c_bit_getscl(adap);
+}
+static _HS_ATTR_ int _old_getsda(struct i2c_algo_biths_data *adap)
+{
+        return i2c_bit_getsda(adap);
+}
+
+static struct i2c_algo_biths_data _old_template = {
+    setstate:  _old_setstate,
+    setsda:  _old_setsda,
+    setscl:  _old_setscl,
+    getsda:  _old_getsda,
+    getscl:  _old_getscl,
 };
 
@@ -583 +577 @@
             return -ENOMEM;
 
-        memcpy(adap, &_ba_template, sizeof(struct i2c_algo_biths_data));
-        adap->data = old_adap;
-        adap->udelay = (old_adap->udelay+1)>>1; /* 1/4 vs 1/2 cycle */
+        memcpy(adap, &_old_template, sizeof(struct i2c_algo_biths_data));
+        adap->hw_data = old_adap;
+        adap->xloops = old_adap->udelay * 0x0863; /* 1/4 vs 1/2 cycle, 0x10c6 / 2 */
         adap->timeout = old_adap->timeout;
         i2c_adap->algo_data = adap;
@@ -608 +602 @@
 
 #endif
+
+#ifdef rdtscl
+/* TSC stuff from arch/i386/lib/delay.c */
+
+static _HS_ATTR_ void i2c_tsc_set(struct i2c_algo_biths_data *adap)
+{
+    rdtscl(adap->bclock);
+}
+
+static _HS_ATTR_ void i2c_tsc_run(struct i2c_algo_biths_data *adap)
+{
+    unsigned long now, loops, xloops;
+    int d0;
+    xloops = adap->xloops; 
+    __asm__("mull %0"
+            :"=d" (xloops), "=&a" (d0)
+            :"1" (xloops),"0" (current_cpu_data.loops_per_jiffy));
+    loops = xloops * HZ;
+    do
+    {
+        rep_nop();
+        rdtscl(now);
+    } while ( (now - adap->bclock) < loops );
+}
+
+#else 
+
+static _HS_ATTR_ void i2c_udelay_set(struct i2c_algo_biths_data *adap) {}
+
+static _HS_ATTR_ void i2c_udelay_run(struct i2c_algo_biths_data *adap)
+{
+    int usecs;
+    /* adap->xloops = usecs * 0x000010c6 / 2; */
+    usecs = ((adap->xloops + 0x0863) >> 12); 
+    if (adap->ctrl & _HS_DBL_DT)
+        usecs<<=1;
+    udelay(usecs);
+}
+
+#endif /* rdtscl */
+
 
 /* 
@@ -621 +656 @@
         adap->dstr = 0; // no protocol dump buffer
 
+        if (adap->set_timer == NULL) {
+#ifdef rdtscl   /* if (x86_udelay_tsc) here instead ? */
+                adap->set_timer = i2c_tsc_set;
+                adap->run_timer = i2c_tsc_run;
+#else
+                adap->set_timer = i2c_udelay_set;
+                adap->run_timer = i2c_udelay_run;
+#endif
+        }
+
         if (bit_test) {
             int ret = test_bus(adap);
@@ -665 +710 @@
 {
         printk(KERN_INFO "i2c-algo-biths.o: i2c high-speed bit algorithm module version %s (%s)\n", I2C_VERSION, I2C_DATE);
+#ifdef rdtscl
+        DEB1(printk(KERN_DEBUG "i2c-algo-biths.o:  ... will use rdtscl() for bus clock\n"));
+#else
+        DEB1(printk(KERN_DEBUG "i2c-algo-biths.o:  ... will use udelay() for bus clock\n");
+#endif
         return 0;
 }
@@ -674 +724 @@
 
 #ifdef MODULE
-MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
+MODULE_AUTHOR("Kyösti Mälkki <kmalkki@cc.hut.fi>");
 MODULE_DESCRIPTION("I2C-Bus bit-banging algorithm");
 #ifdef MODULE_LICENSE

i2c/trunk/kernel/i2c-algo-biths.h

@@ -49 +49 @@
  */
 struct i2c_algo_biths_data {
-        void *data;             /* private data for lowlevel routines */
-        int state;
+        void *hw_data;          /* private data for lowlevel routines */
+        int hw_state;
         void (*setscl)(struct i2c_algo_biths_data *adap) _HS_ATTR_ ;
         void (*setsda)(struct i2c_algo_biths_data *adap) _HS_ATTR_ ;
         int (*getscl) (struct i2c_algo_biths_data *adap) _HS_ATTR_ ;
         int (*getsda) (struct i2c_algo_biths_data *adap) _HS_ATTR_ ;
-        int flags;
+
+        void (*setstate)(struct i2c_algo_biths_data *adap) _HS_ATTR_ ;
+        void (*set_timer)(struct i2c_algo_biths_data *adap) _HS_ATTR_ ;
+        void (*run_timer)(struct i2c_algo_biths_data *adap) _HS_ATTR_ ;
+
+        short ctrl;
+        short errors;
+        char shiftreg;
 
         /* local settings */
-        int udelay;             /* 1/4 clock-cycle time in microsecs */
-                                /* i.e. clock is (250 / udelay) KHz */
+        unsigned long bclock;
+        unsigned long xloops;   /* 1/4 clock-cycle time in x86 TSC ticks */
+                                /* i.e. bus clock is 250*0x10c6 / xloops kHz */
+
         int timeout;            /* in jiffies */
         char *name;             /* replicate i2c_adapter->name */
@@ -73 +82 @@
 #define _HS_DBL_DT      0x0010  /* T_sclhi is twice longer */
 
-#define _HS_NAK         0x0100
-#define _HS_TIMEOUT     0x0200
-#define _HS_SDA_ARB     0x0400
-#define _HS_HW_FAIL     0x0800
-#define _HS_ERROR       0xff00
+#define _HS_NAK         0x0001
+#define _HS_TIMEOUT     0x0002
+#define _HS_SDA_ARB     0x0004
+#define _HS_HW_FAIL     0x0008
 
 int i2c_biths_add_bus(struct i2c_adapter *);
@@ -88 +96 @@
 /* --- setting states on the bus with the right timing: --------------- */
 
+#define _hw_timer_set(adap) adap->set_timer(adap)
+#define _hw_timer_run(adap) adap->run_timer(adap)
+
+static inline int sda_not_set(struct i2c_algo_biths_data *adap, int rdcount)
+{
+    int sda;
+    /* allow some rise/fall time */
+    while ( rdcount-- ) {
+        sda = _hw_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 inline void i2c_bit_setsda(struct i2c_algo_biths_data *adap)
 {
-    int rdcount = 10;
-    int sda;
-    _hw_setsda(adap->data, adap->state);
-    if ( !(adap->flags & _HS_SDA_FREE)) {
-        /* allow some rise/fall time */
-        while ( rdcount ) {
-            sda = _hw_getsda(adap->data);
-            if (adap->flags & _HS_SDA) {
-                if (sda) break;
-            } else {
-                if (! sda) break;
-            }
-            rdcount--;
-        }
-        if (!rdcount) {
-            if (adap->flags & _HS_SDA) {
-                adap->flags |= _HS_SDA_ARB;
-            } else {
-                adap->flags |= _HS_HW_FAIL;
-            }
-            return;
-        }
+    _hw_setsda(adap->hw_data, adap->hw_state);
+    if ( !(adap->ctrl & _HS_SDA_FREE) && sda_not_set(adap, 10)) {
+        return;
     }
-    _hw_timer(adap->udelay);
+    _hw_timer_set(adap);
+    _hw_timer_run(adap);
 }
 
@@ -125 +143 @@
 #ifndef HW_CANNOT_READ_SCL /* Not all adapters have scl sense line... */
     int rdcount = 10;
-    _hw_setscl(adap->data, adap->state);
-    if (adap->flags & _HS_SCL) {
+    _hw_setscl(adap->hw_data, adap->hw_state);
+    if (adap->ctrl & _HS_SCL) {
         unsigned long start;
-        int sda;
         /* allow some rise time */
-        while (rdcount && !_hw_getscl(adap->data)) rdcount--;
-        /* else client pulling SCL low */
+        while (rdcount && !_hw_getscl(adap->hw_data)) rdcount--;
+        /* else clock synchronisation, give more time */
         start = jiffies;
-        while (!rdcount && !_hw_getscl(adap->data)) {
+        while (!rdcount && !_hw_getscl(adap->hw_data)) {
             if ( time_after(jiffies, start+adap->timeout) ) {
-                adap->flags |= _HS_TIMEOUT; /* scl undef */
+                adap->errors |= _HS_TIMEOUT; /* scl undef */
                 return;
             }
@@ -145 +162 @@
 #endif
         }
-        if ( !(adap->flags & _HS_SDA_FREE)) {
-            /* test for SDA arbitration when SCL is high */
-            sda = _hw_getsda(adap->data);
-            if (adap->flags & _HS_SDA) {
-                if (!sda) {
-                    adap->flags |= _HS_SDA_ARB;
-                    return;
-                }
-            } else { /* !(adap->flag & _HS_SDA) */
-                if (sda) {
-                    adap->flags |= _HS_HW_FAIL;
-                    return;
-                }
-            }
+        _hw_timer_set(adap);
+        /* test for SDA arbitration when SCL is high */
+        if ( !(adap->ctrl & _HS_SDA_FREE) && sda_not_set(adap, 1)) {
+            return;
         }
     } else {
         /* allow some fall time */
-        while (rdcount && _hw_getscl(adap->data)) rdcount--;
+        while (rdcount && _hw_getscl(adap->hw_data)) rdcount--;
         if ( !rdcount ) {
-            adap->flags |= _HS_HW_FAIL;
+            adap->errors |= _HS_HW_FAIL;
             return;
         }
+        _hw_timer_set(adap);
     }
 #else
-    _hw_setscl(adap->data, adap->state);
+    _hw_setscl(adap->hw_data, adap->hw_state);
+    _hw_timer_set(adap);
 #endif /* HW_CANNOT_READ_SCL */
-    if (adap->flags & _HS_DBL_DT) {
-        adap->flags &= ~_HS_DBL_DT;
-        _hw_timer(adap->udelay<<1);
-    } else {
-        _hw_timer(adap->udelay);
-    }
+    _hw_timer_run(adap);
 }
 
-#define i2c_bit_getscl(adap) _hw_getscl(adap->data)
-#define i2c_bit_getsda(adap) _hw_getsda(adap->data)
+static inline int i2c_bit_getscl(struct i2c_algo_biths_data *adap)
+{
+    return _hw_getscl(adap->hw_data);
+}
+
+static inline int i2c_bit_getsda(struct i2c_algo_biths_data *adap)
+{
+    return _hw_getsda(adap->hw_data);
+}
 
 #endif