root/i2c/trunk/kernel/i2c-algo-biths.c @ 3759

Revision 3759, 18.8 KB (checked in by kmalkki, 12 years ago)

(Kyösti)

More C99 initializers. More initcalls.

Replace <linux/i2c*.h> with "i2c*.h" in CVS files.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1/* ------------------------------------------------------------------------- */
2/* i2c-algo-biths.c i2c driver algorithms for bit-shift adapters             */
3/* ------------------------------------------------------------------------- */
4/*   Copyright (C) 1995-2000 Simon G. Vogl
5     Copyright (C) 2002-2003 Kyösti Mälkki
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program; if not, write to the Free Software
19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                */
20/* ------------------------------------------------------------------------- */
21
22/* $Id$ */
23
24#include <linux/kernel.h>
25#include <linux/module.h>
26#include <linux/delay.h>
27#include <linux/slab.h>
28#include <linux/version.h>
29#include <linux/init.h>
30#include <asm/uaccess.h>
31#include <linux/ioport.h>
32#include <linux/errno.h>
33#include <linux/sched.h>
34#include "i2c.h"
35#include "i2c-algo-biths.h"
36
37/* ----- global defines ----------------------------------------------- */
38
39/* If non-zero, adapter code written for original i2c-algo-bit can be used unmodified.
40 * As this export same symbols, you should either remove i2c-algo-bit.o from depmod
41 * directories, or load this module manually.
42 */
43#ifndef ALGO_BIT_COMPATIBILITY
44#define ALGO_BIT_COMPATIBILITY 0
45#endif
46
47#define FATAL_BUS       0
48#define MODULE_STATUS   1
49#define FATAL_MSG       2
50#define FATAL_PROTOCOL  3
51#define ALL_MSG         4
52#define ALL_PROTOCOL    5
53#define BIT_LEVEL       9
54
55#define DEB1(x)         if (i2c_debug>=MODULE_STATUS) (x);
56static void proto_s(char *d, const char *s) { strcat(d, s); }
57static void proto_x(char *d, const char *x, unsigned char y) { while (*d) d++; sprintf(d, x, y); }
58#define PROTO_S(x)      if (adap->dstr) proto_s(adap->dstr, x)
59#define PROTO_B(x)      if ((adap->dstr) && (i2c_debug>=BIT_LEVEL)) proto_s(adap->dstr, x)
60#define PROTO_X(x,y)    if (adap->dstr) proto_x(adap->dstr, x, y)
61
62#define PROTO_MAX_DUMP 1024  // 50 x ".oooooooo [xx] .i[xx]"
63
64/* ----- global variables --------------------------------------------- */
65
66/* module parameters:
67 */
68static int i2c_debug; 
69static int bit_test;    /* see if the line-setting functions work       */
70
71/* Bus timing for 50/50 duty cycle :  T_setup + T_hold = T_scllo = T_sclhi */
72/* Run setscl/setsda with a special flag */
73#define T_min   0               /* after any SCL SDA change     */
74#define T_sclhi _HS_DBL_DT      /* SCL high                     */
75#define T_scllo _HS_DBL_DT      /* SCL low                      */
76#define T_setup 0               /* SDA change to SCL rise       */
77#define T_hold  0               /* SCL fall to SDA change       */
78
79#define _sf(a)          adap->ctrl|=(a)
80#define _cf(a)          adap->ctrl&=~(a)
81#define ___setscl(b)    if (b) _sf(_HS_SCL); else _cf(_HS_SCL); i2c_setscl(adap)
82#define ___setsda(b)    if (b) _sf(_HS_SDA); else _cf(_HS_SDA); i2c_setsda(adap)
83
84#define __setdt(x,dt)   if (dt) _sf(dt); x; if (dt) _cf(dt)
85#define __setscl(b,dt)  __setdt(___setscl(b),dt)
86#define __setsda(b,dt)  __setdt(___setsda(b),dt)
87#define __getscl()      i2c_getscl(adap)
88#define __getsda()      i2c_getsda(adap)
89
90#define RETURN_ON_FAILURE(x)            x; if (adap->errors) return
91#define TRY(x) RETURN_ON_FAILURE(x)
92
93#define _setscl(b,dt)   RETURN_ON_FAILURE(__setscl(b,dt))
94#define _setsda(b,dt)   RETURN_ON_FAILURE(__setsda(b,dt))
95#define _getscl         __getscl
96#define _getsda         __getsda
97
98#define _sclhi(dt)      _setscl(1,dt)
99#define _scllo(dt)      _setscl(0,dt)
100#define _sdahi(dt)      _setsda(1,dt)
101#define _sdalo(dt)      _setsda(0,dt)
102
103/* --- setting states on the bus with the right timing: --------------- */
104
105static int i2c_sda_set(struct i2c_algo_biths_data *adap, int rdcount)
106{
107    int sda;
108    /* allow some rise/fall time */
109    while ( rdcount-- ) {
110        sda = adap->getsda(adap->hw_data);
111        if (adap->ctrl & _HS_SDA) {
112            if (sda)
113                return 0;
114            if (!rdcount) {
115                adap->errors |= _HS_SDA_ARB;
116                return -1;
117            }
118        } else { /* !(adap->ctrl & _HS_SDA) */
119            if (!sda)
120                return 0;
121            if (!rdcount) {
122                adap->errors |= _HS_HW_FAIL;
123                return -1;
124            }
125        }
126    }
127    return 0;
128}
129
130static void i2c_setsda(struct i2c_algo_biths_data *adap)
131{
132    adap->setstate(adap); 
133    adap->setsda(adap->hw_data, adap->hw_state);
134    if ( !(adap->ctrl & _HS_SDA_FREE) && ! i2c_sda_set(adap, 10)) {
135        return;
136    }
137    adap->set_timer(adap);
138    adap->run_timer(adap);
139}
140
141static int i2c_getscl(struct i2c_algo_biths_data *adap)
142{
143    return adap->getscl(adap->hw_data);
144}
145
146static int i2c_getsda(struct i2c_algo_biths_data *adap)
147{
148    return adap->getsda(adap->hw_data);
149}
150/*
151 * Raise scl line, and do check for delays. This is necessary for slower
152 * devices.
153 */
154
155static void i2c_setscl(struct i2c_algo_biths_data *adap)
156{
157#ifndef HW_CANNOT_READ_SCL /* Not all adapters have scl sense line... */
158    int rdcount = 10;
159    adap->setstate(adap);
160    adap->setscl(adap->hw_data, adap->hw_state);
161    if (adap->ctrl & _HS_SCL) {
162        unsigned long start;
163        /* allow some rise time */
164        while (rdcount && !adap->getscl(adap->hw_data)) rdcount--;
165        /* else clock synchronisation, give more time */
166        start = jiffies;
167        while (!rdcount && !adap->getscl(adap->hw_data)) {
168            if ( time_after(jiffies, start+adap->timeout) ) {
169                adap->errors |= _HS_TIMEOUT; /* scl undef */
170                return;
171            }
172            cond_resched();
173        }
174        adap->set_timer(adap);
175        /* test for SDA arbitration when SCL is high */
176        if ( !(adap->ctrl & _HS_SDA_FREE) && ! i2c_sda_set(adap, 1)) {
177            return;
178        }
179    } else {
180        /* allow some fall time */
181        while (rdcount && adap->getscl(adap->hw_data)) rdcount--;
182        if ( !rdcount ) {
183            adap->errors |= _HS_HW_FAIL;
184            return;
185        }
186        adap->set_timer(adap);
187    }
188#else
189    adap->setstate(adap);
190    adap->setscl(adap->hw_data, adap->hw_state);
191    adap->set_timer(adap);
192#endif /* HW_CANNOT_READ_SCL */
193    adap->run_timer(adap);
194}
195
196
197/* start, repstart */
198static void i2c_start(struct i2c_algo_biths_data *adap)
199{
200        PROTO_S("S");
201        /* assert: scl, sda undef */
202        adap->errors = 0;
203        _sdahi(T_setup);
204        _sclhi(T_min);
205        _sdalo(T_min);
206        _scllo(T_hold);
207        /* assert: scl, sda low */
208}
209
210static void i2c_stop(struct i2c_algo_biths_data *adap)
211{
212        PROTO_S(" P");
213        /* scl undef after error, sda, scl freedom unknown */
214        adap->ctrl &= ~(_HS_SDA_FREE | _HS_DBL_DT);
215        if (adap->errors) {
216            adap->errors = 0;
217            _scllo(T_hold);
218        }
219        /* assert: scl low, sda undef */
220        _sdalo(T_setup);
221        _sclhi(T_min);
222        _sdahi(T_min);
223        /* assert: scl, sda high */
224}
225
226
227static void i2c_outbits(struct i2c_algo_biths_data *adap, int i) 
228{
229        /* assert: scl is low */
230        PROTO_B(".");
231        while  (i--) {
232            PROTO_B("o");
233            _setsda(adap->shiftreg & 0x80, T_setup);
234            _sclhi(T_sclhi);
235            _scllo(T_hold);
236            adap->shiftreg<<=1;
237        }
238        /* assert: scl is low */
239}
240
241static void i2c_inbits(struct i2c_algo_biths_data *adap, int i)
242{
243        /* assert: scl is low, sda undef */
244        adap->ctrl |= _HS_SDA_FREE;
245        PROTO_B(".");
246        while  (i--) {
247            PROTO_B("i");
248            _sdahi(T_setup); 
249            _sclhi(T_sclhi);   
250            adap->shiftreg<<=1;
251            if (_getsda())
252                adap->shiftreg |= 0x01;
253            _scllo(T_hold);
254        }
255        adap->ctrl &= ~_HS_SDA_FREE;
256        /* assert: scl is low */
257}
258
259static void i2c_outb(struct i2c_algo_biths_data *adap, unsigned short flags,
260                     char *buf, int *count) 
261{
262        while (*count) {
263            adap->shiftreg = *buf;
264            TRY(i2c_outbits(adap, 8));
265            PROTO_X(" %02X ", *buf);
266            buf++;
267           
268            /* read ack: SDA should be pulled down by slave */
269            TRY(i2c_inbits(adap, 1));
270           
271            if (! (adap->shiftreg & 0x01)) { 
272                PROTO_S("[A]");
273            } else if (flags & I2C_M_IGNORE_NAK) {
274                PROTO_S("[NA]");
275            } else {
276                PROTO_S("[NA]");
277                adap->errors |= _HS_NAK;
278            }
279            if (adap->errors) return;
280            (*count)--;
281        }
282}
283
284static void i2c_inb(struct i2c_algo_biths_data *adap, unsigned short flags,
285                    char *buf, int *count) 
286{
287        while (*count) {
288            TRY(i2c_inbits(adap, 8));
289            *buf = adap->shiftreg;
290            PROTO_X(" [%02X] ", *buf);
291            buf++;
292           
293            if (! (flags & I2C_M_NO_RD_ACK)) {
294                if (*count == 1) /* was last */
295                    adap->shiftreg = 0x80;
296                else
297                    adap->shiftreg = 0x00;
298                TRY(i2c_outbits(adap,1));
299
300                if (*count == 1) {
301                    PROTO_S("NA");
302                } else {
303                    PROTO_S("A");
304                }
305            }
306            (*count)--;
307        }
308}
309
310
311static void debug_protocol(struct i2c_algo_biths_data *adap, int retval)
312{
313    if (! adap->dstr) return;
314
315    if ( ((retval<0) && (i2c_debug>=FATAL_PROTOCOL)) || 
316         (i2c_debug>=ALL_PROTOCOL) ) {
317        printk(KERN_DEBUG "i2c-algo-biths.o: %s: %s\n", adap->name, adap->dstr); 
318    }
319    *adap->dstr = 0;
320}
321
322static const char * i2c_strerr(int retval)
323{ 
324    switch (retval) {
325        case 2:
326            return "ack";
327               
328        case 1:
329            return "no ack (ignored)";
330
331        case 0:
332            return "not reached";
333
334        case -EREMOTEIO:
335            return "no ack";
336
337        case -ETIMEDOUT:
338            return "SCL rise timeout";
339         
340        case -ECOMM:
341            return "SDA arbitration";
342
343        case -ENODEV:
344            return "SCL/SDA failure";
345
346        default:
347            return "unknown";
348    }
349}
350
351static int errflag(int flags)
352{
353    if (! flags)
354        return 2;
355    if (flags & _HS_HW_FAIL)
356        return -ENODEV;
357    if (flags & _HS_SDA_ARB)
358        return -ECOMM;
359    if (flags & _HS_TIMEOUT)
360        return -ETIMEDOUT;
361    if (flags & _HS_NAK)
362        return -EREMOTEIO;
363
364    return -1;
365}
366
367static void debug_printout(struct i2c_adapter *i2c_adap, int num, int retval)
368{ 
369    if ( ((retval<0) && (i2c_debug>=FATAL_MSG)) ||
370         (i2c_debug>=ALL_MSG) ) {
371        printk(KERN_ERR "i2c-algo-biths.o: %s: msg #%d %s\n", i2c_adap->name, num, i2c_strerr(retval));
372    }
373}
374
375/*
376 * Sanity check for the adapter hardware
377 */
378static int test_bus(struct i2c_algo_biths_data *adap)
379{
380
381    int sscl, ssda, gscl, gsda, i=0;
382    int errors;
383    int test[][2] = {{1,1}, {0,1}, {1,1}, {1,0}, {1,1}, {-1,-1}}; // SDA, SCL pair
384
385    printk(KERN_INFO "i2c-algo-biths.o: %s bus test\n", adap->name);
386
387    while ( test[i][0]!=-1 ) {
388        ssda = test[i][0];
389        sscl = test[i][1];
390
391        adap->errors = 0;
392        __setsda(ssda, T_min);
393        gsda = __getsda() ? 1 : 0;
394        errors = adap->errors & (_HS_HW_FAIL | _HS_SDA_ARB);
395        if (errors)
396            printk(KERN_WARNING "i2c-algo-biths.o: %s %s\n", adap->name,
397                   i2c_strerr(errflag(errors)));
398           
399        __setscl(sscl, T_min);
400        gscl = __getscl() ? 1 : 0;
401        errors = adap->errors & (_HS_HW_FAIL | _HS_TIMEOUT);
402        if (errors)
403            printk(KERN_WARNING "i2c-algo-biths.o: %s %s\n", adap->name,
404                   i2c_strerr(errflag(errors)));
405
406        printk(KERN_DEBUG "i2c-algo-biths.o: %s SCL: %d  SDA: %d\n", adap->name, gscl, gsda);
407        if ( sscl!=gscl )
408            printk(KERN_WARNING "i2c-algo-biths.o: %s SCL set %d, got %d!\n", adap->name, sscl, gscl);
409        if ( ssda!=gsda )
410            printk(KERN_WARNING "i2c-algo-biths.o: %s SDA set %d, got %d!\n", adap->name, ssda, gsda);
411        if ( (adap->errors) || sscl!=gscl || ssda!=gsda )
412            break;
413        i++;
414    }
415   
416    __setsda(1,0);
417    __setscl(1,0);
418    adap->errors = 0;
419
420    if (test[i][0]==-1) {
421        printk(KERN_INFO "i2c-algo-biths.o: %s passed bus test.\n",adap->name);
422        return 0;
423    } else {
424        printk(KERN_INFO "i2c-algo-biths.o: %s failed bus test.\n",adap->name);
425        return -ENODEV;
426    }
427}
428
429
430/* doAddress transmits the address in the necessary format to handle
431 * reads, writes as well as 10bit-addresses.
432 */
433
434static void doAddress(struct i2c_algo_biths_data *adap, struct i2c_msg *msg) 
435{
436        unsigned char addr[2];
437        int count;
438
439        if ( msg->flags & I2C_M_TEN ) { 
440                /* a ten bit address */
441                count = 2;
442                addr[0] = 0xf0 | (( msg->addr >> 7) & 0x03);
443                addr[1] = msg->addr & 0x7f;
444
445                /* try extended address code ... and the remaining 8 bit address */
446                TRY(i2c_outb(adap, msg->flags, addr, &count));
447
448                if ( msg->flags & I2C_M_RD ) {
449                        TRY(i2c_start(adap));
450                       
451                        /* okay, now switch into reading mode */
452                        count = 1;
453                        addr[0] |= 0x01;
454                        TRY(i2c_outb(adap, msg->flags, addr, &count));
455                }
456        } else {                /* normal 7bit address  */
457                count = 1;
458                addr[0] = ( msg->addr << 1 );
459                if (msg->flags & I2C_M_RD )
460                        addr[0] |= 1;
461                if (msg->flags & I2C_M_REV_DIR_ADDR )
462                        addr[0] ^= 1;
463                TRY(i2c_outb(adap, msg->flags, addr, &count));
464        }
465}
466
467/*
468 * return values:
469 * 1 ACK
470 * 0 IGNORED client NAK
471 * -EREMOTEIO  client NAK
472 * -ETIMEDOUT  from sclhi()
473 */
474
475
476static int bit_xfer(struct i2c_adapter *i2c_adap,
477                    struct i2c_msg msgs[], int num)
478{
479        struct i2c_msg *msg = msgs;
480        struct i2c_algo_biths_data *adap = i2c_adap->algo_data;
481        int mn, j, state;
482        enum { MSG_INIT, MSG_START, MSG_ADDRESS, MSG_DATA, MSG_READY, MSG_STOP, MSG_EXIT };
483
484        state = MSG_INIT;
485        mn=0;
486
487        adap->dstr=NULL;
488        if (i2c_debug>=FATAL_PROTOCOL) {
489            adap->dstr = kmalloc(PROTO_MAX_DUMP, GFP_KERNEL);
490            if (adap->dstr) {
491                *adap->dstr = 0;
492            } else {
493                printk(KERN_DEBUG "i2c-algo-biths.o %s: missing protocol dump (-ENOMEM)\n", adap->name);
494            }
495        }
496
497        for (j=0; j<num; j++) msgs[j].err = 0; // unprocessed
498
499        do switch (state) {
500           
501            case MSG_INIT:
502                msg = &msgs[mn];
503                if ((msg->flags & I2C_M_NOSTART) && (mn)) {
504                    state = MSG_DATA;
505                    break;
506                }
507
508            case MSG_START:     
509                i2c_start(adap);
510                if (adap->errors) {
511                    state = MSG_STOP;   
512                    break;
513                }       
514                   
515            case MSG_ADDRESS:
516                doAddress(adap, msg);
517                if (adap->errors) {
518                    state = MSG_STOP;
519                    break;
520                }
521
522            case MSG_DATA:
523                j = msg->len;
524                if ( msg->flags & I2C_M_RD ) {
525                    i2c_inb(adap, msg->flags, msg->buf, &j);
526                } else {
527                    i2c_outb(adap, msg->flags, msg->buf, &j);
528                }
529                msg->done = msg->len - j;
530                if (adap->errors) {
531                    state = MSG_STOP;
532                    break;
533                }
534       
535            case MSG_READY:
536                mn++;
537                if (mn<num) {
538                    msg->err = errflag(adap->errors);
539                    debug_protocol(adap, msg->err);
540                    state = MSG_INIT;
541                    break;
542                }
543
544            case MSG_STOP:
545                msg->err = errflag(adap->errors);
546                i2c_stop(adap);
547                j = 0;
548                while (adap->errors) {
549                    if ( ++j > 10) {
550                        msg->err = -ENODEV;
551                        break;
552                    }
553                    i2c_stop(adap);
554                }
555                debug_protocol(adap, msg->err);
556                state = MSG_EXIT;
557                break;
558
559            default: /* not reached */
560                state = MSG_EXIT;
561                msg->err = -EINVAL;
562                break;
563                                 
564        } while (state != MSG_EXIT);
565       
566        if (adap->dstr) kfree(adap->dstr);
567
568        for (j=0; j<num; j++)
569            debug_printout(i2c_adap, j, msgs[j].err);
570
571        return (msg->err < 0) ? msg->err : mn;
572}
573
574static int algo_control(struct i2c_adapter *i2c_adap, 
575        unsigned int cmd, unsigned long arg)
576{
577        return 0;
578}
579
580static u32 bit_func(struct i2c_adapter *i2c_adap)
581{
582        return I2C_FUNC_SMBUS_EMUL | I2C_FUNC_10BIT_ADDR | 
583               I2C_FUNC_PROTOCOL_MANGLING;
584}
585
586
587/* -----exported algorithm data: -------------------------------------  */
588
589static struct i2c_algorithm i2c_algo_biths = {
590        .name           = "Bit-shift algorithm",
591        .id             = I2C_ALGO_BIT,
592        .master_xfer    = bit_xfer,
593        .algo_control   = algo_control,
594        .functionality  = bit_func,
595};
596
597
598#if ALGO_BIT_COMPATIBILITY
599#include "i2c-algo-bit.h"
600
601static _HS_ATTR_ void _old_setscl(void *hw_data, int hw_state)
602{
603        struct i2c_algo_bit_data *old = hw_data;
604        old->setscl(old->data, hw_state & _HS_SCL);
605}
606static _HS_ATTR_ void _old_setsda(void *hw_data, int hw_state)
607{
608        struct i2c_algo_bit_data *old = hw_data;
609        old->setsda(old->data, hw_state & _HS_SDA);
610}
611static _HS_ATTR_ int _old_getscl(void *hw_data)
612{
613        struct i2c_algo_bit_data *old = hw_data;
614        return old->getscl(old->data);
615}
616static _HS_ATTR_ int _old_getsda(void *hw_data)
617{
618        struct i2c_algo_bit_data *old = hw_data;
619        return old->getsda(old->data);
620}
621
622static _HS_ATTR_ void _old_setstate(struct i2c_algo_biths_data *adap)
623{
624        adap->hw_state = adap->ctrl;
625}
626
627static struct i2c_algo_biths_data _old_template = {
628        .setstate       = _old_setstate,
629        .setsda         = _old_setsda,
630        .setscl         = _old_setscl,
631        .getsda         = _old_getsda,
632        .getscl         = _old_getscl,
633};
634
635/*
636 * registering functions to load algorithms at runtime
637 */
638int i2c_bit_add_bus(struct i2c_adapter *i2c_adap)
639{
640        int i;
641        struct i2c_algo_bit_data *old_adap = i2c_adap->algo_data;
642        struct i2c_algo_biths_data *adap;
643
644        adap = kmalloc(sizeof(struct i2c_algo_biths_data), GFP_KERNEL);
645        if (adap==NULL)
646            return -ENOMEM;
647
648        memcpy(adap, &_old_template, sizeof(struct i2c_algo_biths_data));
649        adap->hw_data = old_adap;
650        adap->xloops = old_adap->udelay * 0x0863; /* 1/4 vs 1/2 cycle, 0x10c6 / 2 */
651        adap->timeout = old_adap->timeout;
652        i2c_adap->algo_data = adap;
653
654        return i2c_biths_add_bus(i2c_adap);
655}
656
657
658int i2c_bit_del_bus(struct i2c_adapter *i2c_adap)
659{
660        int res;
661
662        if ((res = i2c_biths_del_bus(i2c_adap)) < 0)
663            return res;
664
665        kfree(i2c_adap->algo_data);
666        return 0;
667}
668
669EXPORT_SYMBOL(i2c_bit_add_bus);
670EXPORT_SYMBOL(i2c_bit_del_bus);
671
672#endif
673
674#ifdef rdtscl
675/* TSC stuff from arch/i386/lib/delay.c */
676
677static _HS_ATTR_ void i2c_tsc_set(struct i2c_algo_biths_data *adap)
678{
679    rdtscl(adap->bclock);
680}
681
682static _HS_ATTR_ void i2c_tsc_run(struct i2c_algo_biths_data *adap)
683{
684    unsigned long now, loops, xloops;
685    int d0;
686    xloops = adap->xloops; 
687    __asm__("mull %0"
688            :"=d" (xloops), "=&a" (d0)
689            :"1" (xloops),"0" (current_cpu_data.loops_per_jiffy));
690    loops = xloops * HZ;
691    do
692    {
693        rep_nop();
694        rdtscl(now);
695    } while ( (now - adap->bclock) < loops );
696}
697
698#else
699
700static _HS_ATTR_ void i2c_udelay_set(struct i2c_algo_biths_data *adap) {}
701
702static _HS_ATTR_ void i2c_udelay_run(struct i2c_algo_biths_data *adap)
703{
704    int usecs;
705    /* adap->xloops = usecs * 0x000010c6 / 2; */
706    usecs = ((adap->xloops + 0x0863) >> 12); 
707    if (adap->ctrl & _HS_DBL_DT)
708        usecs<<=1;
709    udelay(usecs);
710}
711
712#endif /* rdtscl */
713
714
715/*
716 * registering functions to load algorithms at runtime
717 */
718int i2c_biths_add_bus(struct i2c_adapter *i2c_adap)
719{
720        struct i2c_algo_biths_data *adap = i2c_adap->algo_data;
721
722        /* get name */
723        adap->name = i2c_adap->name;
724        adap->dstr = 0; // no protocol dump buffer
725
726        if (adap->set_timer == NULL) {
727#ifdef rdtscl   /* if (x86_udelay_tsc) here instead ? */
728                adap->set_timer = i2c_tsc_set;
729                adap->run_timer = i2c_tsc_run;
730#else
731                adap->set_timer = i2c_udelay_set;
732                adap->run_timer = i2c_udelay_run;
733#endif
734        }
735
736        if (bit_test) {
737            int ret = test_bus(adap);
738            if (ret<0)
739                return ret;
740        }
741
742        DEB1(printk(KERN_DEBUG "i2c-algo-biths.o: hw routines for %s registered.\n",
743                    i2c_adap->name));
744#ifdef rdtscl
745        DEB1(printk(KERN_DEBUG "i2c-algo-biths.o:  ... will use rdtscl() for bus clock\n"));
746#else
747        DEB1(printk(KERN_DEBUG "i2c-algo-biths.o:  ... will use udelay() for bus clock\n"));
748#endif
749       
750        /* register new adapter to i2c module... */
751
752        i2c_adap->id |= i2c_algo_biths.id;
753        i2c_adap->algo = &i2c_algo_biths;
754
755        i2c_adap->timeout = HZ; /* default values, should       */
756        i2c_adap->retries = 3;  /* be replaced by defines       */
757
758        i2c_add_adapter(i2c_adap);
759
760        return 0;
761}
762
763
764int i2c_biths_del_bus(struct i2c_adapter *i2c_adap)
765{
766        int res;
767
768        if ((res = i2c_del_adapter(i2c_adap)) < 0)
769                return res;
770
771        DEB1(printk(KERN_DEBUG "i2c-algo-biths.o: adapter unregistered: %s\n",i2c_adap->name));
772
773        return 0;
774}
775
776EXPORT_SYMBOL(i2c_biths_add_bus);
777EXPORT_SYMBOL(i2c_biths_del_bus);
778
779MODULE_AUTHOR("Kyösti Mälkki <kmalkki@cc.hut.fi>");
780MODULE_DESCRIPTION("I2C-Bus bit-banging algorithm");
781MODULE_LICENSE("GPL");
782
783MODULE_PARM(bit_test, "i");
784MODULE_PARM(i2c_debug,"i");
785
786MODULE_PARM_DESC(bit_test, "Test the lines of the bus to see if it is stuck");
787MODULE_PARM_DESC(i2c_debug,
788            "debug level - 1 use; 2 fatal, 3 +proto; 4 all, 5 +proto");
Note: See TracBrowser for help on using the browser.