Changeset 4014

Timestamp:

11/05/05 18:06:20 (8 years ago)

Author:

khali

Message:

Backport SMBus PEC support rewrite from Linux 2.6:

This is my rewrite of the SMBus PEC support. The original
implementation was known to have bugs (credits go to Hideki Iwamoto
for reporting many of them recently), and was incomplete due to a
conceptual limitation.

The rewrite affects only software PEC. Hardware PEC needs very little
code and is mostly untouched.

Files:

• i2c/trunk/kernel/i2c-core.c (modified) (13 diffs)

i2c/trunk/kernel/i2c-core.c

@@ -20 +20 @@
 /* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi>.
    All SMBus-related things are written by Frodo Looijaard <frodol@dds.nl>
-   SMBus 2.0 support by Mark Studebaker <mdsxyz123@yahoo.com>                */
+   SMBus 2.0 support by Mark Studebaker <mdsxyz123@yahoo.com> and
+   Jean Delvare <khali@linux-fr.org> */
 
 /* i2c-core.c,v 1.91.2.2 2003/01/21 10:00:19 kmalkki Exp */
@@ -943 +944 @@
 }
 
-/* CRC over count bytes in the first array plus the bytes in the rest
-   array if it is non-null. rest[0] is the (length of rest) - 1
-   and is included. */
-u8 i2c_smbus_partial_pec(u8 crc, int count, u8 *first, u8 *rest)
+/* Incremental CRC8 over count bytes in the array pointed to by p */
+static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
 {
         int i;
 
         for(i = 0; i < count; i++)
-                crc = crc8((crc ^ first[i]) << 8);
-        if(rest != NULL)
-                for(i = 0; i <= rest[0]; i++)
-                        crc = crc8((crc ^ rest[i]) << 8);
+                crc = crc8((crc ^ p[i]) << 8);
         return crc;
 }
 
