]> git.sur5r.net Git - u-boot/commitdiff
cros_ec: Drop unused CONFIG_DM_CROS_EC
authorSimon Glass <sjg@chromium.org>
Thu, 26 Mar 2015 15:29:32 +0000 (09:29 -0600)
committerSimon Glass <sjg@chromium.org>
Sat, 18 Apr 2015 17:11:15 +0000 (11:11 -0600)
Since all supported boards enable this option now, we can remove it along
with the old code.

Signed-off-by: Simon Glass <sjg@chromium.org>
arch/sandbox/Kconfig
board/samsung/smdk5420/Kconfig
common/cros_ec.c
configs/sandbox_defconfig
configs/snow_defconfig
drivers/misc/Kconfig
drivers/misc/cros_ec.c
drivers/misc/cros_ec_lpc.c
drivers/misc/cros_ec_sandbox.c
include/cros_ec.h

index 52e59d29e81b169d275de7a3c874590be98ae7e5..e1832c931db2a329ed37c16fff636fa9d3c27fa3 100644 (file)
@@ -19,9 +19,6 @@ config DM_GPIO
 config DM_SERIAL
        default y
 
-config DM_CROS_EC
-       default y
-
 config DM_SPI
        default y
 
index 576abaea698bb6ff5adf1098b3e22ac328c88ef9..a9d62fffa55ebfdbdfa1516a0c0fff7108237c4c 100644 (file)
@@ -22,9 +22,6 @@ config SYS_VENDOR
 config SYS_CONFIG_NAME
        default "peach-pi"
 
-config DM_CROS_EC
-       default y
-
 endif
 
 if TARGET_PEACH_PIT
@@ -38,9 +35,6 @@ config SYS_VENDOR
 config SYS_CONFIG_NAME
        default "peach-pit"
 
-config DM_CROS_EC
-       default y
-
 endif
 
 if TARGET_SMDK5420
index 64b46796eff5d40f5a371ae0a5ea221611e87e58..f9c74ca0b990d9c048a4d6f6cc00a8c31dc670ff 100644 (file)
 
 DECLARE_GLOBAL_DATA_PTR;
 
-#ifndef CONFIG_DM_CROS_EC
-struct local_info {
-       struct cros_ec_dev *cros_ec_dev;        /* Pointer to cros_ec device */
-       int cros_ec_err;                        /* Error for cros_ec, 0 if ok */
-};
-
-static struct local_info local;
-#endif
-
 struct cros_ec_dev *board_get_cros_ec_dev(void)
 {
-#ifdef CONFIG_DM_CROS_EC
        struct udevice *dev;
        int ret;
 
@@ -36,30 +26,15 @@ struct cros_ec_dev *board_get_cros_ec_dev(void)
                return NULL;
        }
        return dev_get_uclass_priv(dev);
-#else
-       return local.cros_ec_dev;
-#endif
-}
-
-static int board_init_cros_ec_devices(const void *blob)
-{
-#ifndef CONFIG_DM_CROS_EC
-       local.cros_ec_err = cros_ec_init(blob, &local.cros_ec_dev);
-       if (local.cros_ec_err)
-               return -1;  /* Will report in board_late_init() */
-#endif
-
-       return 0;
 }
 
 int cros_ec_board_init(void)
 {
-       return board_init_cros_ec_devices(gd->fdt_blob);
+       return 0;
 }
 
 int cros_ec_get_error(void)
 {
-#ifdef CONFIG_DM_CROS_EC
        struct udevice *dev;
        int ret;
 
@@ -68,7 +43,4 @@ int cros_ec_get_error(void)
                return ret;
 
        return 0;
-#else
-       return local.cros_ec_err;
-#endif
 }
index 24d71d09a442aa807d2b66d9d498879dd4fce36b..93bcf46e76a1b2f4653ac443014405b344e58358 100644 (file)
@@ -6,7 +6,6 @@ CONFIG_FIT_SIGNATURE=y
 CONFIG_DM=y
 CONFIG_DEFAULT_DEVICE_TREE="sandbox"
 CONFIG_CROS_EC=y
