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