LXR uboot/drivers/i2c/sandbox

   1/*
   2 * Simulate an I2C port
   3 *
   4 * Copyright (c) 2014 Google, Inc
   5 *
   6 * SPDX-License-Identifier:     GPL-2.0+
   7 */
   8
   9#include <common.h>
  10#include <dm.h>
  11#include <errno.h>
  12#include <fdtdec.h>
  13#include <i2c.h>
  14#include <asm/test.h>
  15#include <dm/lists.h>
  16#include <dm/device-internal.h>
  17#include <dm/root.h>
  18
  19DECLARE_GLOBAL_DATA_PTR;
  20
  21struct sandbox_i2c_priv {
  22        bool test_mode;
  23};
  24
  25static int get_emul(struct udevice *dev, struct udevice **devp,
  26                    struct dm_i2c_ops **opsp)
  27{
  28        struct dm_i2c_chip *plat;
  29        struct udevice *child;
  30        int ret;
  31
  32        *devp = NULL;
  33        *opsp = NULL;
  34        plat = dev_get_parent_platdata(dev);
  35        if (!plat->emul) {
  36                ret = dm_scan_fdt_node(dev, gd->fdt_blob, dev->of_offset,
  37                                       false);
  38                if (ret)
  39                        return ret;
  40
  41                for (device_find_first_child(dev, &child); child;
  42                     device_find_next_child(&child)) {
  43                        if (device_get_uclass_id(child) != UCLASS_I2C_EMUL)
  44                                continue;
  45
  46                        ret = device_probe(child);
  47                        if (ret)
  48                                return ret;
  49
  50                        break;
  51                }
  52
  53                if (child)
  54                        plat->emul = child;
  55                else
  56                        return -ENODEV;
  57        }
  58        *devp = plat->emul;
  59        *opsp = i2c_get_ops(plat->emul);
  60
  61        return 0;
  62}
  63
  64void sandbox_i2c_set_test_mode(struct udevice *bus, bool test_mode)
  65{
  66        struct sandbox_i2c_priv *priv = dev_get_priv(bus);
  67
  68        priv->test_mode = test_mode;
  69}
  70
  71static int sandbox_i2c_xfer(struct udevice *bus, struct i2c_msg *msg,
  72                            int nmsgs)
  73{
  74        struct dm_i2c_bus *i2c = dev_get_uclass_priv(bus);
  75        struct sandbox_i2c_priv *priv = dev_get_priv(bus);
  76        struct dm_i2c_ops *ops;
  77        struct udevice *emul, *dev;
  78        bool is_read;
  79        int ret;
  80
  81        /* Special test code to return success but with no emulation */
  82        if (priv->test_mode && msg->addr == SANDBOX_I2C_TEST_ADDR)
  83                return 0;
  84
  85        ret = i2c_get_chip(bus, msg->addr, 1, &dev);
  86        if (ret)
  87                return ret;
  88
  89        ret = get_emul(dev, &emul, &ops);
  90        if (ret)
  91                return ret;
  92
  93        if (priv->test_mode) {
  94                /*
  95                * For testing, don't allow writing above 100KHz for writes and
  96                * 400KHz for reads.
  97                */
  98                is_read = nmsgs > 1;
  99                if (i2c->speed_hz > (is_read ? 400000 : 100000)) {
 100                        debug("%s: Max speed exceeded\n", __func__);
 101                        return -EINVAL;
 102                }
 103        }
 104
 105        return ops->xfer(emul, msg, nmsgs);
 106}
 107
 108static const struct dm_i2c_ops sandbox_i2c_ops = {
 109        .xfer           = sandbox_i2c_xfer,
 110};
 111
 112static const struct udevice_id sandbox_i2c_ids[] = {
 113        { .compatible = "sandbox,i2c" },
 114        { }
 115};
 116
 117U_BOOT_DRIVER(i2c_sandbox) = {
 118        .name   = "i2c_sandbox",
 119        .id     = UCLASS_I2C,
 120        .of_match = sandbox_i2c_ids,
 121        .ops    = &sandbox_i2c_ops,
 122        .priv_auto_alloc_size = sizeof(struct sandbox_i2c_priv),
 123};
 124