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