qemu

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/module.h"
14
#include "hw/i2c/i2c.h"
15
#include "hw/nvram/eeprom_at24c.h"
16
#include "hw/qdev-properties.h"
17
#include "hw/qdev-properties-system.h"
18
#include "sysemu/block-backend.h"
19
#include "qom/object.h"
20

21
/* #define DEBUG_AT24C */
22

23
#ifdef DEBUG_AT24C
24
#define DPRINTK(FMT, ...) printf(TYPE_AT24C_EE " : " FMT, ## __VA_ARGS__)
25
#else
26
#define DPRINTK(FMT, ...) do {} while (0)
27
#endif
28

29
#define ERR(FMT, ...) fprintf(stderr, TYPE_AT24C_EE " : " FMT, \
30
                            ## __VA_ARGS__)
31

32
#define TYPE_AT24C_EE "at24c-eeprom"
33
typedef struct EEPROMState EEPROMState;
34
DECLARE_INSTANCE_CHECKER(EEPROMState, AT24C_EE,
35
                         TYPE_AT24C_EE)
36

37
struct EEPROMState {
38
    I2CSlave parent_obj;
39

40
    /* address counter */
41
    uint16_t cur;
42
    /* total size in bytes */
43
    uint32_t rsize;
44
    /*
45
     * address byte number
46
     *  for  24c01, 24c02 size <= 256 byte, use only 1 byte
47
     *  otherwise size > 256, use 2 byte
48
     */
49
    uint8_t asize;
50

51
    bool writable;
52
    /* cells changed since last START? */
53
    bool changed;
54
    /* during WRITE, # of address bytes transferred */
55
    uint8_t haveaddr;
56

57
    uint8_t *mem;
58

59
    BlockBackend *blk;
60

61
    const uint8_t *init_rom;
62
    uint32_t init_rom_size;
63
};
64

65
static
66
int at24c_eeprom_event(I2CSlave *s, enum i2c_event event)
67
{
68
    EEPROMState *ee = AT24C_EE(s);
69

70
    switch (event) {
71
    case I2C_START_SEND:
72
    case I2C_FINISH:
73
        ee->haveaddr = 0;
74
        /* fallthrough */
75
    case I2C_START_RECV:
76
        DPRINTK("clear\n");
77
        if (ee->blk && ee->changed) {
78
            int ret = blk_pwrite(ee->blk, 0, ee->rsize, ee->mem, 0);
79
            if (ret < 0) {
80
                ERR(TYPE_AT24C_EE
81
                        " : failed to write backing file\n");
82
            }
83
            DPRINTK("Wrote to backing file\n");
84
        }
85
        ee->changed = false;
86
        break;
87
    case I2C_NACK:
88
        break;
89
    default:
90
        return -1;
91
    }
92
    return 0;
93
}
94

95
static
96
uint8_t at24c_eeprom_recv(I2CSlave *s)
97
{
98
    EEPROMState *ee = AT24C_EE(s);
99
    uint8_t ret;
100

101
    /*
102
     * If got the byte address but not completely with address size
103
     * will return the invalid value
104
     */
105
    if (ee->haveaddr > 0 && ee->haveaddr < ee->asize) {
106
        return 0xff;
107
    }
108

109
    ret = ee->mem[ee->cur];
110

111
    ee->cur = (ee->cur + 1u) % ee->rsize;
112
    DPRINTK("Recv %02x %c\n", ret, ret);
113

114
    return ret;
115
}
116

117
static
118
int at24c_eeprom_send(I2CSlave *s, uint8_t data)
119
{
120
    EEPROMState *ee = AT24C_EE(s);
121

122
    if (ee->haveaddr < ee->asize) {
123
        ee->cur <<= 8;
124
        ee->cur |= data;
125
        ee->haveaddr++;
126
        if (ee->haveaddr == ee->asize) {
127
            ee->cur %= ee->rsize;
128
            DPRINTK("Set pointer %04x\n", ee->cur);
129
        }
130

131
    } else {
132
        if (ee->writable) {
133
            DPRINTK("Send %02x\n", data);
134
            ee->mem[ee->cur] = data;
135
            ee->changed = true;
136
        } else {
137
            DPRINTK("Send error %02x read-only\n", data);
138
        }
139
        ee->cur = (ee->cur + 1u) % ee->rsize;
140

141
    }
142

143
    return 0;
144
}
145