-CONFIG_DM_CROS_EC=y
 CONFIG_CROS_EC_SANDBOX=y
 CONFIG_CROS_EC_KEYB=y
 CONFIG_CMD_CROS_EC=y
index 2b0d6faf98f213f6acd8d8e2e195fc60d1ba93ce..6417a771618572e2161788740fafdd10e15ecfce 100644 (file)
@@ -4,7 +4,6 @@ CONFIG_ARCH_EXYNOS=y
 CONFIG_TARGET_SNOW=y
 CONFIG_DEFAULT_DEVICE_TREE="exynos5250-snow"
 CONFIG_CROS_EC=y
-CONFIG_DM_CROS_EC=y
 CONFIG_CROS_EC_I2C=y
 CONFIG_CROS_EC_KEYB=y
 CONFIG_CMD_CROS_EC=y
index 36a8f0d098e2df26e76abadde9df6ac1aa79b9c5..1ec9b221fff76088b59c40dec595b5e31e6ff104 100644 (file)
@@ -44,16 +44,6 @@ config CROS_EC_SPI
          provides a faster and more robust interface than I2C but the bugs
          are less interesting.
 
-config DM_CROS_EC
-       bool "Enable Driver Model for Chrome OS EC"
-       depends on DM
-       help
-         Enable driver model for the Chrome OS EC interface. This
-         allows the cros_ec SPI driver to operate with CONFIG_DM_SPI
-         but otherwise makes few changes. Since cros_ec also supports
-         LPC (which doesn't support driver model yet), a full
-         conversion is not yet possible.
-
 config CONFIG_FSL_SEC_MON
        bool "Enable FSL SEC_MON Driver"
        help
index 6d4d04561cbf9c2cc9b791794aa0f65476fe2548..982bac788d52b1b52948a525018a585bcb225d8c 100644 (file)
@@ -41,10 +41,6 @@ enum {
        CROS_EC_CMD_HASH_TIMEOUT_MS = 2000,
 };
 
-#ifndef CONFIG_DM_CROS_EC
-static struct cros_ec_dev static_dev, *last_dev;
-#endif
-
 DECLARE_GLOBAL_DATA_PTR;
 
 /* Note: depends on enum ec_current_image */
@@ -211,9 +207,7 @@ static int send_command_proto3(struct cros_ec_dev *dev,
                               const void *dout, int dout_len,
                               uint8_t **dinp, int din_len)
 {
-#ifdef CONFIG_DM_CROS_EC
        struct dm_cros_ec_ops *ops;
-#endif
        int out_bytes, in_bytes;
        int rv;
 
@@ -228,28 +222,8 @@ static int send_command_proto3(struct cros_ec_dev *dev,
        if (in_bytes < 0)
                return in_bytes;
 
-#ifdef CONFIG_DM_CROS_EC
        ops = dm_cros_ec_get_ops(dev->dev);
        rv = ops->packet ? ops->packet(dev->dev, out_bytes, in_bytes) : -ENOSYS;
-#else
-       switch (dev->interface) {
-#ifdef CONFIG_CROS_EC_SPI
-       case CROS_EC_IF_SPI:
-               rv = cros_ec_spi_packet(dev, out_bytes, in_bytes);
-               break;
-#endif
-#ifdef CONFIG_CROS_EC_SANDBOX
-       case CROS_EC_IF_SANDBOX:
-               rv = cros_ec_sandbox_packet(dev, out_bytes, in_bytes);
-               break;
-#endif
-       case CROS_EC_IF_NONE:
-       /* TODO: support protocol 3 for LPC, I2C; for now fall through */
-       default:
-               debug("%s: Unsupported interface\n", __func__);
-               rv = -1;
-       }
-#endif
        if (rv < 0)
                return rv;
 
@@ -261,9 +235,7 @@ static int send_command(struct cros_ec_dev *dev, uint8_t cmd, int cmd_version,
                        const void *dout, int dout_len,
                        uint8_t **dinp, int din_len)
 {
-#ifdef CONFIG_DM_CROS_EC
        struct dm_cros_ec_ops *ops;
-#endif
        int ret = -1;
 
        /* Handle protocol version 3 support */
@@ -272,38 +244,9 @@ static int send_command(struct cros_ec_dev *dev, uint8_t cmd, int cmd_version,
                                           dout, dout_len, dinp, din_len);
        }
 
-#ifdef CONFIG_DM_CROS_EC
        ops = dm_cros_ec_get_ops(dev->dev);
        ret = ops->command(dev->dev, cmd, cmd_version,
                           (const uint8_t *)dout, dout_len, dinp, din_len);
-#else
-       switch (dev->interface) {
-#ifdef CONFIG_CROS_EC_SPI
-       case CROS_EC_IF_SPI:
-               ret = cros_ec_spi_command(dev, cmd, cmd_version,
-                                       (const uint8_t *)dout, dout_len,
-                                       dinp, din_len);
-               break;
-#endif
-#ifdef CONFIG_CROS_EC_I2C
-       case CROS_EC_IF_I2C:
-               ret = cros_ec_i2c_command(dev, cmd, cmd_version,
-                                       (const uint8_t *)dout, dout_len,
-                                       dinp, din_len);
-               break;
-#endif
-#ifdef CONFIG_CROS_EC_LPC
-       case CROS_EC_IF_LPC:
-               ret = cros_ec_lpc_command(dev, cmd, cmd_version,
-                                       (const uint8_t *)dout, dout_len,
-                                       dinp, din_len);
-               break;
-#endif
-       case CROS_EC_IF_NONE:
-       default:
-               ret = -1;
-       }
-#endif
 
        return ret;
 }
@@ -681,7 +624,6 @@ static int cros_ec_check_version(struct cros_ec_dev *dev)
        struct ec_params_hello req;
        struct ec_response_hello *resp;
 
-#ifdef CONFIG_DM_CROS_EC
        struct dm_cros_ec_ops *ops;
        int ret;
 
@@ -691,13 +633,6 @@ static int cros_ec_check_version(struct cros_ec_dev *dev)
                if (ret)
                        return ret;
        }
-#else
-#ifdef CONFIG_CROS_EC_LPC
-       /* LPC has its own way of doing this */
-       if (dev->interface == CROS_EC_IF_LPC)
-               return cros_ec_lpc_check_version(dev);
-#endif
-#endif
 
        /*
         * TODO(sjg@chromium.org).
@@ -1027,76 +962,6 @@ int cros_ec_get_ldo(struct cros_ec_dev *dev, uint8_t index, uint8_t *state)
        return 0;
 }
 
-#ifndef CONFIG_DM_CROS_EC
-/**
- * Decode EC interface details from the device tree and allocate a suitable
- * device.
- *
- * @param blob         Device tree blob
- * @param node         Node to decode from
- * @param devp         Returns a pointer to the new allocated device
- * @return 0 if ok, -1 on error
- */
-static int cros_ec_decode_fdt(const void *blob, int node,
-               struct cros_ec_dev **devp)
-{
-       enum fdt_compat_id compat;
-       struct cros_ec_dev *dev;
-       int parent;
-
-       /* See what type of parent we are inside (this is expensive) */
-       parent = fdt_parent_offset(blob, node);
-       if (parent < 0) {
-               debug("%s: Cannot find node parent\n", __func__);
-               return -1;
-       }
-
-       dev = &static_dev;
-       dev->node = node;
-       dev->parent_node = parent;
-
-       compat = fdtdec_lookup(blob, parent);
-       switch (compat) {
-#ifdef CONFIG_CROS_EC_SPI
-       case COMPAT_SAMSUNG_EXYNOS_SPI:
-               dev->interface = CROS_EC_IF_SPI;
-               if (cros_ec_spi_decode_fdt(dev, blob))
-                       return -1;
-               break;
-#endif
-#ifdef CONFIG_CROS_EC_I2C
-       case COMPAT_SAMSUNG_S3C2440_I2C:
-               dev->interface = CROS_EC_IF_I2C;
-               if (cros_ec_i2c_decode_fdt(dev, blob))
-                       return -1;
-               break;
-#endif
-#ifdef CONFIG_CROS_EC_LPC
-       case COMPAT_INTEL_LPC:
-               dev->interface = CROS_EC_IF_LPC;
-               break;
-#endif
-#ifdef CONFIG_CROS_EC_SANDBOX
-       case COMPAT_SANDBOX_HOST_EMULATION:
-               dev->interface = CROS_EC_IF_SANDBOX;
-               break;
-#endif
-       default:
-               debug("%s: Unknown compat id %d\n", __func__, compat);
-               return -1;
-       }
-
-       gpio_request_by_name_nodev(blob, node, "ec-interrupt", 0, &dev->ec_int,
-                                  GPIOD_IS_IN);
-       dev->optimise_flash_write = fdtdec_get_bool(blob, node,
-                                                   "optimise-flash-write");
-       *devp = dev;
-
-       return 0;
-}
-#endif
-
-#ifdef CONFIG_DM_CROS_EC
 int cros_ec_register(struct udevice *dev)
 {
        struct cros_ec_dev *cdev = dev_get_uclass_priv(dev);
@@ -1125,94 +990,6 @@ int cros_ec_register(struct udevice *dev)
 
        return 0;
 }
-#else
-int cros_ec_init(const void *blob, struct cros_ec_dev **cros_ecp)
-{
-       struct cros_ec_dev *dev;
-       char id[MSG_BYTES];
-#ifdef CONFIG_DM_CROS_EC
-       struct udevice *udev;
-       int ret;
-
-       ret = uclass_find_device(UCLASS_CROS_EC, 0, &udev);
-       if (!ret)
-               device_remove(udev);
-       ret = uclass_get_device(UCLASS_CROS_EC, 0, &udev);
-       if (ret)
-               return ret;
-       dev = dev_get_uclass_priv(udev);
-       return 0;
-#else
-       int node = 0;
-
-       *cros_ecp = NULL;
-       do {
-               node = fdtdec_next_compatible(blob, node,
-                                             COMPAT_GOOGLE_CROS_EC);
-               if (node < 0) {
-                       debug("%s: Node not found\n", __func__);
-                       return 0;
-               }
-       } while (!fdtdec_get_is_enabled(blob, node));
-
-       if (cros_ec_decode_fdt(blob, node, &dev)) {
-               debug("%s: Failed to decode device.\n", __func__);
-               return -CROS_EC_ERR_FDT_DECODE;
-       }
-
-       switch (dev->interface) {
-#ifdef CONFIG_CROS_EC_SPI
-       case CROS_EC_IF_SPI:
-               if (cros_ec_spi_init(dev, blob)) {
-                       debug("%s: Could not setup SPI interface\n", __func__);
-                       return -CROS_EC_ERR_DEV_INIT;
-               }
-               break;
-#endif
-#ifdef CONFIG_CROS_EC_I2C
-       case CROS_EC_IF_I2C:
-               if (cros_ec_i2c_init(dev, blob))
-                       return -CROS_EC_ERR_DEV_INIT;
-               break;
-#endif
-#ifdef CONFIG_CROS_EC_LPC
-       case CROS_EC_IF_LPC:
-               if (cros_ec_lpc_init(dev, blob))
-                       return -CROS_EC_ERR_DEV_INIT;
-               break;
-#endif
-#ifdef CONFIG_CROS_EC_SANDBOX
-       case CROS_EC_IF_SANDBOX:
-               if (cros_ec_sandbox_init(dev, blob))
-                       return -CROS_EC_ERR_DEV_INIT;
-               break;
-#endif
-       case CROS_EC_IF_NONE:
-       default:
-               return 0;
-       }
-#endif
-
-       if (cros_ec_check_version(dev)) {
-               debug("%s: Could not detect CROS-EC version\n", __func__);
-               return -CROS_EC_ERR_CHECK_VERSION;
-       }
-
-       if (cros_ec_read_id(dev, id, sizeof(id))) {
-               debug("%s: Could not read KBC ID\n", __func__);
-               return -CROS_EC_ERR_READ_ID;
-       }
-
-       /* Remember this device for use by the cros_ec command */
-       *cros_ecp = dev;
-#ifndef CONFIG_DM_CROS_EC
-       last_dev = dev;
-#endif
-       debug("Google Chrome EC CROS-EC driver ready, id '%s'\n", id);
-
-       return 0;
-}
-#endif
 
 int cros_ec_decode_region(int argc, char * const argv[])
 {
@@ -1595,9 +1372,7 @@ static int cros_ec_i2c_passthrough(struct cros_ec_dev *dev, int flag,
 static int do_cros_ec(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
        struct cros_ec_dev *dev;
-#ifdef CONFIG_DM_CROS_EC
        struct udevice *udev;
-#endif
        const char *cmd;
        int ret = 0;
 
@@ -1606,15 +1381,11 @@ static int do_cros_ec(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 
        cmd = argv[1];
        if (0 == strcmp("init", cmd)) {
-#ifdef CONFIG_DM_CROS_EC
                /* Remove any existing device */
                ret = uclass_find_device(UCLASS_CROS_EC, 0, &udev);
                if (!ret)
                        device_remove(udev);
                ret = uclass_get_device(UCLASS_CROS_EC, 0, &udev);
-#else
-               ret = cros_ec_init(gd->fdt_blob, &dev);
-#endif
                if (ret) {
                        printf("Could not init cros_ec device (err %d)\n", ret);
                        return 1;
@@ -1622,21 +1393,12 @@ static int do_cros_ec(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
                return 0;
        }
 
-#ifdef CONFIG_DM_CROS_EC
        ret = uclass_get_device(UCLASS_CROS_EC, 0, &udev);
        if (ret) {
                printf("Cannot get cros-ec device (err=%d)\n", ret);
                return 1;
        }
        dev = dev_get_uclass_priv(udev);
-#else
-       /* Just use the last allocated device; there should be only one */
-       if (!last_dev) {
-               printf("No CROS-EC device available\n");
-               return 1;
-       }
-       dev = last_dev;
-#endif
        if (0 == strcmp("id", cmd)) {
                char id[MSG_BYTES];
 
@@ -1894,10 +1656,8 @@ U_BOOT_CMD(
 );
 #endif
 
-#ifdef CONFIG_DM_CROS_EC
 UCLASS_DRIVER(cros_ec) = {
        .id             = UCLASS_CROS_EC,
        .name           = "cros_ec",
        .per_device_auto_alloc_size = sizeof(struct cros_ec_dev),
 };
-#endif
index b94501e474217f5444c2bf7da9aebf86066c4e0b..ef6e6820974c155b91ee113c419f332f15e9731c 100644 (file)
@@ -41,18 +41,11 @@ static int wait_for_sync(struct cros_ec_dev *dev)
        return 0;
 }
 
-#ifdef CONFIG_DM_CROS_EC
 int cros_ec_lpc_command(struct udevice *udev, uint8_t cmd, int cmd_version,
                     const uint8_t *dout, int dout_len,
                     uint8_t **dinp, int din_len)
 {
        struct cros_ec_dev *dev = dev_get_uclass_priv(udev);
-#else
-int cros_ec_lpc_command(struct cros_ec_dev *dev, uint8_t cmd, int cmd_version,
-                    const uint8_t *dout, int dout_len,
-                    uint8_t **dinp, int din_len)
-{
-#endif
        const int cmd_addr = EC_LPC_ADDR_HOST_CMD;
        const int data_addr = EC_LPC_ADDR_HOST_DATA;
        const int args_addr = EC_LPC_ADDR_HOST_ARGS;
@@ -187,11 +180,7 @@ int cros_ec_lpc_init(struct cros_ec_dev *dev, const void *blob)
  * seeing whether the EC sets the EC_HOST_ARGS_FLAG_FROM_HOST flag
  * in args when it responds.
  */
-#ifdef CONFIG_DM_CROS_EC
 static int cros_ec_lpc_check_version(struct udevice *dev)
-#else
-int cros_ec_lpc_check_version(struct cros_ec_dev *dev)
-#endif
 {
        if (inb(EC_LPC_ADDR_MEMMAP + EC_MEMMAP_ID) == 'E' &&
                        inb(EC_LPC_ADDR_MEMMAP + EC_MEMMAP_ID + 1)
@@ -206,7 +195,6 @@ int cros_ec_lpc_check_version(struct cros_ec_dev *dev)
        return -1;
 }
 
-#ifdef CONFIG_DM_CROS_EC
 static int cros_ec_probe(struct udevice *dev)
 {
        return cros_ec_register(dev);
@@ -229,4 +217,3 @@ U_BOOT_DRIVER(cros_ec_lpc) = {
        .probe          = cros_ec_probe,
        .ops            = &cros_ec_ops,
 };
-#endif
index 282d8d843f645bd77fc401f7d8c9da4fab59b717..fa7d669ca7a10c00c7c8d13eb8c09bc21eea8745 100644 (file)
@@ -467,17 +467,10 @@ static int process_cmd(struct ec_state *ec,
        return len;
 }
 
-#ifdef CONFIG_DM_CROS_EC
 int cros_ec_sandbox_packet(struct udevice *udev, int out_bytes, int in_bytes)
 {
        struct cros_ec_dev *dev = dev_get_uclass_priv(udev);
        struct ec_state *ec = dev_get_priv(dev->dev);
-#else
-int cros_ec_sandbox_packet(struct cros_ec_dev *dev, int out_bytes,
-                          int in_bytes)
-{
-       struct ec_state *ec = &s_state;
-#endif
        struct ec_host_request *req_hdr = (struct ec_host_request *)dev->dout;
        const void *req_data = req_hdr + 1;
        struct ec_host_response *resp_hdr = (struct ec_host_response *)dev->din;
@@ -500,18 +493,9 @@ int cros_ec_sandbox_packet(struct cros_ec_dev *dev, int out_bytes,
        return in_bytes;
 }
 
-int cros_ec_sandbox_decode_fdt(struct cros_ec_dev *dev, const void *blob)
-{
-       return 0;
-}
-
 void cros_ec_check_keyboard(struct cros_ec_dev *dev)
 {
-#ifdef CONFIG_DM_CROS_EC
        struct ec_state *ec = dev_get_priv(dev->dev);
-#else
-       struct ec_state *ec = &s_state;
-#endif
        ulong start;
 
        printf("Press keys for EC to detect on reset (ESC=recovery)...");
@@ -525,7 +509,6 @@ void cros_ec_check_keyboard(struct cros_ec_dev *dev)
        }
 }
 
-#ifdef CONFIG_DM_CROS_EC
 int cros_ec_probe(struct udevice *dev)
 {
        struct ec_state *ec = dev->priv;
@@ -569,61 +552,6 @@ int cros_ec_probe(struct udevice *dev)
        return cros_ec_register(dev);
 }
 
-#else
-
-/**
- * Initialize sandbox EC emulation.
- *
- * @param dev          CROS_EC device
- * @param blob         Device tree blob
- * @return 0 if ok, -1 on error
- */
-int cros_ec_sandbox_init(struct cros_ec_dev *dev, const void *blob)
-{
-       struct ec_state *ec = &s_state;
-       int node;
-       int err;
-
-       node = fdtdec_next_compatible(blob, 0, COMPAT_GOOGLE_CROS_EC);
-       if (node < 0) {
-               debug("Failed to find chrome-ec node'\n");
-               return -1;
-       }
-
-       err = cros_ec_decode_ec_flash(blob, node, &ec->ec_config);
-       if (err)
-               return err;
-
-       node = fdtdec_next_compatible(blob, 0, COMPAT_GOOGLE_CROS_EC_KEYB);
-       if (node < 0) {
-               debug("%s: No cros_ec keyboard found\n", __func__);
-       } else if (keyscan_read_fdt_matrix(ec, blob, node)) {
-               debug("%s: Could not read key matrix\n", __func__);
-               return -1;
-       }
-
-       /* If we loaded EC data, check that the length matches */
-       if (ec->flash_data &&
-           ec->flash_data_len != ec->ec_config.flash.length) {
-               printf("EC data length is %x, expected %x, discarding data\n",
-                      ec->flash_data_len, ec->ec_config.flash.length);
-               os_free(ec->flash_data);
-               ec->flash_data = NULL;
-       }
-
-       /* Otherwise allocate the memory */
-       if (!ec->flash_data) {
-               ec->flash_data_len = ec->ec_config.flash.length;
-               ec->flash_data = os_malloc(ec->flash_data_len);
-               if (!ec->flash_data)
-                       return -ENOMEM;
-       }
-
-       return 0;
-}
-#endif
-
-#ifdef CONFIG_DM_CROS_EC
 struct dm_cros_ec_ops cros_ec_ops = {
        .packet = cros_ec_sandbox_packet,
 };
@@ -641,4 +569,3 @@ U_BOOT_DRIVER(cros_ec_sandbox) = {
        .priv_auto_alloc_size = sizeof(struct ec_state),
        .ops            = &cros_ec_ops,
 };
-#endif
index 8457c80c5efd4264e5943255dc35b83fd520581b..850c09e11da431294d2f819720603be5ba0e8d49 100644 (file)
 #include <cros_ec_message.h>
 #include <asm/gpio.h>
 
-#ifndef CONFIG_DM_CROS_EC
-/* Which interface is the device on? */
-enum cros_ec_interface_t {
-       CROS_EC_IF_NONE,
-       CROS_EC_IF_SPI,
-       CROS_EC_IF_I2C,
-       CROS_EC_IF_LPC, /* Intel Low Pin Count interface */
-       CROS_EC_IF_SANDBOX,
-};
-#endif
-
 /* Our configuration information */
 struct cros_ec_dev {
-#ifdef CONFIG_DM_CROS_EC
        struct udevice *dev;            /* Transport device */
-#else
-       enum cros_ec_interface_t interface;
-       struct spi_slave *spi;          /* Our SPI slave, if using SPI */
-       int node;                       /* Our node */
-       int parent_node;                /* Our parent node (interface) */
-       unsigned int cs;                /* Our chip select */
-       unsigned int addr;              /* Device address (for I2C) */
-       unsigned int bus_num;           /* Bus number (for I2C) */
-       unsigned int max_frequency;     /* Maximum interface frequency */
-#endif
        struct gpio_desc ec_int;        /* GPIO used as EC interrupt line */
        int protocol_version;           /* Protocol version to use */
        int optimise_flash_write;       /* Don't write erased flash blocks */
@@ -240,8 +218,6 @@ int cros_ec_flash_update_rw(struct cros_ec_dev *dev,
  */
 struct cros_ec_dev *board_get_cros_ec_dev(void);
 
-#ifdef CONFIG_DM_CROS_EC
-
 struct dm_cros_ec_ops {
        int (*check_version)(struct udevice *dev);
        int (*command)(struct udevice *dev, uint8_t cmd, int cmd_version,
@@ -255,112 +231,6 @@ struct dm_cros_ec_ops {
 
 int cros_ec_register(struct udevice *dev);
 
-#else /* !CONFIG_DM_CROS_EC */
-
-/* Internal interfaces */
-int cros_ec_i2c_init(struct cros_ec_dev *dev, const void *blob);
-int cros_ec_spi_init(struct cros_ec_dev *dev, const void *blob);
-int cros_ec_lpc_init(struct cros_ec_dev *dev, const void *blob);
-int cros_ec_sandbox_init(struct cros_ec_dev *dev, const void *blob);
-
-/**
- * Read information from the fdt for the i2c cros_ec interface
- *
- * @param dev          CROS-EC device
- * @param blob         Device tree blob
- * @return 0 if ok, -1 if we failed to read all required information
- */
-int cros_ec_i2c_decode_fdt(struct cros_ec_dev *dev, const void *blob);
-
-/**
- * Read information from the fdt for the spi cros_ec interface
- *
- * @param dev          CROS-EC device
- * @param blob         Device tree blob
- * @return 0 if ok, -1 if we failed to read all required information
- */
-int cros_ec_spi_decode_fdt(struct cros_ec_dev *dev, const void *blob);
-
-/**
- * Read information from the fdt for the sandbox cros_ec interface
- *
- * @param dev          CROS-EC device
- * @param blob         Device tree blob
- * @return 0 if ok, -1 if we failed to read all required information
- */
-int cros_ec_sandbox_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->protocol_version accordingly.
- *
- * @param dev          CROS-EC device to check
- */
-int cros_ec_lpc_check_version(struct cros_ec_dev *dev);
-
-/**
- * Send a command to an I2C CROS-EC device and return the reply.
- *
- * This rather complicated function deals with sending both old-style and
- * new-style commands. The old ones have just a command byte and arguments.
- * The new ones have version, command, arg-len, [args], chksum so are 3 bytes
- * longer.
- *
- * The device's internal input/output buffers are used.
- *
- * @param dev          CROS-EC device
- * @param cmd          Command to send (EC_CMD_...)
- * @param cmd_version  Version of command to send (EC_VER_...)
- * @param dout          Output data (may be NULL If dout_len=0)
- * @param dout_len      Size of output data in bytes
- * @param dinp          Returns pointer to response data
- * @param din_len       Maximum size of response in bytes
- * @return number of bytes in response, or -1 on error
- */
-int cros_ec_i2c_command(struct cros_ec_dev *dev, uint8_t cmd, int cmd_version,
-                    const uint8_t *dout, int dout_len,
-                    uint8_t **dinp, int din_len);
-
-/**
- * Send a command to a LPC CROS-EC device and return the reply.
- *
- * The device's internal input/output buffers are used.
- *
- * @param dev          CROS-EC device
- * @param cmd          Command to send (EC_CMD_...)
- * @param cmd_version  Version of command to send (EC_VER_...)
- * @param dout          Output data (may be NULL If dout_len=0)
- * @param dout_len      Size of output data in bytes
- * @param dinp          Returns pointer to response data
- * @param din_len       Maximum size of response in bytes
- * @return number of bytes in response, or -1 on error
- */
-int cros_ec_lpc_command(struct cros_ec_dev *dev, uint8_t cmd, int cmd_version,
-                    const uint8_t *dout, int dout_len,
-                    uint8_t **dinp, int din_len);
-
-int cros_ec_spi_command(struct cros_ec_dev *dev, uint8_t cmd, int cmd_version,
-                    const uint8_t *dout, int dout_len,
-                    uint8_t **dinp, int din_len);
-
-/**
- * Send a packet to a CROS-EC device and return the response packet.
- *
- * Expects the request packet to be stored in dev->dout.  Stores the response
- * packet in dev->din.
- *
- * @param dev          CROS-EC device
- * @param out_bytes    Size of request packet to output
- * @param in_bytes     Maximum size of response packet to receive
- * @return number of bytes in response packet, or <0 on error
- */
-int cros_ec_spi_packet(struct cros_ec_dev *dev, int out_bytes, int in_bytes);
-int cros_ec_sandbox_packet(struct cros_ec_dev *dev, int out_bytes,
-                          int in_bytes);
-#endif
-
 /**
  * Dump a block of data for a command.
  *