Subversion Repositories Kolibri OS

Rev

Rev 3031 | Rev 4104 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

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