146
I2CSlave *at24c_eeprom_init(I2CBus *bus, uint8_t address, uint32_t rom_size)
147
{
148
    return at24c_eeprom_init_rom(bus, address, rom_size, NULL, 0);
149
}
150

151
I2CSlave *at24c_eeprom_init_rom(I2CBus *bus, uint8_t address, uint32_t rom_size,
152
                                const uint8_t *init_rom, uint32_t init_rom_size)
153
{
154
    EEPROMState *s;
155

156
    s = AT24C_EE(i2c_slave_new(TYPE_AT24C_EE, address));
157

158
    qdev_prop_set_uint32(DEVICE(s), "rom-size", rom_size);
159

160
    /* TODO: Model init_rom with QOM properties. */
161
    s->init_rom = init_rom;
162
    s->init_rom_size = init_rom_size;
163

164
    i2c_slave_realize_and_unref(I2C_SLAVE(s), bus, &error_abort);
165

166
    return I2C_SLAVE(s);
167
}
168

169
static void at24c_eeprom_realize(DeviceState *dev, Error **errp)
170
{
171
    EEPROMState *ee = AT24C_EE(dev);
172

173
    if (ee->init_rom_size > ee->rsize) {
174
        error_setg(errp, "%s: init rom is larger than rom: %u > %u",
175
                   TYPE_AT24C_EE, ee->init_rom_size, ee->rsize);
176
        return;
177
    }
178

179
    if (ee->blk) {
180
        int64_t len = blk_getlength(ee->blk);
181

182
        if (len != ee->rsize) {
183
            error_setg(errp, "%s: Backing file size %" PRId64 " != %u",
184
                       TYPE_AT24C_EE, len, ee->rsize);
185
            return;
186
        }
187

188
        if (blk_set_perm(ee->blk, BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE,
189
                         BLK_PERM_ALL, &error_fatal) < 0)
190
        {
191
            error_setg(errp, "%s: Backing file incorrect permission",
192
                       TYPE_AT24C_EE);
193
            return;
194
        }
195
    }
196

197
    ee->mem = g_malloc0(ee->rsize);
198
    memset(ee->mem, 0, ee->rsize);
199

200
    if (ee->init_rom) {
201
        memcpy(ee->mem, ee->init_rom, MIN(ee->init_rom_size, ee->rsize));
202
    }
203

204
    if (ee->blk) {
205
        int ret = blk_pread(ee->blk, 0, ee->rsize, ee->mem, 0);
206

207
        if (ret < 0) {
208
            ERR(TYPE_AT24C_EE
209
                    " : Failed initial sync with backing file\n");
210
        }
211
        DPRINTK("Reset read backing file\n");
212
    }
213

214
    /*
215
     * If address size didn't define with property set
216
     *   value is 0 as default, setting it by Rom size detecting.
217
     */
218
    if (ee->asize == 0) {
219
        if (ee->rsize <= 256) {
220
            ee->asize = 1;
221
        } else {
222
            ee->asize = 2;
223
        }
224
    }
225
}
226

227
static
228
void at24c_eeprom_reset(DeviceState *state)
229
{
230
    EEPROMState *ee = AT24C_EE(state);
231

232
    ee->changed = false;
233
    ee->cur = 0;
234
    ee->haveaddr = 0;
235
}
236

237
static Property at24c_eeprom_props[] = {
238
    DEFINE_PROP_UINT32("rom-size", EEPROMState, rsize, 0),
239
    DEFINE_PROP_UINT8("address-size", EEPROMState, asize, 0),
240
    DEFINE_PROP_BOOL("writable", EEPROMState, writable, true),
241
    DEFINE_PROP_DRIVE("drive", EEPROMState, blk),
242
    DEFINE_PROP_END_OF_LIST()
243
};
244

245
static
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
    dc->reset = 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

269
static void at24c_eeprom_register(void)
270
{
271
    type_register_static(&at24c_eeprom_type);
272
}
273

274
type_init(at24c_eeprom_register)
275