-u8 i2c_smbus_pec(int count, u8 *first, u8 *rest)
-{
-        return i2c_smbus_partial_pec(0, count, first, rest);
-}
-
-/* Returns new "size" (transaction type)
-   Note that we convert byte to byte_data and byte_data to word_data
-   rather than invent new xxx_PEC transactions. */
-int i2c_smbus_add_pec(u16 addr, u8 command, int size,
-                      union i2c_smbus_data *data)
-{
-        u8 buf[3];
-
-        buf[0] = addr << 1;
-        buf[1] = command;
-        switch(size) {
-                case I2C_SMBUS_BYTE:
-                        data->byte = i2c_smbus_pec(2, buf, NULL);
-                        size = I2C_SMBUS_BYTE_DATA;
-                        break;
-                case I2C_SMBUS_BYTE_DATA:
-                        buf[2] = data->byte;
-                        data->word = buf[2] |
-                                    (i2c_smbus_pec(3, buf, NULL) << 8);
-                        size = I2C_SMBUS_WORD_DATA;
-                        break;
-                case I2C_SMBUS_WORD_DATA:
-                        /* unsupported */
-                        break;
-                case I2C_SMBUS_BLOCK_DATA:
-                        data->block[data->block[0] + 1] =
-                                     i2c_smbus_pec(2, buf, data->block);
-                        size = I2C_SMBUS_BLOCK_DATA_PEC;
-                        break;
-        }
-        return size;    
-}
-
-int i2c_smbus_check_pec(u16 addr, u8 command, int size, u8 partial,
-                        union i2c_smbus_data *data)
-{
-        u8 buf[3], rpec, cpec;
-
-        buf[1] = command;
-        switch(size) {
-                case I2C_SMBUS_BYTE_DATA:
-                        buf[0] = (addr << 1) | 1;
-                        cpec = i2c_smbus_pec(2, buf, NULL);
-                        rpec = data->byte;
-                        break;
-                case I2C_SMBUS_WORD_DATA:
-                        buf[0] = (addr << 1) | 1;
-                        buf[2] = data->word & 0xff;
-                        cpec = i2c_smbus_pec(3, buf, NULL);
-                        rpec = data->word >> 8;
-                        break;
-                case I2C_SMBUS_WORD_DATA_PEC:
-                        /* unsupported */
-                        cpec = rpec = 0;
-                        break;
-                case I2C_SMBUS_PROC_CALL_PEC:
-                        /* unsupported */
-                        cpec = rpec = 0;
-                        break;
-                case I2C_SMBUS_BLOCK_DATA_PEC:
-                        buf[0] = (addr << 1);
-                        buf[2] = (addr << 1) | 1;
-                        cpec = i2c_smbus_pec(3, buf, data->block);
-                        rpec = data->block[data->block[0] + 1];
-                        break;
-                case I2C_SMBUS_BLOCK_PROC_CALL_PEC:
-                        buf[0] = (addr << 1) | 1;
-                        rpec = i2c_smbus_partial_pec(partial, 1,
-                                                     buf, data->block);
-                        cpec = data->block[data->block[0] + 1];
-                        break;
-                default:
-                        cpec = rpec = 0;
-                        break;
-        }
+/* Assume a 7-bit address, which is reasonable for SMBus */
+static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
+{
+        /* The address will be sent first */
+        u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
+        pec = i2c_smbus_pec(pec, &addr, 1);
+
+        /* The data buffer follows */
+        return i2c_smbus_pec(pec, msg->buf, msg->len);
+}
+
+/* Used for write only transactions */
+static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
+{
+        msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
+        msg->len++;
+}
+
+/* Return <0 on CRC error
+   If there was a write before this read (most cases) we need to take the
+   partial CRC from the write part into account.
+   Note that this function does modify the message (we need to decrease the
+   message length to hide the CRC byte from the caller). */
+int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
+{
+        u8 rpec = msg->buf[--msg->len];
+        cpec = i2c_smbus_msg_pec(cpec, msg);
+
         if(rpec != cpec) {
                 DEB(printk(KERN_DEBUG "i2c-core.o: Bad PEC 0x%02x vs. 0x%02x\n",
@@ -1064 +1008 @@
 extern s32 i2c_smbus_write_byte(struct i2c_client * client, u8 value)
 {
-        union i2c_smbus_data data;      /* only for PEC */
         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
-                              I2C_SMBUS_WRITE,value, I2C_SMBUS_BYTE,&data);
+                              I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
 }
 
@@ -1224 +1167 @@
                                 };
         int i, len;
+        u8 partial_pec = 0;
 
         msgbuf0[0] = command;
@@ -1266 +1210 @@
                 break;
         case I2C_SMBUS_BLOCK_DATA:
-        case I2C_SMBUS_BLOCK_DATA_PEC:
                 if (read_write == I2C_SMBUS_READ) {
                         /* I2C_FUNC_SMBUS_EMUL doesn't include I2C_FUNC_SMBUS_READ_BLOCK_DATA */
@@ -1279 +1222 @@
                         msg[1].flags |= I2C_M_RECV_LEN;
                         msg[1].len = I2C_SMBUS_BLOCK_MAX + 1;
-                        if (size == I2C_SMBUS_BLOCK_DATA_PEC) {
-                                msg[1].len++;
+                        if (flags & I2C_CLIENT_PEC)
                                 msg[1].flags |= I2C_M_RECV_PEC;
-                        }
                 } else {
                         msg[0].len = data->block[0] + 2;
@@ -1291 +1232 @@
                                 return -1;
                         }
-                        if(size == I2C_SMBUS_BLOCK_DATA_PEC)
-                                (msg[0].len)++;
                         for (i = 1; i < msg[0].len; i++)
                                 msgbuf0[i] = data->block[i-1];
@@ -1298 +1237 @@
                 break;
         case I2C_SMBUS_BLOCK_PROC_CALL:
-        case I2C_SMBUS_BLOCK_PROC_CALL_PEC:
                 /* I2C_FUNC_SMBUS_EMUL doesn't include I2C_FUNC_SMBUS_BLOCK_PROC_CALL */
                 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BLOCK_PROC_CALL)) {
@@ -1322 +1260 @@
                 msg[1].flags |= I2C_M_RECV_LEN;
                 msg[1].len = I2C_SMBUS_BLOCK_MAX + 1;
-                if (size == I2C_SMBUS_BLOCK_PROC_CALL_PEC) {
-                        msg[1].len++;
+                if (flags & I2C_CLIENT_PEC)
                         msg[1].flags |= I2C_M_RECV_PEC;
-                }
                 break;
         case I2C_SMBUS_I2C_BLOCK_DATA:
@@ -1348 +1284 @@
         }
 
+        i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
+                                      && size != I2C_SMBUS_I2C_BLOCK_DATA);
+        if (i) {
+                /* Compute PEC if first message is a write */
+                if (!(msg[0].flags & I2C_M_RD)) {
+                        if (num == 1) /* Write only */
+                                i2c_smbus_add_pec(&msg[0]);
+                        else /* Write followed by read */
+                                partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
+                }
+                /* Ask for PEC if last message is a read */
+                if (msg[num-1].flags & I2C_M_RD)
+                        msg[num-1].len++;
+        }
+
         if (i2c_transfer(adapter, msg, num) < 0)
                 return -1;
