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