Subversion Repositories Kolibri OS

Rev

Rev 3120 | 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 <linux/jiffies.h>
  31. #include <errno.h>
  32. #include <linux/i2c.h>
  33. #include <linux/i2c-algo-bit.h>
  34.  
  35. #define I2C_FUNC_NOSTART                0x00000010 /* I2C_M_NOSTART */
  36.  
  37. /* ----- global defines ----------------------------------------------- */
  38.  
  39. #ifdef DEBUG
  40. #define bit_dbg(level, dev, format, args...) \
  41.         do { \
  42.                 if (i2c_debug >= level) \
  43.                         dev_dbg(dev, format, ##args); \
  44.         } while (0)
  45. #else
  46. #define bit_dbg(level, dev, format, args...) \
  47.         do {} while (0)
  48. #endif /* DEBUG */
  49.  
  50. /* ----- global variables --------------------------------------------- */
  51.  
  52. static int bit_test = 0;   /* see if the line-setting functions work   */
  53.  
  54. #ifdef DEBUG
  55. static int i2c_debug = 1;
  56. module_param(i2c_debug, int, S_IRUGO | S_IWUSR);
  57. MODULE_PARM_DESC(i2c_debug,
  58.                  "debug level - 0 off; 1 normal; 2 verbose; 3 very verbose");
  59. #endif
  60.  
  61. /* --- setting states on the bus with the right timing: --------------- */
  62.  
  63. #define setsda(adap, val)       adap->setsda(adap->data, val)
  64. #define setscl(adap, val)       adap->setscl(adap->data, val)
  65. #define getsda(adap)            adap->getsda(adap->data)
  66. #define getscl(adap)            adap->getscl(adap->data)
  67.  
  68. static inline void sdalo(struct i2c_algo_bit_data *adap)
  69. {
  70.         setsda(adap, 0);
  71.         udelay((adap->udelay + 1) / 2);
  72. }
  73.  
  74. static inline void sdahi(struct i2c_algo_bit_data *adap)
  75. {
  76.         setsda(adap, 1);
  77.         udelay((adap->udelay + 1) / 2);
  78. }
  79.  
  80. static inline void scllo(struct i2c_algo_bit_data *adap)
  81. {
  82.         setscl(adap, 0);
  83.         udelay(adap->udelay / 2);
  84. }
  85.  
  86. /*
  87.  * Raise scl line, and do checking for delays. This is necessary for slower
  88.  * devices.
  89.  */
  90. static int sclhi(struct i2c_algo_bit_data *adap)
  91. {
  92.         unsigned long start;
  93.  
  94.         setscl(adap, 1);
  95.  
  96.         /* Not all adapters have scl sense line... */
  97.         if (!adap->getscl)
  98.                 goto done;
  99.  
  100.     start = GetTimerTicks();
  101.         while (!getscl(adap)) {
  102.                 /* This hw knows how to read the clock line, so we wait
  103.                  * until it actually gets high.  This is safer as some
  104.                  * chips may hold it low ("clock stretching") while they
  105.                  * are processing data internally.
  106.                  */
  107.                 if (time_after(GetTimerTicks(), start + adap->timeout)) {
  108.                         /* Test one last time, as we may have been preempted
  109.                          * between last check and timeout test.
  110.                          */
  111.                         if (getscl(adap))
  112.                                 break;
  113.            return -ETIMEDOUT;
  114.                 }
  115.                 asm volatile("rep; nop" ::: "memory");
  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.         dbgprintf("%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.     dbgprintf("%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.         /* Complain if SCL can't be read */
  640.         if (bit_adap->getscl == NULL) {
  641.                 dev_warn(&adap->dev, "Not I2C compliant: can't read SCL\n");
  642.                 dev_warn(&adap->dev, "Bus may be unreliable\n");
  643.         }
  644.         return 0;
  645. }
  646.  
  647. int i2c_bit_add_bus(struct i2c_adapter *adap)
  648. {
  649.         return __i2c_bit_add_bus(adap, NULL);
  650. }
  651.  
  652.  
  653.