cros_ec: Clean up multiple EC protocol support

Version 1 protocols (without command version) were already no longer
supported in cros_ec.c.  This removes some dead code from the
cros_ec_i2c driver.

Version 2 protcols (with command version) are now called
protocol_version=2, instead of cmd_version_is_supported=1.

A subsequent change will introduce protocol version 3 for SPI.

Reviewed-by: Simon Glass <sjg@chromium.org>
Signed-off-by: Randall Spangler <rspangler@chromium.org>
Signed-off-by: Simon Glass <sjg@chromium.org>

diff --git a/drivers/misc/cros_ec.c b/drivers/misc/cros_ec.c
index ff46762ddedef52d18d564a4e116308e21792c41..33b9390d3e31f6c69b61fe2d566624bf971f4587 100644 (file)
--- a/drivers/misc/cros_ec.c
+++ b/drivers/misc/cros_ec.c
@@ -501,18 +501,23 @@ static int cros_ec_check_version(struct cros_ec_dev *dev)
         *
         * So for now, just read all the data anyway.
         */
-       dev->cmd_version_is_supported = 1;
+
+       /* Try sending a version 2 packet */
+       dev->protocol_version = 2;
        if (ec_command_inptr(dev, EC_CMD_HELLO, 0, &req, sizeof(req),
                       (uint8_t **)&resp, sizeof(*resp)) > 0) {
-               /* It appears to understand new version commands */
-               dev->cmd_version_is_supported = 1;
-       } else {
-               printf("%s: ERROR: old EC interface not supported\n",
-                      __func__);
-               return -1;
+               return 0;
        }
 
-       return 0;
+       /*
+        * Fail if we're still here, since the EC doesn't understand any
+        * protcol version we speak.  Version 1 interface without command
+        * version is no longer supported, and we don't know about any new
+        * protocol versions.
+        */
+       dev->protocol_version = 0;
+       printf("%s: ERROR: old EC interface not supported\n", __func__);
+       return -1;
 }
 
 int cros_ec_test(struct cros_ec_dev *dev)

