drivers/misc/i2c_eeprom_emul.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Simulate an I2C eeprom
   4  *
   5  * Copyright (c) 2014 Google, Inc
   6  */
   7
   8 #include <common.h>
   9 #include <dm.h>
  10 #include <errno.h>
  11 #include <i2c.h>
  12 #include <malloc.h>
  13 #include <asm/test.h>
  14
  15 #ifdef DEBUG
  16 #define debug_buffer print_buffer
  17 #else
  18 #define debug_buffer(x, ...)
  19 #endif
  20
  21 struct sandbox_i2c_flash_plat_data {
  22         enum sandbox_i2c_eeprom_test_mode test_mode;
  23         const char *filename;
  24         int offset_len;         /* Length of an offset in bytes */
  25         int size;               /* Size of data buffer */
  26         uint chip_addr_offset_mask; /* mask of addr bits used for offset */
  27 };
  28
  29 struct sandbox_i2c_flash {
  30         uint8_t *data;
  31         uint prev_addr;         /* slave address of previous access */
  32         uint prev_offset;       /* offset of previous access */
  33 };
  34
  35 void sandbox_i2c_eeprom_set_test_mode(struct udevice *dev,
  36                                       enum sandbox_i2c_eeprom_test_mode mode)
  37 {
  38         struct sandbox_i2c_flash_plat_data *plat = dev_get_platdata(dev);
  39
  40         plat->test_mode = mode;
  41 }
  42
  43 void sandbox_i2c_eeprom_set_offset_len(struct udevice *dev, int offset_len)
  44 {
  45         struct sandbox_i2c_flash_plat_data *plat = dev_get_platdata(dev);
  46
  47         plat->offset_len = offset_len;
  48 }
  49
  50 void sandbox_i2c_eeprom_set_chip_addr_offset_mask(struct udevice *dev,
  51                                                   uint mask)
  52 {
  53         struct sandbox_i2c_flash_plat_data *plat = dev_get_platdata(dev);
  54
  55         plat->chip_addr_offset_mask = mask;
  56 }
  57
  58 uint sanbox_i2c_eeprom_get_prev_addr(struct udevice *dev)
  59 {
  60         struct sandbox_i2c_flash *priv = dev_get_priv(dev);
  61
  62         return priv->prev_addr;
  63 }
  64
  65 uint sanbox_i2c_eeprom_get_prev_offset(struct udevice *dev)
  66 {
  67         struct sandbox_i2c_flash *priv = dev_get_priv(dev);
  68
  69         return priv->prev_offset;
  70 }
  71
  72 static int sandbox_i2c_eeprom_xfer(struct udevice *emul, struct i2c_msg *msg,
  73                                   int nmsgs)
  74 {
  75         struct sandbox_i2c_flash *priv = dev_get_priv(emul);
  76         struct sandbox_i2c_flash_plat_data *plat = dev_get_platdata(emul);
  77         uint offset = msg->addr & plat->chip_addr_offset_mask;
  78
  79         debug("\n%s\n", __func__);
  80         debug_buffer(0, priv->data, 1, 16, 0);
  81
  82         /* store addr for testing visibity */
  83         priv->prev_addr = msg->addr;
  84
  85         for (; nmsgs > 0; nmsgs--, msg++) {
  86                 int len;
  87                 u8 *ptr;
  88
  89                 if (!plat->size)
  90                         return -ENODEV;
  91                 len = msg->len;
  92                 debug("   %s: msg->addr=%x msg->len=%d",
  93                       msg->flags & I2C_M_RD ? "read" : "write",
  94                       msg->addr, msg->len);
  95                 if (msg->flags & I2C_M_RD) {
  96                         if (plat->test_mode == SIE_TEST_MODE_SINGLE_BYTE)
  97                                 len = 1;
  98                         debug(", offset %x, len %x: ", offset, len);
  99                         if (offset + len > plat->size) {
 100                                 int overflow = offset + len - plat->size;
 101                                 int initial = len - overflow;
 102
 103                                 memcpy(msg->buf, priv->data + offset, initial);
 104                                 memcpy(msg->buf + initial, priv->data,
 105                                        overflow);
 106                         } else {
 107                                 memcpy(msg->buf, priv->data + offset, len);
 108                         }
 109                         memset(msg->buf + len, '\xff', msg->len - len);
 110                         debug_buffer(0, msg->buf, 1, msg->len, 0);
 111                 } else if (len >= plat->offset_len) {
 112                         int i;
 113
 114                         ptr = msg->buf;
 115                         for (i = 0; i < plat->offset_len; i++, len--)
 116                                 offset = (offset << 8) | *ptr++;
 117                         debug(", set offset %x: ", offset);
 118                         debug_buffer(0, msg->buf, 1, msg->len, 0);
 119                         if (plat->test_mode == SIE_TEST_MODE_SINGLE_BYTE)
 120                                 len = min(len, 1);
 121
 122                         /* store offset for testing visibility */
 123                         priv->prev_offset = offset;
 124
 125                         /* For testing, map offsets into our limited buffer.
 126                          * offset wraps every 256 bytes
 127                          */
 128                         offset &= 0xff;
 129                         debug("mapped offset to %x\n", offset);
 130
 131                         if (offset + len > plat->size) {
 132                                 int overflow = offset + len - plat->size;
 133                                 int initial = len - overflow;
 134
 135                                 memcpy(priv->data + offset, ptr, initial);
 136                                 memcpy(priv->data, ptr + initial, overflow);
 137                         } else {
 138                                 memcpy(priv->data + offset, ptr, len);
 139                         }
 140                 }
 141         }
 142         debug_buffer(0, priv->data, 1, 16, 0);
 143
 144         return 0;
 145 }
 146
 147 struct dm_i2c_ops sandbox_i2c_emul_ops = {
 148         .xfer = sandbox_i2c_eeprom_xfer,
 149 };
 150
 151 static int sandbox_i2c_eeprom_ofdata_to_platdata(struct udevice *dev)
 152 {
 153         struct sandbox_i2c_flash_plat_data *plat = dev_get_platdata(dev);
 154
 155         plat->size = dev_read_u32_default(dev, "sandbox,size", 32);
 156         plat->filename = dev_read_string(dev, "sandbox,filename");
 157         if (!plat->filename) {
 158                 debug("%s: No filename for device '%s'\n", __func__,
 159                       dev->name);
 160                 return -EINVAL;
 161         }
 162         plat->test_mode = SIE_TEST_MODE_NONE;
 163         plat->offset_len = 1;
 164         plat->chip_addr_offset_mask = 0;
 165
 166         return 0;
 167 }
 168
 169 static int sandbox_i2c_eeprom_probe(struct udevice *dev)
 170 {
 171         struct sandbox_i2c_flash_plat_data *plat = dev_get_platdata(dev);
 172         struct sandbox_i2c_flash *priv = dev_get_priv(dev);
 173
 174         priv->data = calloc(1, plat->size);
 175         if (!priv->data)
 176                 return -ENOMEM;
 177
 178         return 0;
 179 }
 180
 181 static int sandbox_i2c_eeprom_remove(struct udevice *dev)
 182 {
 183         struct sandbox_i2c_flash *priv = dev_get_priv(dev);
 184
 185         free(priv->data);
 186
 187         return 0;
 188 }
 189
 190 static const struct udevice_id sandbox_i2c_ids[] = {
 191         { .compatible = "sandbox,i2c-eeprom" },
 192         { }
 193 };
 194
 195 U_BOOT_DRIVER(sandbox_i2c_emul) = {
 196         .name           = "sandbox_i2c_eeprom_emul",
 197         .id             = UCLASS_I2C_EMUL,
 198         .of_match       = sandbox_i2c_ids,
 199         .ofdata_to_platdata = sandbox_i2c_eeprom_ofdata_to_platdata,
 200         .probe          = sandbox_i2c_eeprom_probe,
 201         .remove         = sandbox_i2c_eeprom_remove,
 202         .priv_auto_alloc_size = sizeof(struct sandbox_i2c_flash),
 203         .platdata_auto_alloc_size = sizeof(struct sandbox_i2c_flash_plat_data),
 204         .ops            = &sandbox_i2c_emul_ops,
 205 };