WebSVN – Kolibri OS – Diff – /drivers/video/drm/i2c/i2c-algo-bit.c

     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
-    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+    MA 02110-1301 USA.
  * ------------------------------------------------------------------------- */
 /* With some changes from Frodo Looijaard , Kyösti Mälkki
     and Jean Delvare  */
+#include
 #include
 #include
 #include
 #include
+#include
 #include
 #include
 #include
 		if (i2c_debug >= level) \
 			dev_dbg(dev, format, ##args); \
 	} while (0)
 #else
 #define bit_dbg(level, dev, format, args...) \
-	do {} while (0)
+    do { /* dbgprintf(format, ##args); */ } while (0)
 #endif /* DEBUG */
 /* ----- global variables ---------------------------------------------	*/
+static int bit_test = 0;   /* see if the line-setting functions work   */
+#ifdef DEBUG
+static int i2c_debug = 1;
+module_param(i2c_debug, int, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(i2c_debug,
-static int bit_test;	/* see if the line-setting functions work	*/
+		 "debug level - 0 off; 1 normal; 2 verbose; 3 very verbose");
 #endif
 	/* Not all adapters have scl sense line... */
 	if (!adap->getscl)
 		goto done;
-//   start = jiffies;
+    start = GetTimerTicks();
 	while (!getscl(adap)) {
 		/* This hw knows how to read the clock line, so we wait
 		 * until it actually gets high.  This is safer as some
 		 * chips may hold it low ("clock stretching") while they
 		 * are processing data internally.
+		 */
-		 */
+		if (time_after(GetTimerTicks(), start + adap->timeout)) {
-//       if (time_after(jiffies, start + adap->timeout))
+			/* Test one last time, as we may have been preempted
+			 * between last check and timeout test.
+			 */
-//           return -ETIMEDOUT;
+			if (getscl(adap))
+				break;
-        udelay(adap->udelay);
+           return -ETIMEDOUT;
+		}
-//       cond_resched();
-	}
-#ifdef DEBUG
-	if (jiffies != start && i2c_debug >= 3)
-		pr_debug("i2c-algo-bit: needed %ld jiffies for SCL to go "
-			 "high\n", jiffies - start);
-#endif
+		udelay(1);
+    }
 done:
 	udelay(adap->udelay);
 		if (ret < 0)
 			return -ENODEV;
+	}
 	if (adap->getscl == NULL)
-		pr_info("%s: Testing SDA only, SCL is not readable\n", name);
+        dbgprintf("%s: Testing SDA only, SCL is not readable\n", name);
 	sda = getsda(adap);
+	scl = (adap->getscl == NULL) ? 1 : getscl(adap);
-	scl = (adap->getscl == NULL) ? 1 : getscl(adap);
+	if (!scl || !sda) {
+		printk(KERN_WARNING
-	if (!scl || !sda) {
+		       "%s: bus seems to be busy (scl=%d, sda=%d)\n",
-		printk(KERN_WARNING "%s: bus seems to be busy\n", name);
+		       name, scl, sda);
 		goto bailout;
+	}
+	}
 	if (adap->post_xfer)
 		adap->post_xfer(i2c_adap);
-	pr_info("%s: Test OK\n", name);
+    dbgprintf("%s: Test OK\n", name);
 	return 0;
 bailout:
 		/* A slave NAKing the master means the slave didn't like
 		 * something about the data it saw.  For example, maybe
 		 * the SMBus PEC was wrong.
 		 */
 		} else if (retval == 0) {
-//           dev_err(&i2c_adap->dev, "sendbytes: NAK bailout.\n");
+            dev_err(&i2c_adap->dev, "sendbytes: NAK bailout.\n");
 			return -EIO;
 		/* Timeout; or (someday) lost arbitration
+		 *
 		 * FIXME Lost ARB implies retrying the transaction from
 		 * the first message, after the "winning" master issues
 		 * its STOP.  As a rule, upper layer code has no reason
 		 * to know or care about this ... it is *NOT* an error.
 		 */
 		} else {
- //          dev_err(&i2c_adap->dev, "sendbytes: error %d\n",
+            dev_err(&i2c_adap->dev, "sendbytes: error %d\n",
- //                  retval);
+                   retval);
 			return retval;
+		}
+	}
 	return wrcount;
 	/* assert: sda is high */
 	if (is_ack)		/* send ack */
 		setsda(adap, 0);
 	udelay((adap->udelay + 1) / 2);
 	if (sclhi(adap) < 0) {	/* timeout */
-//       dev_err(&i2c_adap->dev, "readbytes: ack/nak timeout\n");
+       dev_err(&i2c_adap->dev, "readbytes: ack/nak timeout\n");
-//       return -ETIMEDOUT;
+       return -ETIMEDOUT;
+	}
 	scllo(adap);
 	return 0;
