drivers/i2c/i2c-algo-bit.c

   1 /* ------------------------------------------------------------------------- */
   2 /* i2c-algo-bit.c i2c driver algorithms for bit-shift adapters               */
   3 /* ------------------------------------------------------------------------- */
   4 /*   Copyright (C) 1995-2000 Simon G. Vogl
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                */
  19 /* ------------------------------------------------------------------------- */
  20
  21 /* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and even
  22    Frodo Looijaard <frodol@dds.nl> */
  23
  24 /* $Id: i2c-algo-bit.c,v 1.1.1.1 2005/04/11 02:50:21 jack Exp $ */
  25
  26 #include <linux/kernel.h>
  27 #include <linux/module.h>
  28 #include <linux/delay.h>
  29 #include <linux/slab.h>
  30 #include <linux/version.h>
  31 #include <linux/init.h>
  32 #include <asm/uaccess.h>
  33 #include <linux/ioport.h>
  34 #include <linux/errno.h>
  35 #include <linux/sched.h>
  36
  37 #include <linux/i2c.h>
  38 #include <linux/i2c-algo-bit.h>
  39
  40 /* ----- global defines ----------------------------------------------- */
  41 #define DEB(x) if (i2c_debug>=1) x;
  42 #define DEB2(x) if (i2c_debug>=2) x;
  43 #define DEBSTAT(x) if (i2c_debug>=3) x; /* print several statistical values*/
  44 #define DEBPROTO(x) if (i2c_debug>=9) { x; }
  45         /* debug the protocol by showing transferred bits */
  46
  47 /* debugging - slow down transfer to have a look at the data ..         */
  48 /* I use this with two leds&resistors, each one connected to sda,scl    */
  49 /* respectively. This makes sure that the algorithm works. Some chips   */
  50 /* might not like this, as they have an internal timeout of some mils   */
  51 /*
  52 #define SLO_IO      jif=jiffies;while(time_before_eq(jiffies, jif+i2c_table[minor].veryslow))\
  53                         if (need_resched) schedule();
  54 */
  55
  56
  57 /* ----- global variables --------------------------------------------- */
  58
  59 #ifdef SLO_IO
  60         int jif;
  61 #endif
  62
  63 /* module parameters:
  64  */
  65 static int i2c_debug;
  66 static int bit_test;    /* see if the line-setting functions work       */
  67 static int bit_scan;    /* have a look at what's hanging 'round         */
  68
  69 /* --- setting states on the bus with the right timing: --------------- */
  70
  71 #define setsda(adap,val) adap->setsda(adap->data, val)
  72 #define setscl(adap,val) adap->setscl(adap->data, val)
  73 #define getsda(adap) adap->getsda(adap->data)
  74 #define getscl(adap) adap->getscl(adap->data)
  75
  76 static inline void sdalo(struct i2c_algo_bit_data *adap)
  77 {
  78         setsda(adap,0);
  79         udelay(adap->udelay);
  80 }
  81
  82 static inline void sdahi(struct i2c_algo_bit_data *adap)
  83 {
  84         setsda(adap,1);
  85         udelay(adap->udelay);
  86 }
  87
  88 static inline void scllo(struct i2c_algo_bit_data *adap)
  89 {
  90         setscl(adap,0);
  91         udelay(adap->udelay);
  92 #ifdef SLO_IO
  93         SLO_IO
  94 #endif
  95 }
  96
  97 /*
  98  * Raise scl line, and do checking for delays. This is necessary for slower
  99  * devices.
 100  */
 101 static inline int sclhi(struct i2c_algo_bit_data *adap)
 102 {
 103         int start=jiffies;
 104
 105         setscl(adap,1);
 106
 107         udelay(adap->udelay);
 108
 109         /* Not all adapters have scl sense line... */
 110         if (adap->getscl == NULL )
 111                 return 0;
 112
 113         while (! getscl(adap) ) {
 114                 /* the hw knows how to read the clock line,
 115                  * so we wait until it actually gets high.
 116                  * This is safer as some chips may hold it low
 117                  * while they are processing data internally.
 118                  */
 119                 setscl(adap,1);
 120                 if (time_after_eq(jiffies, start+adap->timeout)) {
 121                         return -ETIMEDOUT;
 122                 }
 123                 if (current->need_resched)
 124                         schedule();
 125         }
 126         DEBSTAT(printk("needed %ld jiffies\n", jiffies-start));
 127 #ifdef SLO_IO
 128         SLO_IO
 129 #endif
 130         return 0;
 131 }
 132
 133
 134 /* --- other auxiliary functions -------------------------------------- */
 135 static void i2c_start(struct i2c_algo_bit_data *adap)
 136 {
 137         /* assert: scl, sda are high */
 138         DEBPROTO(printk("S "));
 139         sdalo(adap);
 140         scllo(adap);
 141 }
 142
 143 static void i2c_repstart(struct i2c_algo_bit_data *adap)
 144 {
 145         /* scl, sda may not be high */
 146         DEBPROTO(printk(" Sr "));
 147         setsda(adap,1);
 148         setscl(adap,1);
 149         udelay(adap->udelay);
 150
 151         sdalo(adap);
 152         scllo(adap);
 153 }
 154
 155
 156 static void i2c_stop(struct i2c_algo_bit_data *adap)
 157 {
 158         DEBPROTO(printk("P\n"));
 159         /* assert: scl is low */
 160         sdalo(adap);
 161         sclhi(adap);
 162         sdahi(adap);
 163 }
 164
 165
 166
 167 /* send a byte without start cond., look for arbitration,
 168    check ackn. from slave */
 169 /* returns:
 170  * 1 if the device acknowledged
 171  * 0 if the device did not ack
 172  * -ETIMEDOUT if an error occurred (while raising the scl line)
 173  */
 174 static int i2c_outb(struct i2c_adapter *i2c_adap, char c)
 175 {
 176         int i;
 177         int sb;
 178         int ack;
 179         struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
 180
 181         /* assert: scl is low */
 182         DEB2(printk(" i2c_outb:%2.2X\n",c&0xff));
 183         for ( i=7 ; i>=0 ; i-- ) {
 184                 sb = c & ( 1 << i );
 185                 setsda(adap,sb);
 186                 udelay(adap->udelay);
 187                 DEBPROTO(printk("%d",sb!=0));
 188                 if (sclhi(adap)<0) { /* timed out */
 189                         sdahi(adap); /* we don't want to block the net */
 190                         return -ETIMEDOUT;
 191                 };
 192                 /* do arbitration here:
 193                  * if ( sb && ! getsda(adap) ) -> ouch! Get out of here.
 194                  */
 195                 setscl(adap, 0 );
 196                 udelay(adap->udelay);
 197         }
 198         sdahi(adap);
 199         if (sclhi(adap)<0){ /* timeout */
 200                 return -ETIMEDOUT;
 201         };
 202         /* read ack: SDA should be pulled down by slave */
 203         ack=getsda(adap);       /* ack: sda is pulled low ->success.     */
 204         DEB2(printk(" i2c_outb: getsda() =  0x%2.2x\n", ~ack ));
 205
 206         DEBPROTO( printk("[%2.2x]",c&0xff) );
 207         DEBPROTO(if (0==ack){ printk(" A ");} else printk(" NA ") );
 208         scllo(adap);
 209         return 0==ack;          /* return 1 if device acked      */
 210         /* assert: scl is low (sda undef) */
 211 }
 212
 213
 214 static int i2c_inb(struct i2c_adapter *i2c_adap)
 215 {
 216         /* read byte via i2c port, without start/stop sequence  */
 217         /* acknowledge is sent in i2c_read.                     */
 218         int i;
 219         unsigned char indata=0;
 220         struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
 221
 222         /* assert: scl is low */
 223         DEB2(printk("i2c_inb.\n"));
 224
 225         sdahi(adap);
 226         for (i=0;i<8;i++) {
 227                 if (sclhi(adap)<0) { /* timeout */
 228                         return -ETIMEDOUT;
 229                 };
 230                 indata *= 2;
 231                 if ( getsda(adap) )
 232                         indata |= 0x01;
 233                 scllo(adap);
 234         }
 235         /* assert: scl is low */
 236         DEBPROTO(printk(" %2.2x", indata & 0xff));
 237         return (int) (indata & 0xff);
 238 }
 239
 240 /*
 241  * Sanity check for the adapter hardware - check the reaction of
 242  * the bus lines only if it seems to be idle.
 243  */
 244 static int test_bus(struct i2c_algo_bit_data *adap, char* name) {
 245         int scl,sda;
 246         sda=getsda(adap);
 247         if (adap->getscl==NULL) {
 248                 printk("i2c-algo-bit.o: Warning: Adapter can't read from clock line - skipping test.\n");
 249                 return 0;
 250         }
 251         scl=getscl(adap);
 252         printk("i2c-algo-bit.o: Adapter: %s scl: %d  sda: %d -- testing...\n",
 253                name,getscl(adap),getsda(adap));
 254         if (!scl || !sda ) {
 255                 printk("i2c-algo-bit.o: %s seems to be busy.\n",name);
 256                 goto bailout;
 257         }
 258         sdalo(adap);
 259         printk("i2c-algo-bit.o:1 scl: %d  sda: %d \n",getscl(adap),
 260                getsda(adap));
 261         if ( 0 != getsda(adap) ) {
 262                 printk("i2c-algo-bit.o: %s SDA stuck high!\n",name);
 263                 sdahi(adap);
 264                 goto bailout;
 265         }
 266         if ( 0 == getscl(adap) ) {
 267                 printk("i2c-algo-bit.o: %s SCL unexpected low while pulling SDA low!\n",
 268                         name);
 269                 goto bailout;
 270         }
 271         sdahi(adap);
 272         printk("i2c-algo-bit.o:2 scl: %d  sda: %d \n",getscl(adap),
 273                getsda(adap));
 274         if ( 0 == getsda(adap) ) {
 275                 printk("i2c-algo-bit.o: %s SDA stuck low!\n",name);
 276                 sdahi(adap);
 277                 goto bailout;
 278         }
 279         if ( 0 == getscl(adap) ) {
 280                 printk("i2c-algo-bit.o: %s SCL unexpected low while SDA high!\n",
 281                        name);
 282         goto bailout;
 283         }
 284         scllo(adap);
 285         printk("i2c-algo-bit.o:3 scl: %d  sda: %d \n",getscl(adap),
 286                getsda(adap));
 287         if ( 0 != getscl(adap) ) {
 288                 printk("i2c-algo-bit.o: %s SCL stuck high!\n",name);
 289                 sclhi(adap);
 290                 goto bailout;
 291         }
 292         if ( 0 == getsda(adap) ) {
 293                 printk("i2c-algo-bit.o: %s SDA unexpected low while pulling SCL low!\n",
 294                         name);
 295                 goto bailout;
 296         }
 297         sclhi(adap);
 298         printk("i2c-algo-bit.o:4 scl: %d  sda: %d \n",getscl(adap),
 299                getsda(adap));
 300         if ( 0 == getscl(adap) ) {
 301                 printk("i2c-algo-bit.o: %s SCL stuck low!\n",name);
 302                 sclhi(adap);
 303                 goto bailout;
 304         }
 305         if ( 0 == getsda(adap) ) {
 306                 printk("i2c-algo-bit.o: %s SDA unexpected low while SCL high!\n",
 307                         name);
 308                 goto bailout;
 309         }
 310         printk("i2c-algo-bit.o: %s passed test.\n",name);
 311         return 0;
 312 bailout:
 313         sdahi(adap);
 314         sclhi(adap);
 315         return -ENODEV;
 316 }
 317
 318 /* ----- Utility functions
 319  */
 320
 321 /* try_address tries to contact a chip for a number of
 322  * times before it gives up.
 323  * return values:
 324  * 1 chip answered
 325  * 0 chip did not answer
 326  * -x transmission error
 327  */
 328 static inline int try_address(struct i2c_adapter *i2c_adap,
 329                        unsigned char addr, int retries)
 330 {
 331         struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
 332         int i,ret = -1;
 333         for (i=0;i<=retries;i++) {
 334                 ret = i2c_outb(i2c_adap,addr);
 335                 if (ret==1)
 336                         break;  /* success! */
 337                 i2c_stop(adap);
 338                 udelay(5/*adap->udelay*/);
 339                 if (i==retries)  /* no success */
 340                         break;
 341                 i2c_start(adap);
 342                 udelay(adap->udelay);
 343         }
 344         DEB2(if (i) printk("i2c-algo-bit.o: needed %d retries for %d\n",
 345                            i,addr));
 346         return ret;
 347 }
 348
 349 static int sendbytes(struct i2c_adapter *i2c_adap,const char *buf, int count)
 350 {
 351         struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
 352         char c;
 353         const char *temp = buf;
 354         int retval;
 355         int wrcount=0;
 356
 357         while (count > 0) {
 358                 c = *temp;
 359                 DEB2(printk("i2c-algo-bit.o: %s i2c_write: writing %2.2X\n",
 360                             i2c_adap->name, c&0xff));
 361                 retval = i2c_outb(i2c_adap,c);
 362                 if (retval>0) {
 363                         count--;
 364                         temp++;
 365                         wrcount++;
 366                 } else { /* arbitration or no acknowledge */
 367                         printk("i2c-algo-bit.o: %s i2c_write: error - bailout.\n",
 368                                i2c_adap->name);
 369                         i2c_stop(adap);
 370                         return (retval<0)? retval : -EFAULT;
 371                                 /* got a better one ?? */
 372                 }
 373 #if 0
 374                 /* from asm/delay.h */
 375                 __delay(adap->mdelay * (loops_per_sec / 1000) );
 376 #endif
 377         }
 378         return wrcount;
 379 }
 380
 381 static inline int readbytes(struct i2c_adapter *i2c_adap,char *buf,int count)
 382 {
 383         char *temp = buf;
 384         int inval;
 385         int rdcount=0;          /* counts bytes read */
 386         struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
 387
 388         while (count > 0) {
 389                 inval = i2c_inb(i2c_adap);
 390 /*printk("%#02x ",inval); if ( ! (count % 16) ) printk("\n"); */
 391                 if (inval>=0) {
 392                         *temp = inval;
 393                         rdcount++;
 394                 } else {   /* read timed out */
 395                         printk("i2c-algo-bit.o: i2c_read: i2c_inb timed out.\n");
 396                         break;
 397                 }
 398
 399                 if ( count > 1 ) {              /* send ack */
 400                         sdalo(adap);
 401                         DEBPROTO(printk(" Am "));
 402                 } else {
 403                         sdahi(adap);    /* neg. ack on last byte */
 404                         DEBPROTO(printk(" NAm "));
 405                 }
 406                 if (sclhi(adap)<0) {    /* timeout */
 407                         sdahi(adap);
 408                         printk("i2c-algo-bit.o: i2c_read: Timeout at ack\n");
 409                         return -ETIMEDOUT;
 410                 };
 411                 scllo(adap);
 412                 sdahi(adap);
 413                 temp++;
 414                 count--;
 415         }
 416         return rdcount;
 417 }
 418
 419 /* doAddress initiates the transfer by generating the start condition (in
 420  * try_address) and transmits the address in the necessary format to handle
 421  * reads, writes as well as 10bit-addresses.
 422  * returns:
 423  *  0 everything went okay, the chip ack'ed
 424  * -x an error occurred (like: -EREMOTEIO if the device did not answer, or
 425  *      -ETIMEDOUT, for example if the lines are stuck...)
 426  */
 427 static inline int bit_doAddress(struct i2c_adapter *i2c_adap,
 428                                 struct i2c_msg *msg, int retries)
 429 {
 430         unsigned short flags = msg->flags;
 431         struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
 432
 433         unsigned char addr;
 434         int ret;
 435         if ( (flags & I2C_M_TEN)  ) {
 436                 /* a ten bit address */
 437                 addr = 0xf0 | (( msg->addr >> 7) & 0x03);
 438                 DEB2(printk("addr0: %d\n",addr));
 439                 /* try extended address code...*/
 440                 ret = try_address(i2c_adap, addr, retries);
 441                 if (ret!=1) {
 442                         printk("died at extended address code.\n");
 443                         return -EREMOTEIO;
 444                 }
 445                 /* the remaining 8 bit address */
 446                 ret = i2c_outb(i2c_adap,msg->addr & 0x7f);
 447                 if (ret != 1) {
 448                         /* the chip did not ack / xmission error occurred */
 449                         printk("died at 2nd address code.\n");
 450                         return -EREMOTEIO;
 451                 }
 452                 if ( flags & I2C_M_RD ) {
 453                         i2c_repstart(adap);
 454                         /* okay, now switch into reading mode */
 455                         addr |= 0x01;
 456                         ret = try_address(i2c_adap, addr, retries);
 457                         if (ret!=1) {
 458                                 printk("died at extended address code.\n");
 459                                 return -EREMOTEIO;
 460                         }
 461                 }
 462         } else {                /* normal 7bit address  */
 463                 addr = ( msg->addr << 1 );
 464                 if (flags & I2C_M_RD )
 465                         addr |= 1;
 466                 if (flags & I2C_M_REV_DIR_ADDR )
 467                         addr ^= 1;
 468                 ret = try_address(i2c_adap, addr, retries);
 469                 if (ret!=1) {
 470                         return -EREMOTEIO;
 471                 }
 472         }
 473         return 0;
 474 }
 475
 476 static int bit_xfer(struct i2c_adapter *i2c_adap,
 477                     struct i2c_msg msgs[], int num)
 478 {
 479         struct i2c_msg *pmsg;
 480         struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
 481
 482         int i,ret;
 483
 484         i2c_start(adap);
 485         for (i=0;i<num;i++) {
 486                 pmsg = &msgs[i];
 487                 if (!(pmsg->flags & I2C_M_NOSTART)) {
 488                         if (i) {
 489                                 i2c_repstart(adap);
 490                         }
 491                         ret = bit_doAddress(i2c_adap,pmsg,i2c_adap->retries);
 492                         if (ret != 0) {
 493                                 DEB2(printk("i2c-algo-bit.o: NAK from device adr %#2x msg #%d\n"
 494                                        ,msgs[i].addr,i));
 495                                 return (ret<0) ? ret : -EREMOTEIO;
 496                         }
 497                 }
 498                 if (pmsg->flags & I2C_M_RD ) {
 499                         /* read bytes into buffer*/
 500                         ret = readbytes(i2c_adap,pmsg->buf,pmsg->len);
 501                         DEB2(printk("i2c-algo-bit.o: read %d bytes.\n",ret));
 502                         if (ret < pmsg->len ) {
 503                                 return (ret<0)? ret : -EREMOTEIO;
 504                         }
 505                 } else {
 506                         /* write bytes from buffer */
 507                         ret = sendbytes(i2c_adap,pmsg->buf,pmsg->len);
 508                         DEB2(printk("i2c-algo-bit.o: wrote %d bytes.\n",ret));
 509                         if (ret < pmsg->len ) {
 510                                 return (ret<0) ? ret : -EREMOTEIO;
 511                         }
 512                 }
 513         }
 514         i2c_stop(adap);
 515         return num;
 516 }
 517
 518 static int algo_control(struct i2c_adapter *adapter,
 519         unsigned int cmd, unsigned long arg)
 520 {
 521         return 0;
 522 }
 523
 524 static u32 bit_func(struct i2c_adapter *adap)
 525 {
 526         return I2C_FUNC_SMBUS_EMUL | I2C_FUNC_10BIT_ADDR |
 527                I2C_FUNC_PROTOCOL_MANGLING;
 528 }
 529
 530
 531 /* -----exported algorithm data: -------------------------------------  */
 532
 533 static struct i2c_algorithm i2c_bit_algo = {
 534         "Bit-shift algorithm",
 535         I2C_ALGO_BIT,
 536         bit_xfer,
 537         NULL,
 538         NULL,                           /* slave_xmit           */
 539         NULL,                           /* slave_recv           */
 540         algo_control,                   /* ioctl                */
 541         bit_func,                       /* functionality        */
 542 };
 543
 544 /*
 545  * registering functions to load algorithms at runtime
 546  */
 547 int i2c_bit_add_bus(struct i2c_adapter *adap)
 548 {
 549         int i;
 550         struct i2c_algo_bit_data *bit_adap = adap->algo_data;
 551
 552         if (bit_test) {
 553                 int ret = test_bus(bit_adap, adap->name);
 554                 if (ret<0)
 555                         return -ENODEV;
 556         }
 557
 558         DEB2(printk("i2c-algo-bit.o: hw routines for %s registered.\n",
 559                     adap->name));
 560
 561         /* register new adapter to i2c module... */
 562
 563         adap->id |= i2c_bit_algo.id;
 564         adap->algo = &i2c_bit_algo;
 565
 566         adap->timeout = 100;    /* default values, should       */
 567         adap->retries = 3;      /* be replaced by defines       */
 568
 569         /* scan bus */
 570         if (bit_scan) {
 571                 int ack;
 572                 printk(KERN_INFO " i2c-algo-bit.o: scanning bus %s.\n",
 573                        adap->name);
 574                 for (i = 0x00; i < 0xff; i+=2) {
 575                         i2c_start(bit_adap);
 576                         ack = i2c_outb(adap,i);
 577                         i2c_stop(bit_adap);
 578                         if (ack>0) {
 579                                 printk("(%02x)",i>>1);
 580                         } else
 581                                 printk(".");
 582                 }
 583                 printk("\n");
 584         }
 585
 586 #ifdef MODULE
 587         MOD_INC_USE_COUNT;
 588 #endif
 589         i2c_add_adapter(adap);
 590
 591         return 0;
 592 }
 593
 594
 595 int i2c_bit_del_bus(struct i2c_adapter *adap)
 596 {
 597         int res;
 598
 599         if ((res = i2c_del_adapter(adap)) < 0)
 600                 return res;
 601
 602         DEB2(printk("i2c-algo-bit.o: adapter unregistered: %s\n",adap->name));
 603
 604 #ifdef MODULE
 605         MOD_DEC_USE_COUNT;
 606 #endif
 607         return 0;
 608 }
 609
 610 int __init i2c_algo_bit_init (void)
 611 {
 612         printk("i2c-algo-bit.o: i2c bit algorithm module\n");
 613         return 0;
 614 }
 615
 616
 617
 618 EXPORT_SYMBOL(i2c_bit_add_bus);
 619 EXPORT_SYMBOL(i2c_bit_del_bus);
 620
 621 #ifdef MODULE
 622 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
 623 MODULE_DESCRIPTION("I2C-Bus bit-banging algorithm");
 624 MODULE_LICENSE("GPL");
 625
 626 MODULE_PARM(bit_test, "i");
 627 MODULE_PARM(bit_scan, "i");
 628 MODULE_PARM(i2c_debug,"i");
 629
 630 MODULE_PARM_DESC(bit_test, "Test the lines of the bus to see if it is stuck");
 631 MODULE_PARM_DESC(bit_scan, "Scan for active chips on the bus");
 632 MODULE_PARM_DESC(i2c_debug,
 633             "debug level - 0 off; 1 normal; 2,3 more verbose; 9 bit-protocol");
 634
 635 int init_module(void)
 636 {
 637         return i2c_algo_bit_init();
 638 }
 639
 640 void cleanup_module(void)
 641 {
 642 }
 643 #endif