+
+        /* Check PEC if last message is a read */
+        if (i && (msg[num-1].flags & I2C_M_RD)) {
+                if (i2c_smbus_check_pec(partial_pec, &msg[num-1]) < 0)
+                        return -1;
+        }
 
         if (read_write == I2C_SMBUS_READ)
@@ -1371 +1328 @@
                         case I2C_SMBUS_BLOCK_DATA:
                         case I2C_SMBUS_BLOCK_PROC_CALL:
-                        case I2C_SMBUS_BLOCK_DATA_PEC:
-                        case I2C_SMBUS_BLOCK_PROC_CALL_PEC:
                                 len = msgbuf1[0] + 1;
-                                if(size == I2C_SMBUS_BLOCK_DATA_PEC ||
-                                   size == I2C_SMBUS_BLOCK_PROC_CALL_PEC)
-                                        len++;
                                 for (i = 0; i < len; i++)
                                         data->block[i] = msgbuf1[i];
@@ -1390 +1342 @@
 {
         s32 res;
-        int swpec = 0;
-        u8 partial = 0;
 
         flags &= I2C_M_TEN | I2C_CLIENT_PEC;
-        if((flags & I2C_CLIENT_PEC) &&
-           !(i2c_check_functionality(adap, I2C_FUNC_SMBUS_HWPEC_CALC))) {
-                swpec = 1;
-                if(read_write == I2C_SMBUS_READ &&
-                   size == I2C_SMBUS_BLOCK_DATA)
-                        size = I2C_SMBUS_BLOCK_DATA_PEC;
-                else if(size == I2C_SMBUS_PROC_CALL)
-                        size = I2C_SMBUS_PROC_CALL_PEC;
-                else if(size == I2C_SMBUS_BLOCK_PROC_CALL) {
-                        i2c_smbus_add_pec(addr, command,
-                                          I2C_SMBUS_BLOCK_DATA, data);
-                        partial = data->block[data->block[0] + 1];
-                        size = I2C_SMBUS_BLOCK_PROC_CALL_PEC;
-                } else if(read_write == I2C_SMBUS_WRITE &&
-                          size != I2C_SMBUS_QUICK &&
-                          size != I2C_SMBUS_I2C_BLOCK_DATA)
-                        size = i2c_smbus_add_pec(addr, command, size, data);
-        }
 
         if (adap->algo->smbus_xfer) {
@@ -1422 +1354 @@
                                               command,size,data);
 
-        if(res >= 0 && swpec &&
-           size != I2C_SMBUS_QUICK && size != I2C_SMBUS_I2C_BLOCK_DATA &&
-           (read_write == I2C_SMBUS_READ || size == I2C_SMBUS_PROC_CALL_PEC ||
-            size == I2C_SMBUS_BLOCK_PROC_CALL_PEC)) {
-                if(i2c_smbus_check_pec(addr, command, size, partial, data))
-                        return -1;
-        }
         return res;
 }