+}
 		   transaction length as the first read byte. */
 		if (rdcount == 1 && (flags & I2C_M_RECV_LEN)) {
 			if (inval <= 0 || inval > I2C_SMBUS_BLOCK_MAX) {
 				if (!(flags & I2C_M_NO_RD_ACK))
 					acknak(i2c_adap, 0);
-//               dev_err(&i2c_adap->dev, "readbytes: invalid "
+               dev_err(&i2c_adap->dev, "readbytes: invalid "
-//                   "block length (%d)\n", inval);
+                   "block length (%d)\n", inval);
-				return -EREMOTEIO;
+				return -EPROTO;
+			}
 			/* The original count value accounts for the extra
 			   bytes, that is, either 1 for a regular transaction,
 			   or 2 for a PEC transaction. */
 			count += inval;
 /* doAddress initiates the transfer by generating the start condition (in
  * try_address) and transmits the address in the necessary format to handle
  * reads, writes as well as 10bit-addresses.
  * returns:
  *  0 everything went okay, the chip ack'ed, or IGNORE_NAK flag was set
- * -x an error occurred (like: -EREMOTEIO if the device did not answer, or
+ * -x an error occurred (like: -ENXIO if the device did not answer, or
  *	-ETIMEDOUT, for example if the lines are stuck...)
  */
 static int bit_doAddress(struct i2c_adapter *i2c_adap, struct i2c_msg *msg)
+{
 	unsigned short flags = msg->flags;
 	retries = nak_ok ? 0 : i2c_adap->retries;
 	if (flags & I2C_M_TEN) {
 		/* a ten bit address */
-		addr = 0xf0 | ((msg->addr >> 7) & 0x03);
+		addr = 0xf0 | ((msg->addr >> 7) & 0x06);
 		bit_dbg(2, &i2c_adap->dev, "addr0: %d\n", addr);
 		/* try extended address code...*/
 		ret = try_address(i2c_adap, addr, retries);
 		if ((ret != 1) && !nak_ok)  {
- //          dev_err(&i2c_adap->dev,
+           dev_err(&i2c_adap->dev,
- //              "died at extended address code\n");
+               "died at extended address code\n");
-			return -EREMOTEIO;
+			return -ENXIO;
 		}
 		/* the remaining 8 bit address */
-		ret = i2c_outb(i2c_adap, msg->addr & 0x7f);
+		ret = i2c_outb(i2c_adap, msg->addr & 0xff);
 		if ((ret != 1) && !nak_ok) {
 			/* the chip did not ack / xmission error occurred */
-//           dev_err(&i2c_adap->dev, "died at 2nd address code\n");
+            dev_err(&i2c_adap->dev, "died at 2nd address code\n");
-			return -EREMOTEIO;
+			return -ENXIO;
+		}
 		if (flags & I2C_M_RD) {
 			bit_dbg(3, &i2c_adap->dev, "emitting repeated "
 				"start condition\n");
 			i2c_repstart(adap);
 			/* okay, now switch into reading mode */
 			addr |= 0x01;
 			ret = try_address(i2c_adap, addr, retries);
 			if ((ret != 1) && !nak_ok) {
-//               dev_err(&i2c_adap->dev,
+               dev_err(&i2c_adap->dev,
-//                   "died at repeated address code\n");
+                   "died at repeated address code\n");
-				return -EREMOTEIO;
+				return -EIO;
+			}
+		}
 	} else {		/* normal 7bit address	*/
 	struct i2c_msg *pmsg;
 	struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
 	int i, ret;
 	unsigned short nak_ok;
 	//ENTER();
-	if (adap->pre_xfer) {
+    if (adap->pre_xfer) {
 		ret = adap->pre_xfer(i2c_adap);
 		if (ret < 0)
 			return ret;
 			if (ret >= 1)
 				bit_dbg(2, &i2c_adap->dev, "read %d byte%s\n",
 					ret, ret == 1 ? "" : "s");
 			if (ret < pmsg->len) {
 				if (ret >= 0)
-					ret = -EREMOTEIO;
+					ret = -EIO;
 				goto bailout;
+			}
 		} else {
 			/* write bytes from buffer */
 			ret = sendbytes(i2c_adap, pmsg);
 			if (ret >= 1)
 				bit_dbg(2, &i2c_adap->dev, "wrote %d byte%s\n",
 					ret, ret == 1 ? "" : "s");
 			if (ret < pmsg->len) {
 				if (ret >= 0)
-					ret = -EREMOTEIO;
+					ret = -EIO;
 				goto bailout;
+			}
+		}
+	}
 	ret = i;
 bailout:
 	bit_dbg(3, &i2c_adap->dev, "emitting stop condition\n");
-	i2c_stop(adap);
-//    LEAVE();
+	i2c_stop(adap);
 	if (adap->post_xfer)
 		adap->post_xfer(i2c_adap);
 	return ret;
+}
 static u32 bit_func(struct i2c_adapter *adap)
+{
-	return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL |
+	return I2C_FUNC_I2C | I2C_FUNC_NOSTART | I2C_FUNC_SMBUS_EMUL |
 	       I2C_FUNC_SMBUS_READ_BLOCK_DATA |
 	       I2C_FUNC_SMBUS_BLOCK_PROC_CALL |
 	       I2C_FUNC_10BIT_ADDR | I2C_FUNC_PROTOCOL_MANGLING;
+}
+/* -----exported algorithm data: -------------------------------------	*/
 /* -----exported algorithm data: -------------------------------------	*/
 const struct i2c_algorithm i2c_bit_algo = {
-static const struct i2c_algorithm i2c_bit_algo = {
+	.master_xfer	= bit_xfer,
-	.master_xfer	= bit_xfer,
+	.functionality	= bit_func,
 	struct i2c_algo_bit_data *bit_adap = adap->algo_data;
 	int ret;
 	if (bit_test) {
 		ret = test_bus(adap);
-		if (ret < 0)
+		if (bit_test >= 2 && ret < 0)
 			return -ENODEV;
+	}
 	/* register new adapter to i2c module... */
+	adap->algo = &i2c_bit_algo;
+	adap->retries = 3;
+	/* Complain if SCL can't be read */
+	if (bit_adap->getscl == NULL) {
-	adap->algo = &i2c_bit_algo;
+		dev_warn(&adap->dev, "Not I2C compliant: can't read SCL\n");
-	adap->retries = 3;
+		dev_warn(&adap->dev, "Bus may be unreliable\n");
+	}
 	return 0;

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/i2c/i2c-algo-bit.c – Rev 1963 → 3031