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