1 /*
2 * *AT24C* series I2C EEPROM
3 *
4 * Copyright (c) 2015 Michael Davidsaver
5 *
6 * This work is licensed under the terms of the GNU GPL, version 2. See
7 * the LICENSE file in the top-level directory.
8 */
9
10 #include "qemu/osdep.h"
11
12 #include "qapi/error.h"
13 #include "qemu/error-report.h"
14 #include "qemu/module.h"
15 #include "hw/i2c/i2c.h"
16 #include "hw/nvram/eeprom_at24c.h"
17 #include "hw/qdev-properties.h"
18 #include "hw/qdev-properties-system.h"
19 #include "system/block-backend.h"
20 #include "qom/object.h"
21
22 /* #define DEBUG_AT24C */
23
24 #ifdef DEBUG_AT24C
25 #define DPRINTK(FMT, ...) printf(TYPE_AT24C_EE " : " FMT, ## __VA_ARGS__)
26 #else
27 #define DPRINTK(FMT, ...) do {} while (0)
28 #endif
29
30 #define TYPE_AT24C_EE "at24c-eeprom"
31 OBJECT_DECLARE_SIMPLE_TYPE(EEPROMState, AT24C_EE)
32
33 struct EEPROMState {
34 I2CSlave parent_obj;
35
36 /* address counter */
37 uint16_t cur;
38 /* total size in bytes */
39 uint32_t rsize;
40 /*
41 * address byte number
42 * for 24c01, 24c02 size <= 256 byte, use only 1 byte
43 * otherwise size > 256, use 2 byte
44 */
45 uint8_t asize;
46
47 bool writable;
48 /* cells changed since last START? */
49 bool changed;
50 /* during WRITE, # of address bytes transferred */
51 uint8_t haveaddr;
52
53 uint8_t *mem;
54
55 BlockBackend *blk;
56
57 const uint8_t *init_rom;
58 uint32_t init_rom_size;
59 };
60
61 static
at24c_eeprom_event(I2CSlave * s,enum i2c_event event)62 int at24c_eeprom_event(I2CSlave *s, enum i2c_event event)
63 {
64 EEPROMState *ee = AT24C_EE(s);
65
66 switch (event) {
67 case I2C_START_SEND:
68 case I2C_FINISH:
69 ee->haveaddr = 0;
70 /* fallthrough */
71 case I2C_START_RECV:
72 DPRINTK("clear\n");
73 if (ee->blk && ee->changed) {
74 int ret = blk_pwrite(ee->blk, 0, ee->rsize, ee->mem, 0);
75 if (ret < 0) {
76 error_report("%s: failed to write backing file", __func__);
77 }
78 DPRINTK("Wrote to backing file\n");
79 }
80 ee->changed = false;
81 break;
82 case I2C_NACK:
83 break;
84 default:
85 return -1;
86 }
87 return 0;
88 }
89
90 static
at24c_eeprom_recv(I2CSlave * s)91 uint8_t at24c_eeprom_recv(I2CSlave *s)
92 {
93 EEPROMState *ee = AT24C_EE(s);
94 uint8_t ret;
95
96 if (ee->haveaddr > 0 && ee->haveaddr < ee->asize) {
97 /*
98 * Provide behaviour that aligns with NVMe MI 1.2c, section 8.2.
99 *
100 * https://nvmexpress.org/wp-content/uploads/NVM-Express-Management-Interface-Specification-1.2c-2022.10.06-Ratified.pdf
101 *
102 * Otherwise, the clocked-out data is meaningless anyway, and so reading
103 * off memory is as good a behaviour as anything. This also happens to
104 * help the address-width detection heuristic in OpenBMC's userspace.
105 *
106 * https://github.com/openbmc/entity-manager/blob/0422a24bb6033605ce75479f675fedc76abb1167/src/fru_device.cpp#L197-L229
107 */
108 ee->haveaddr = ee->asize;
109 ee->cur %= ee->rsize;
110 }
111
112 ret = ee->mem[ee->cur];
113
114 ee->cur = (ee->cur + 1u) % ee->rsize;
115 DPRINTK("Recv %02x %c\n", ret, ret);
116
117 return ret;
118 }
119
120 static
at24c_eeprom_send(I2CSlave * s,uint8_t data)121 int at24c_eeprom_send(I2CSlave *s, uint8_t data)
122 {
123 EEPROMState *ee = AT24C_EE(s);
124
125 if (ee->haveaddr < ee->asize) {
126 ee->cur <<= 8;
127 ee->cur |= data;
128 ee->haveaddr++;
129 if (ee->haveaddr == ee->asize) {
130 ee->cur %= ee->rsize;
131 DPRINTK("Set pointer %04x\n", ee->cur);
132 }
133
134 } else {
135 if (ee->writable) {
136 DPRINTK("Send %02x\n", data);
137 ee->mem[ee->cur] = data;
138 ee->changed = true;
139 } else {
140 DPRINTK("Send error %02x read-only\n", data);
141 }
142 ee->cur = (ee->cur + 1u) % ee->rsize;
143
144 }
145
146 return 0;
147 }
148
at24c_eeprom_init(I2CBus * bus,uint8_t address,uint32_t rom_size)149 I2CSlave *at24c_eeprom_init(I2CBus *bus, uint8_t address, uint32_t rom_size)
150 {
151 return at24c_eeprom_init_rom(bus, address, rom_size, NULL, 0);
152 }
153
at24c_eeprom_init_rom(I2CBus * bus,uint8_t address,uint32_t rom_size,const uint8_t * init_rom,uint32_t init_rom_size)154 I2CSlave *at24c_eeprom_init_rom(I2CBus *bus, uint8_t address, uint32_t rom_size,
155 const uint8_t *init_rom, uint32_t init_rom_size)
156 {
157 EEPROMState *s;
158
159 s = AT24C_EE(i2c_slave_new(TYPE_AT24C_EE, address));
160
161 qdev_prop_set_uint32(DEVICE(s), "rom-size", rom_size);
162
163 /* TODO: Model init_rom with QOM properties. */
164 s->init_rom = init_rom;
165 s->init_rom_size = init_rom_size;
166
167 i2c_slave_realize_and_unref(I2C_SLAVE(s), bus, &error_abort);
168
169 return I2C_SLAVE(s);
170 }
171
at24c_eeprom_realize(DeviceState * dev,Error ** errp)172 static void at24c_eeprom_realize(DeviceState *dev, Error **errp)
173 {
174 EEPROMState *ee = AT24C_EE(dev);
175
176 if (ee->init_rom_size > ee->rsize) {
177 error_setg(errp, "%s: init rom is larger than rom: %u > %u",
178 TYPE_AT24C_EE, ee->init_rom_size, ee->rsize);
179 return;
180 }
181
182 if (ee->blk) {
183 int64_t len = blk_getlength(ee->blk);
184
185 if (len != ee->rsize) {
186 error_setg(errp, "%s: Backing file size %" PRId64 " != %u",
187 TYPE_AT24C_EE, len, ee->rsize);
188 return;
189 }
190
191 if (blk_set_perm(ee->blk, BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE,
192 BLK_PERM_ALL, &error_fatal) < 0)
193 {
194 error_setg(errp, "%s: Backing file incorrect permission",
195 TYPE_AT24C_EE);
196 return;
197 }
198 }
199
200 ee->mem = g_malloc0(ee->rsize);
201
202 if (ee->blk) {
203 int ret = blk_pread(ee->blk, 0, ee->rsize, ee->mem, 0);
204
205 if (ret < 0) {
206 error_setg(errp, "%s: Failed initial sync with backing file",
207 TYPE_AT24C_EE);
208 return;
209 }
210 DPRINTK("Reset read backing file\n");
211 } else if (ee->init_rom) {
212 memcpy(ee->mem, ee->init_rom, MIN(ee->init_rom_size, ee->rsize));
213 }
214
215 /*
216 * If address size didn't define with property set
217 * value is 0 as default, setting it by Rom size detecting.
218 */
219 if (ee->asize == 0) {
220 if (ee->rsize <= 256) {
221 ee->asize = 1;
222 } else {
223 ee->asize = 2;
224 }
225 }
226 }
227
228 static
at24c_eeprom_reset(DeviceState * state)229 void at24c_eeprom_reset(DeviceState *state)
230 {
231 EEPROMState *ee = AT24C_EE(state);
232
233 ee->changed = false;
234 ee->cur = 0;
235 ee->haveaddr = 0;
236 }
237
238 static const Property at24c_eeprom_props[] = {
239 DEFINE_PROP_UINT32("rom-size", EEPROMState, rsize, 0),
240 DEFINE_PROP_UINT8("address-size", EEPROMState, asize, 0),
241 DEFINE_PROP_BOOL("writable", EEPROMState, writable, true),
242 DEFINE_PROP_DRIVE("drive", EEPROMState, blk),
243 };
244
245 static
at24c_eeprom_class_init(ObjectClass * klass,void * data)246 void at24c_eeprom_class_init(ObjectClass *klass, void *data)
247 {
248 DeviceClass *dc = DEVICE_CLASS(klass);
249 I2CSlaveClass *k = I2C_SLAVE_CLASS(klass);
250
251 dc->realize = &at24c_eeprom_realize;
252 k->event = &at24c_eeprom_event;
253 k->recv = &at24c_eeprom_recv;
254 k->send = &at24c_eeprom_send;
255
256 device_class_set_props(dc, at24c_eeprom_props);
257 device_class_set_legacy_reset(dc, at24c_eeprom_reset);
258 }
259
260 static
261 const TypeInfo at24c_eeprom_type = {
262 .name = TYPE_AT24C_EE,
263 .parent = TYPE_I2C_SLAVE,
264 .instance_size = sizeof(EEPROMState),
265 .class_size = sizeof(I2CSlaveClass),
266 .class_init = at24c_eeprom_class_init,
267 };
268
at24c_eeprom_register(void)269 static void at24c_eeprom_register(void)
270 {
271 type_register_static(&at24c_eeprom_type);
272 }
273
274 type_init(at24c_eeprom_register)
275