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 "qemu/module.h"
  14#include "hw/hw.h"
  15#include "hw/i2c/i2c.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
  32typedef 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
  50static
  51int 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
  77static
  78uint8_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
  91static
  92int 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
 120static 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
 145static
 146void 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
 167static 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
 174static
 175void 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    dc->props = at24c_eeprom_props;
 186    dc->reset = at24c_eeprom_reset;
 187}
 188
 189static
 190const 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
 198static void at24c_eeprom_register(void)
 199{
 200    type_register_static(&at24c_eeprom_type);
 201}
 202
 203type_init(at24c_eeprom_register)
 204