kernel/drivers/i2c/algos/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
  17 /* With some changes from Frodo Looijaard <frodol@dds.nl>, Kyösti Mälkki
  18    <kmalkki@cc.hut.fi> and Jean Delvare <jdelvare@suse.de> */
  19
  20 #include <linux/kernel.h>
  21 #include <linux/module.h>
  22 #include <linux/delay.h>
  23 #include <linux/errno.h>
  24 #include <linux/sched.h>
  25 #include <linux/i2c.h>
  26 #include <linux/i2c-algo-bit.h>
  27
  28
  29 /* ----- global defines ----------------------------------------------- */
  30
  31 #ifdef DEBUG
  32 #define bit_dbg(level, dev, format, args...) \
  33         do { \
  34                 if (i2c_debug >= level) \
  35                         dev_dbg(dev, format, ##args); \
  36         } while (0)
  37 #else
  38 #define bit_dbg(level, dev, format, args...) \
  39         do {} while (0)
  40 #endif /* DEBUG */
  41
  42 /* ----- global variables --------------------------------------------- */
  43
  44 static int bit_test;    /* see if the line-setting functions work       */
  45 module_param(bit_test, int, S_IRUGO);
  46 MODULE_PARM_DESC(bit_test, "lines testing - 0 off; 1 report; 2 fail if stuck");
  47
  48 #ifdef DEBUG
  49 static int i2c_debug = 1;
  50 module_param(i2c_debug, int, S_IRUGO | S_IWUSR);
  51 MODULE_PARM_DESC(i2c_debug,
  52                  "debug level - 0 off; 1 normal; 2 verbose; 3 very verbose");
  53 #endif
  54
  55 /* --- setting states on the bus with the right timing: --------------- */
  56
  57 #define setsda(adap, val)       adap->setsda(adap->data, val)
  58 #define setscl(adap, val)       adap->setscl(adap->data, val)
  59 #define getsda(adap)            adap->getsda(adap->data)
  60 #define getscl(adap)            adap->getscl(adap->data)
  61
  62 static inline void sdalo(struct i2c_algo_bit_data *adap)
  63 {
  64         setsda(adap, 0);
  65         udelay((adap->udelay + 1) / 2);
  66 }
  67
  68 static inline void sdahi(struct i2c_algo_bit_data *adap)
  69 {
  70         setsda(adap, 1);
  71         udelay((adap->udelay + 1) / 2);
  72 }
  73
  74 static inline void scllo(struct i2c_algo_bit_data *adap)
  75 {
  76         setscl(adap, 0);
  77         udelay(adap->udelay / 2);
  78 }
  79
  80 /*
  81  * Raise scl line, and do checking for delays. This is necessary for slower
  82  * devices.
  83  */
  84 static int sclhi(struct i2c_algo_bit_data *adap)
  85 {
  86         unsigned long start;
  87
  88         setscl(adap, 1);
  89
  90         /* Not all adapters have scl sense line... */
  91         if (!adap->getscl)
  92                 goto done;
  93
  94         start = jiffies;
  95         while (!getscl(adap)) {
  96                 /* This hw knows how to read the clock line, so we wait
  97                  * until it actually gets high.  This is safer as some
  98                  * chips may hold it low ("clock stretching") while they
  99                  * are processing data internally.
 100                  */
 101                 if (time_after(jiffies, start + adap->timeout)) {
 102                         /* Test one last time, as we may have been preempted
 103                          * between last check and timeout test.
 104                          */
 105                         if (getscl(adap))
 106                                 break;
 107                         return -ETIMEDOUT;
 108                 }
 109                 cpu_relax();
 110         }
 111 #ifdef DEBUG
 112         if (jiffies != start && i2c_debug >= 3)
 113                 pr_debug("i2c-algo-bit: needed %ld jiffies for SCL to go "
 114                          "high\n", jiffies - start);
 115 #endif
 116
 117 done:
 118         udelay(adap->udelay);
 119         return 0;
 120 }
 121
 122
 123 /* --- other auxiliary functions -------------------------------------- */
 124 static void i2c_start(struct i2c_algo_bit_data *adap)
 125 {
 126         /* assert: scl, sda are high */
 127         setsda(adap, 0);
 128         udelay(adap->udelay);
 129         scllo(adap);
 130 }
 131
 132 static void i2c_repstart(struct i2c_algo_bit_data *adap)
 133 {
 134         /* assert: scl is low */
 135         sdahi(adap);
 136         sclhi(adap);
 137         setsda(adap, 0);
 138         udelay(adap->udelay);
 139         scllo(adap);
 140 }
 141
 142
 143 static void i2c_stop(struct i2c_algo_bit_data *adap)
 144 {
 145         /* assert: scl is low */
 146         sdalo(adap);
 147         sclhi(adap);
 148         setsda(adap, 1);
 149         udelay(adap->udelay);
 150 }
 151
 152
 153
 154 /* send a byte without start cond., look for arbitration,
 155    check ackn. from slave */
 156 /* returns:
 157  * 1 if the device acknowledged
 158  * 0 if the device did not ack
 159  * -ETIMEDOUT if an error occurred (while raising the scl line)
 160  */
 161 static int i2c_outb(struct i2c_adapter *i2c_adap, unsigned char c)
 162 {
 163         int i;
 164         int sb;
 165         int ack;
 166         struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
 167
 168         /* assert: scl is low */
 169         for (i = 7; i >= 0; i--) {
 170                 sb = (c >> i) & 1;
 171                 setsda(adap, sb);
 172                 udelay((adap->udelay + 1) / 2);
 173                 if (sclhi(adap) < 0) { /* timed out */
 174                         bit_dbg(1, &i2c_adap->dev, "i2c_outb: 0x%02x, "
 175                                 "timeout at bit #%d\n", (int)c, i);
 176                         return -ETIMEDOUT;
 177                 }
 178                 /* FIXME do arbitration here:
 179                  * if (sb && !getsda(adap)) -> ouch! Get out of here.
 180                  *
 181                  * Report a unique code, so higher level code can retry
 182                  * the whole (combined) message and *NOT* issue STOP.
 183                  */
 184                 scllo(adap);
 185         }
 186         sdahi(adap);
 187         if (sclhi(adap) < 0) { /* timeout */
 188                 bit_dbg(1, &i2c_adap->dev, "i2c_outb: 0x%02x, "
 189                         "timeout at ack\n", (int)c);
 190                 return -ETIMEDOUT;
 191         }
 192
 193         /* read ack: SDA should be pulled down by slave, or it may
 194          * NAK (usually to report problems with the data we wrote).
 195          */
 196         ack = !getsda(adap);    /* ack: sda is pulled low -> success */
 197         bit_dbg(2, &i2c_adap->dev, "i2c_outb: 0x%02x %s\n", (int)c,
 198                 ack ? "A" : "NA");
 199
 200         scllo(adap);
 201         return ack;
 202         /* assert: scl is low (sda undef) */
 203 }
 204
 205
 206 static int i2c_inb(struct i2c_adapter *i2c_adap)
 207 {
 208         /* read byte via i2c port, without start/stop sequence  */
 209         /* acknowledge is sent in i2c_read.                     */
 210         int i;
 211         unsigned char indata = 0;
 212         struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
 213
 214         /* assert: scl is low */
 215         sdahi(adap);
 216         for (i = 0; i < 8; i++) {
 217                 if (sclhi(adap) < 0) { /* timeout */
 218                         bit_dbg(1, &i2c_adap->dev, "i2c_inb: timeout at bit "
 219                                 "#%d\n", 7 - i);
 220                         return -ETIMEDOUT;
 221                 }
 222                 indata *= 2;
 223                 if (getsda(adap))
 224                         indata |= 0x01;
 225                 setscl(adap, 0);
 226                 udelay(i == 7 ? adap->udelay / 2 : adap->udelay);
 227         }
 228         /* assert: scl is low */
 229         return indata;
 230 }
 231
 232 /*
 233  * Sanity check for the adapter hardware - check the reaction of
 234  * the bus lines only if it seems to be idle.
 235  */
 236 static int test_bus(struct i2c_adapter *i2c_adap)
 237 {
 238         struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
 239         const char *name = i2c_adap->name;
 240         int scl, sda, ret;
 241
 242         if (adap->pre_xfer) {
 243                 ret = adap->pre_xfer(i2c_adap);
 244                 if (ret < 0)
 245                         return -ENODEV;
 246         }
 247
 248         if (adap->getscl == NULL)
 249                 pr_info("%s: Testing SDA only, SCL is not readable\n", name);
 250
 251         sda = getsda(adap);
 252         scl = (adap->getscl == NULL) ? 1 : getscl(adap);
 253         if (!scl || !sda) {
 254                 printk(KERN_WARNING
 255                        "%s: bus seems to be busy (scl=%d, sda=%d)\n",
 256                        name, scl, sda);
 257                 goto bailout;
 258         }
 259
 260         sdalo(adap);
 261         sda = getsda(adap);
 262         scl = (adap->getscl == NULL) ? 1 : getscl(adap);
 263         if (sda) {
 264                 printk(KERN_WARNING "%s: SDA stuck high!\n", name);
 265                 goto bailout;
 266         }
 267         if (!scl) {
 268                 printk(KERN_WARNING "%s: SCL unexpected low "
 269                        "while pulling SDA low!\n", name);
 270                 goto bailout;
 271         }
 272
 273         sdahi(adap);
 274         sda = getsda(adap);
 275         scl = (adap->getscl == NULL) ? 1 : getscl(adap);
 276         if (!sda) {
 277                 printk(KERN_WARNING "%s: SDA stuck low!\n", name);
 278                 goto bailout;
 279         }
 280         if (!scl) {
 281                 printk(KERN_WARNING "%s: SCL unexpected low "
 282                        "while pulling SDA high!\n", name);
 283                 goto bailout;
 284         }
 285
 286         scllo(adap);
 287         sda = getsda(adap);
 288         scl = (adap->getscl == NULL) ? 0 : getscl(adap);
 289         if (scl) {
 290                 printk(KERN_WARNING "%s: SCL stuck high!\n", name);
 291                 goto bailout;
 292         }
 293         if (!sda) {
 294                 printk(KERN_WARNING "%s: SDA unexpected low "
 295                        "while pulling SCL low!\n", name);
 296                 goto bailout;
 297         }
 298
 299         sclhi(adap);
 300         sda = getsda(adap);
 301         scl = (adap->getscl == NULL) ? 1 : getscl(adap);
 302         if (!scl) {
 303                 printk(KERN_WARNING "%s: SCL stuck low!\n", name);
 304                 goto bailout;
 305         }
 306         if (!sda) {
 307                 printk(KERN_WARNING "%s: SDA unexpected low "
 308                        "while pulling SCL high!\n", name);
 309                 goto bailout;
 310         }
 311
 312         if (adap->post_xfer)
 313                 adap->post_xfer(i2c_adap);
 314
 315         pr_info("%s: Test OK\n", name);
 316         return 0;
 317 bailout:
 318         sdahi(adap);
 319         sclhi(adap);
 320
 321         if (adap->post_xfer)
 322                 adap->post_xfer(i2c_adap);
 323
 324         return -ENODEV;
 325 }
 326
 327 /* ----- Utility functions
 328  */
 329
 330 /* try_address tries to contact a chip for a number of
 331  * times before it gives up.
 332  * return values:
 333  * 1 chip answered
 334  * 0 chip did not answer
 335  * -x transmission error
 336  */
 337 static int try_address(struct i2c_adapter *i2c_adap,
 338                        unsigned char addr, int retries)
 339 {
 340         struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
 341         int i, ret = 0;
 342
 343         for (i = 0; i <= retries; i++) {
 344                 ret = i2c_outb(i2c_adap, addr);
 345                 if (ret == 1 || i == retries)
 346                         break;
 347                 bit_dbg(3, &i2c_adap->dev, "emitting stop condition\n");
 348                 i2c_stop(adap);
 349                 udelay(adap->udelay);
 350                 yield();
 351                 bit_dbg(3, &i2c_adap->dev, "emitting start condition\n");
 352                 i2c_start(adap);
 353         }
 354         if (i && ret)
 355                 bit_dbg(1, &i2c_adap->dev, "Used %d tries to %s client at "
 356                         "0x%02x: %s\n", i + 1,
 357                         addr & 1 ? "read from" : "write to", addr >> 1,
 358                         ret == 1 ? "success" : "failed, timeout?");
 359         return ret;
 360 }
 361
 362 static int sendbytes(struct i2c_adapter *i2c_adap, struct i2c_msg *msg)
 363 {
 364         const unsigned char *temp = msg->buf;
 365         int count = msg->len;
 366         unsigned short nak_ok = msg->flags & I2C_M_IGNORE_NAK;
 367         int retval;
 368         int wrcount = 0;
 369
 370         while (count > 0) {
 371                 retval = i2c_outb(i2c_adap, *temp);
 372
 373                 /* OK/ACK; or ignored NAK */
 374                 if ((retval > 0) || (nak_ok && (retval == 0))) {
 375                         count--;
 376                         temp++;
 377                         wrcount++;
 378
 379                 /* A slave NAKing the master means the slave didn't like
 380                  * something about the data it saw.  For example, maybe
 381                  * the SMBus PEC was wrong.
 382                  */
 383                 } else if (retval == 0) {
 384                         dev_err(&i2c_adap->dev, "sendbytes: NAK bailout.\n");
 385                         return -EIO;
 386
 387                 /* Timeout; or (someday) lost arbitration
 388                  *
 389                  * FIXME Lost ARB implies retrying the transaction from
 390                  * the first message, after the "winning" master issues
 391                  * its STOP.  As a rule, upper layer code has no reason
 392                  * to know or care about this ... it is *NOT* an error.
 393                  */
 394                 } else {
 395                         dev_err(&i2c_adap->dev, "sendbytes: error %d\n",
 396                                         retval);
 397                         return retval;
 398                 }
 399         }
 400         return wrcount;
 401 }
 402
 403 static int acknak(struct i2c_adapter *i2c_adap, int is_ack)
 404 {
 405         struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
 406
 407         /* assert: sda is high */
 408         if (is_ack)             /* send ack */
 409                 setsda(adap, 0);
 410         udelay((adap->udelay + 1) / 2);
 411         if (sclhi(adap) < 0) {  /* timeout */
 412                 dev_err(&i2c_adap->dev, "readbytes: ack/nak timeout\n");
 413                 return -ETIMEDOUT;
 414         }
 415         scllo(adap);
 416         return 0;
 417 }
 418
 419 static int readbytes(struct i2c_adapter *i2c_adap, struct i2c_msg *msg)
 420 {
 421         int inval;
 422         int rdcount = 0;        /* counts bytes read */
 423         unsigned char *temp = msg->buf;
 424         int count = msg->len;
 425         const unsigned flags = msg->flags;
 426
 427         while (count > 0) {
 428                 inval = i2c_inb(i2c_adap);
 429                 if (inval >= 0) {
 430                         *temp = inval;
 431                         rdcount++;
 432                 } else {   /* read timed out */
 433                         break;
 434                 }
 435
 436                 temp++;
 437                 count--;
 438
 439                 /* Some SMBus transactions require that we receive the
 440                    transaction length as the first read byte. */
 441                 if (rdcount == 1 && (flags & I2C_M_RECV_LEN)) {
 442                         if (inval <= 0 || inval > I2C_SMBUS_BLOCK_MAX) {
 443                                 if (!(flags & I2C_M_NO_RD_ACK))
 444                                         acknak(i2c_adap, 0);
 445                                 dev_err(&i2c_adap->dev, "readbytes: invalid "
 446                                         "block length (%d)\n", inval);
 447                                 return -EPROTO;
 448                         }
 449                         /* The original count value accounts for the extra
 450                            bytes, that is, either 1 for a regular transaction,
 451                            or 2 for a PEC transaction. */
 452                         count += inval;
 453                         msg->len += inval;
 454                 }
 455
 456                 bit_dbg(2, &i2c_adap->dev, "readbytes: 0x%02x %s\n",
 457                         inval,
 458                         (flags & I2C_M_NO_RD_ACK)
 459                                 ? "(no ack/nak)"
 460                                 : (count ? "A" : "NA"));
 461
 462                 if (!(flags & I2C_M_NO_RD_ACK)) {
 463                         inval = acknak(i2c_adap, count);
 464                         if (inval < 0)
 465                                 return inval;
 466                 }
 467         }
 468         return rdcount;
 469 }
 470
 471 /* doAddress initiates the transfer by generating the start condition (in
 472  * try_address) and transmits the address in the necessary format to handle
 473  * reads, writes as well as 10bit-addresses.
 474  * returns:
 475  *  0 everything went okay, the chip ack'ed, or IGNORE_NAK flag was set
 476  * -x an error occurred (like: -ENXIO if the device did not answer, or
 477  *      -ETIMEDOUT, for example if the lines are stuck...)
 478  */
 479 static int bit_doAddress(struct i2c_adapter *i2c_adap, struct i2c_msg *msg)
 480 {
 481         unsigned short flags = msg->flags;
 482         unsigned short nak_ok = msg->flags & I2C_M_IGNORE_NAK;
 483         struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
 484
 485         unsigned char addr;
 486         int ret, retries;
 487
 488         retries = nak_ok ? 0 : i2c_adap->retries;
 489
 490         if (flags & I2C_M_TEN) {
 491                 /* a ten bit address */
 492                 addr = 0xf0 | ((msg->addr >> 7) & 0x06);
 493                 bit_dbg(2, &i2c_adap->dev, "addr0: %d\n", addr);
 494                 /* try extended address code...*/
 495                 ret = try_address(i2c_adap, addr, retries);
 496                 if ((ret != 1) && !nak_ok)  {
 497                         dev_err(&i2c_adap->dev,
 498                                 "died at extended address code\n");
 499                         return -ENXIO;
 500                 }
 501                 /* the remaining 8 bit address */
 502                 ret = i2c_outb(i2c_adap, msg->addr & 0xff);
 503                 if ((ret != 1) && !nak_ok) {
 504                         /* the chip did not ack / xmission error occurred */
 505                         dev_err(&i2c_adap->dev, "died at 2nd address code\n");
 506                         return -ENXIO;
 507                 }
 508                 if (flags & I2C_M_RD) {
 509                         bit_dbg(3, &i2c_adap->dev, "emitting repeated "
 510                                 "start condition\n");
 511                         i2c_repstart(adap);
 512                         /* okay, now switch into reading mode */
 513                         addr |= 0x01;
 514                         ret = try_address(i2c_adap, addr, retries);
 515                         if ((ret != 1) && !nak_ok) {
 516                                 dev_err(&i2c_adap->dev,
 517                                         "died at repeated address code\n");
 518                                 return -EIO;
 519                         }
 520                 }
 521         } else {                /* normal 7bit address  */
 522                 addr = msg->addr << 1;
 523                 if (flags & I2C_M_RD)
 524                         addr |= 1;
 525                 if (flags & I2C_M_REV_DIR_ADDR)
 526                         addr ^= 1;
 527                 ret = try_address(i2c_adap, addr, retries);
 528                 if ((ret != 1) && !nak_ok)
 529                         return -ENXIO;
 530         }
 531
 532         return 0;
 533 }
 534
 535 static int bit_xfer(struct i2c_adapter *i2c_adap,
 536                     struct i2c_msg msgs[], int num)
 537 {
 538         struct i2c_msg *pmsg;
 539         struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
 540         int i, ret;
 541         unsigned short nak_ok;
 542
 543         if (adap->pre_xfer) {
 544                 ret = adap->pre_xfer(i2c_adap);
 545                 if (ret < 0)
 546                         return ret;
 547         }
 548
 549         bit_dbg(3, &i2c_adap->dev, "emitting start condition\n");
 550         i2c_start(adap);
 551         for (i = 0; i < num; i++) {
 552                 pmsg = &msgs[i];
 553                 nak_ok = pmsg->flags & I2C_M_IGNORE_NAK;
 554                 if (!(pmsg->flags & I2C_M_NOSTART)) {
 555                         if (i) {
 556                                 bit_dbg(3, &i2c_adap->dev, "emitting "
 557                                         "repeated start condition\n");
 558                                 i2c_repstart(adap);
 559                         }
 560                         ret = bit_doAddress(i2c_adap, pmsg);
 561                         if ((ret != 0) && !nak_ok) {
 562                                 bit_dbg(1, &i2c_adap->dev, "NAK from "
 563                                         "device addr 0x%02x msg #%d\n",
 564                                         msgs[i].addr, i);
 565                                 goto bailout;
 566                         }
 567                 }
 568                 if (pmsg->flags & I2C_M_RD) {
 569                         /* read bytes into buffer*/
 570                         ret = readbytes(i2c_adap, pmsg);
 571                         if (ret >= 1)
 572                                 bit_dbg(2, &i2c_adap->dev, "read %d byte%s\n",
 573                                         ret, ret == 1 ? "" : "s");
 574                         if (ret < pmsg->len) {
 575                                 if (ret >= 0)
 576                                         ret = -EIO;
 577                                 goto bailout;
 578                         }
 579                 } else {
 580                         /* write bytes from buffer */
 581                         ret = sendbytes(i2c_adap, pmsg);
 582                         if (ret >= 1)
 583                                 bit_dbg(2, &i2c_adap->dev, "wrote %d byte%s\n",
 584                                         ret, ret == 1 ? "" : "s");
 585                         if (ret < pmsg->len) {
 586                                 if (ret >= 0)
 587                                         ret = -EIO;
 588                                 goto bailout;
 589                         }
 590                 }
 591         }
 592         ret = i;
 593
 594 bailout:
 595         bit_dbg(3, &i2c_adap->dev, "emitting stop condition\n");
 596         i2c_stop(adap);
 597
 598         if (adap->post_xfer)
 599                 adap->post_xfer(i2c_adap);
 600         return ret;
 601 }
 602
 603 static u32 bit_func(struct i2c_adapter *adap)
 604 {
 605         return I2C_FUNC_I2C | I2C_FUNC_NOSTART | I2C_FUNC_SMBUS_EMUL |
 606                I2C_FUNC_SMBUS_READ_BLOCK_DATA |
 607                I2C_FUNC_SMBUS_BLOCK_PROC_CALL |
 608                I2C_FUNC_10BIT_ADDR | I2C_FUNC_PROTOCOL_MANGLING;
 609 }
 610
 611
 612 /* -----exported algorithm data: -------------------------------------  */
 613
 614 const struct i2c_algorithm i2c_bit_algo = {
 615         .master_xfer    = bit_xfer,
 616         .functionality  = bit_func,
 617 };
 618 EXPORT_SYMBOL(i2c_bit_algo);
 619
 620 /*
 621  * registering functions to load algorithms at runtime
 622  */
 623 static int __i2c_bit_add_bus(struct i2c_adapter *adap,
 624                              int (*add_adapter)(struct i2c_adapter *))
 625 {
 626         struct i2c_algo_bit_data *bit_adap = adap->algo_data;
 627         int ret;
 628
 629         if (bit_test) {
 630                 ret = test_bus(adap);
 631                 if (bit_test >= 2 && ret < 0)
 632                         return -ENODEV;
 633         }
 634
 635         /* register new adapter to i2c module... */
 636         adap->algo = &i2c_bit_algo;
 637         adap->retries = 3;
 638
 639         ret = add_adapter(adap);
 640         if (ret < 0)
 641                 return ret;
 642
 643         /* Complain if SCL can't be read */
 644         if (bit_adap->getscl == NULL) {
 645                 dev_warn(&adap->dev, "Not I2C compliant: can't read SCL\n");
 646                 dev_warn(&adap->dev, "Bus may be unreliable\n");
 647         }
 648         return 0;
 649 }
 650
 651 int i2c_bit_add_bus(struct i2c_adapter *adap)
 652 {
 653         return __i2c_bit_add_bus(adap, i2c_add_adapter);
 654 }
 655 EXPORT_SYMBOL(i2c_bit_add_bus);
 656
 657 int i2c_bit_add_numbered_bus(struct i2c_adapter *adap)
 658 {
 659         return __i2c_bit_add_bus(adap, i2c_add_numbered_adapter);
 660 }
 661 EXPORT_SYMBOL(i2c_bit_add_numbered_bus);
 662
 663 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
 664 MODULE_DESCRIPTION("I2C-Bus bit-banging algorithm");
 665 MODULE_LICENSE("GPL");