diff --git a/drivers/misc/cros_ec_i2c.c b/drivers/misc/cros_ec_i2c.c
index 0fbab991b5b0af8d121a6e71efc720665fe2b60d..513cdb1cb09808be69ac6a44be2cb651ad9ac347 100644 (file)
--- a/drivers/misc/cros_ec_i2c.c
+++ b/drivers/misc/cros_ec_i2c.c
@@ -35,7 +35,7 @@ int cros_ec_i2c_command(struct cros_ec_dev *dev, uint8_t cmd, int cmd_version,
        uint8_t *ptr;
        /* Receive input data, so that args will be dword aligned */
        uint8_t *in_ptr;
-       int ret;
+       int len, csum, ret;
 
        old_bus = i2c_get_bus_num();
 
@@ -67,24 +67,24 @@ int cros_ec_i2c_command(struct cros_ec_dev *dev, uint8_t cmd, int cmd_version,
         * will be dword aligned.
         */
        in_ptr = dev->din + sizeof(int64_t);
-       if (!dev->cmd_version_is_supported) {
-               /* Send an old-style command */
-               *ptr++ = cmd;
-               out_bytes = dout_len + 1;
-               in_bytes = din_len + 2;
-               in_ptr--;       /* Expect just a status byte */
-       } else {
-               *ptr++ = EC_CMD_VERSION0 + cmd_version;
-               *ptr++ = cmd;
-               *ptr++ = dout_len;
-               in_ptr -= 2;    /* Expect status, length bytes */
+
+       if (dev->protocol_version != 2) {
+               /* Something we don't support */
+               debug("%s: Protocol version %d unsupported\n",
+                     __func__, dev->protocol_version);
+               return -1;
        }
+
+       *ptr++ = EC_CMD_VERSION0 + cmd_version;
+       *ptr++ = cmd;
+       *ptr++ = dout_len;
+       in_ptr -= 2;    /* Expect status, length bytes */
+
        memcpy(ptr, dout, dout_len);
        ptr += dout_len;
 
-       if (dev->cmd_version_is_supported)
-               *ptr++ = (uint8_t)
-                        cros_ec_calc_checksum(dev->dout, dout_len + 3);
+       *ptr++ = (uint8_t)
+               cros_ec_calc_checksum(dev->dout, dout_len + 3);
 
        /* Set to the proper i2c bus */
        if (i2c_set_bus_num(dev->bus_num)) {
@@ -121,26 +121,20 @@ int cros_ec_i2c_command(struct cros_ec_dev *dev, uint8_t cmd, int cmd_version,
                return -(int)*in_ptr;
        }
 
-       if (dev->cmd_version_is_supported) {
-               int len, csum;
-
-               len = in_ptr[1];
-               if (len + 3 > sizeof(dev->din)) {
-                       debug("%s: Received length %#02x too large\n",
-                             __func__, len);
-                       return -1;
-               }
-               csum = cros_ec_calc_checksum(in_ptr, 2 + len);
-               if (csum != in_ptr[2 + len]) {
-                       debug("%s: Invalid checksum rx %#02x, calced %#02x\n",
-                             __func__, in_ptr[2 + din_len], csum);
-                       return -1;
-               }
-               din_len = min(din_len, len);
-               cros_ec_dump_data("in", -1, in_ptr, din_len + 3);
-       } else {
-               cros_ec_dump_data("in (old)", -1, in_ptr, in_bytes);
+       len = in_ptr[1];
+       if (len + 3 > sizeof(dev->din)) {
+               debug("%s: Received length %#02x too large\n",
+                     __func__, len);
+               return -1;
        }
+       csum = cros_ec_calc_checksum(in_ptr, 2 + len);
+       if (csum != in_ptr[2 + len]) {
+               debug("%s: Invalid checksum rx %#02x, calced %#02x\n",
+                     __func__, in_ptr[2 + din_len], csum);
+               return -1;
+       }
+       din_len = min(din_len, len);
+       cros_ec_dump_data("in", -1, in_ptr, din_len + 3);
 
        /* Return pointer to dword-aligned input data, if any */
        *dinp = dev->din + sizeof(int64_t);
@@ -178,7 +172,5 @@ int cros_ec_i2c_init(struct cros_ec_dev *dev, const void *blob)
 {
        i2c_init(dev->max_frequency, dev->addr);
 
-       dev->cmd_version_is_supported = 0;
-
        return 0;
 }

diff --git a/drivers/misc/cros_ec_spi.c b/drivers/misc/cros_ec_spi.c
index 2fc911025eeb5e01c76b9a9ace2eeabc6dbdc149..ef73782606e21301a14ba7ae5c500ef5c404db3a 100644 (file)
--- a/drivers/misc/cros_ec_spi.c
+++ b/drivers/misc/cros_ec_spi.c
@@ -42,6 +42,12 @@ int cros_ec_spi_command(struct cros_ec_dev *dev, uint8_t cmd, int cmd_version,
        int csum, len;
        int rv;
 
+       if (dev->protocol_version != 2) {
+               debug("%s: Unsupported EC protcol version %d\n",
+                     __func__, dev->protocol_version);
+               return -1;
+       }
+
        /*
         * Sanity-check input size to make sure it plus transaction overhead
         * fits in the internal device buffer.

diff --git a/include/cros_ec.h b/include/cros_ec.h
index 31661329fd2dba61b5c75c8b20acc895ce09af64..1199d923354c30e8a3926a80e52b6d50d6778784 100644 (file)
--- a/include/cros_ec.h
+++ b/include/cros_ec.h
@@ -33,7 +33,7 @@ struct cros_ec_dev {
        unsigned int bus_num;           /* Bus number (for I2C) */
        unsigned int max_frequency;     /* Maximum interface frequency */
        struct fdt_gpio_state ec_int;   /* GPIO used as EC interrupt line */
-       int cmd_version_is_supported;   /* Device supports command versions */
+       int protocol_version;           /* Protocol version to use */
        int optimise_flash_write;       /* Don't write erased flash blocks */
 
        /*
@@ -260,8 +260,7 @@ int cros_ec_spi_decode_fdt(struct cros_ec_dev *dev, const void *blob);
  * Check whether the LPC interface supports new-style commands.
  *
  * LPC has its own way of doing this, which involves checking LPC values
- * visible to the host. Do this, and update dev->cmd_version_is_supported
- * accordingly.
+ * visible to the host. Do this, and update dev->protocol_version accordingly.
  *
  * @param dev          CROS-EC device to check
  */