LXR qemu/hw/nvram/eeprom

   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
  31typedef 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
  49static
  50int 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
  76static
  77int 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
  90static
  91int 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
 119static
 120int 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
 146static
 147void 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
 168static 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
 175static
 176void 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
 190static
 191const 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
 199static void at24c_eeprom_register(void)
 200{
 201    type_register_static(&at24c_eeprom_type);
 202}
 203
 204type_init(at24c_eeprom_register)
 205