hw/nvram/eeprom_at24c.c

   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/qdev-properties.h"
  16 #include "sysemu/block-backend.h"
  17
  18 /* #define DEBUG_AT24C */
  19
  20 #ifdef DEBUG_AT24C
  21 #define DPRINTK(FMT, ...) printf(TYPE_AT24C_EE " : " FMT, ## __VA_ARGS__)
  22 #else
  23 #define DPRINTK(FMT, ...) do {} while (0)
  24 #endif
  25
  26 #define ERR(FMT, ...) fprintf(stderr, TYPE_AT24C_EE " : " FMT, \
  27                             ## __VA_ARGS__)
  28
  29 #define TYPE_AT24C_EE "at24c-eeprom"
  30 #define AT24C_EE(obj) OBJECT_CHECK(EEPROMState, (obj), TYPE_AT24C_EE)
  31
  32 typedef struct EEPROMState {
  33     I2CSlave parent_obj;
  34
  35     /* address counter */
  36     uint16_t cur;
  37     /* total size in bytes */
  38     uint32_t rsize;
  39     bool writable;
  40     /* cells changed since last START? */
  41     bool changed;
  42     /* during WRITE, # of address bytes transfered */
  43     uint8_t haveaddr;
  44
  45     uint8_t *mem;
  46
  47     BlockBackend *blk;
  48 } EEPROMState;
  49
  50 static
  51 int at24c_eeprom_event(I2CSlave *s, enum i2c_event event)
  52 {
  53     EEPROMState *ee = container_of(s, EEPROMState, parent_obj);
  54
  55     switch (event) {
  56     case I2C_START_SEND:
  57     case I2C_START_RECV:
  58     case I2C_FINISH:
  59         ee->haveaddr = 0;
  60         DPRINTK("clear\n");
  61         if (ee->blk && ee->changed) {
  62             int len = blk_pwrite(ee->blk, 0, ee->mem, ee->rsize, 0);
  63             if (len != ee->rsize) {
  64                 ERR(TYPE_AT24C_EE
  65                         " : failed to write backing file\n");
  66             }
  67             DPRINTK("Wrote to backing file\n");
  68         }
  69         ee->changed = false;
  70         break;
  71     case I2C_NACK:
  72         break;
  73     }
  74     return 0;
  75 }
  76
  77 static
  78 uint8_t at24c_eeprom_recv(I2CSlave *s)
  79 {
  80     EEPROMState *ee = AT24C_EE(s);
  81     uint8_t ret;
  82
  83     ret = ee->mem[ee->cur];
  84
  85     ee->cur = (ee->cur + 1u) % ee->rsize;
  86     DPRINTK("Recv %02x %c\n", ret, ret);
  87
  88     return ret;
  89 }
  90
  91 static
  92 int at24c_eeprom_send(I2CSlave *s, uint8_t data)
  93 {
  94     EEPROMState *ee = AT24C_EE(s);
  95
  96     if (ee->haveaddr < 2) {
  97         ee->cur <<= 8;
  98         ee->cur |= data;
  99         ee->haveaddr++;
 100         if (ee->haveaddr == 2) {
 101             ee->cur %= ee->rsize;
 102             DPRINTK("Set pointer %04x\n", ee->cur);
 103         }
 104
 105     } else {
 106         if (ee->writable) {
 107             DPRINTK("Send %02x\n", data);
 108             ee->mem[ee->cur] = data;
 109             ee->changed = true;
 110         } else {
 111             DPRINTK("Send error %02x read-only\n", data);
 112         }
 113         ee->cur = (ee->cur + 1u) % ee->rsize;
 114
 115     }
 116
 117     return 0;
 118 }
 119
 120 static void at24c_eeprom_realize(DeviceState *dev, Error **errp)
 121 {
 122     EEPROMState *ee = AT24C_EE(dev);
 123
 124     if (ee->blk) {
 125         int64_t len = blk_getlength(ee->blk);
 126
 127         if (len != ee->rsize) {
 128             error_setg(errp, "%s: Backing file size %" PRId64 " != %u",
 129                        TYPE_AT24C_EE, len, ee->rsize);
 130             return;
 131         }
 132
 133         if (blk_set_perm(ee->blk, BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE,
 134                          BLK_PERM_ALL, &error_fatal) < 0)
 135         {
 136             error_setg(errp, "%s: Backing file incorrect permission",
 137                        TYPE_AT24C_EE);
 138             return;
 139         }
 140     }
 141
 142     ee->mem = g_malloc0(ee->rsize);
 143 }
 144
 145 static
 146 void at24c_eeprom_reset(DeviceState *state)
 147 {
 148     EEPROMState *ee = AT24C_EE(state);
 149
 150     ee->changed = false;
 151     ee->cur = 0;
 152     ee->haveaddr = 0;
 153
 154     memset(ee->mem, 0, ee->rsize);
 155
 156     if (ee->blk) {
 157         int len = blk_pread(ee->blk, 0, ee->mem, ee->rsize);
 158
 159         if (len != ee->rsize) {
 160             ERR(TYPE_AT24C_EE
 161                     " : Failed initial sync with backing file\n");
 162         }
 163         DPRINTK("Reset read backing file\n");
 164     }
 165 }
 166
 167 static Property at24c_eeprom_props[] = {
 168     DEFINE_PROP_UINT32("rom-size", EEPROMState, rsize, 0),
 169     DEFINE_PROP_BOOL("writable", EEPROMState, writable, true),
 170     DEFINE_PROP_DRIVE("drive", EEPROMState, blk),
 171     DEFINE_PROP_END_OF_LIST()
 172 };
 173
 174 static
 175 void at24c_eeprom_class_init(ObjectClass *klass, void *data)
 176 {
 177     DeviceClass *dc = DEVICE_CLASS(klass);
 178     I2CSlaveClass *k = I2C_SLAVE_CLASS(klass);
 179
 180     dc->realize = &at24c_eeprom_realize;
 181     k->event = &at24c_eeprom_event;
 182     k->recv = &at24c_eeprom_recv;
 183     k->send = &at24c_eeprom_send;
 184
 185     device_class_set_props(dc, at24c_eeprom_props);
 186     dc->reset = at24c_eeprom_reset;
 187 }
 188
 189 static
 190 const TypeInfo at24c_eeprom_type = {
 191     .name = TYPE_AT24C_EE,
 192     .parent = TYPE_I2C_SLAVE,
 193     .instance_size = sizeof(EEPROMState),
 194     .class_size = sizeof(I2CSlaveClass),
 195     .class_init = at24c_eeprom_class_init,
 196 };
 197
 198 static void at24c_eeprom_register(void)
 199 {
 200     type_register_static(&at24c_eeprom_type);
 201 }
 202
 203 type_init(at24c_eeprom_register)