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/nvram/eeprom_at24c.h" 16 #include "hw/qdev-properties.h" 17 #include "hw/qdev-properties-system.h" 18 #include "system/block-backend.h" 19 #include "qom/object.h" 20 21 /* #define DEBUG_AT24C */ 22 23 #ifdef DEBUG_AT24C 24 #define DPRINTK(FMT, ...) printf(TYPE_AT24C_EE " : " FMT, ## __VA_ARGS__) 25 #else 26 #define DPRINTK(FMT, ...) do {} while (0) 27 #endif 28 29 #define ERR(FMT, ...) fprintf(stderr, TYPE_AT24C_EE " : " FMT, \ 30 ## __VA_ARGS__) 31 32 #define TYPE_AT24C_EE "at24c-eeprom" 33 OBJECT_DECLARE_SIMPLE_TYPE(EEPROMState, AT24C_EE) 34 35 struct EEPROMState { 36 I2CSlave parent_obj; 37 38 /* address counter */ 39 uint16_t cur; 40 /* total size in bytes */ 41 uint32_t rsize; 42 /* 43 * address byte number 44 * for 24c01, 24c02 size <= 256 byte, use only 1 byte 45 * otherwise size > 256, use 2 byte 46 */ 47 uint8_t asize; 48 49 bool writable; 50 /* cells changed since last START? */ 51 bool changed; 52 /* during WRITE, # of address bytes transferred */ 53 uint8_t haveaddr; 54 55 uint8_t *mem; 56 57 BlockBackend *blk; 58 59 const uint8_t *init_rom; 60 uint32_t init_rom_size; 61 }; 62 63 static 64 int at24c_eeprom_event(I2CSlave *s, enum i2c_event event) 65 { 66 EEPROMState *ee = AT24C_EE(s); 67 68 switch (event) { 69 case I2C_START_SEND: 70 case I2C_FINISH: 71 ee->haveaddr = 0; 72 /* fallthrough */ 73 case I2C_START_RECV: 74 DPRINTK("clear\n"); 75 if (ee->blk && ee->changed) { 76 int ret = blk_pwrite(ee->blk, 0, ee->rsize, ee->mem, 0); 77 if (ret < 0) { 78 ERR(TYPE_AT24C_EE 79 " : failed to write backing file\n"); 80 } 81 DPRINTK("Wrote to backing file\n"); 82 } 83 ee->changed = false; 84 break; 85 case I2C_NACK: 86 break; 87 default: 88 return -1; 89 } 90 return 0; 91 } 92 93 static 94 uint8_t at24c_eeprom_recv(I2CSlave *s) 95 { 96 EEPROMState *ee = AT24C_EE(s); 97 uint8_t ret; 98 99 /* 100 * If got the byte address but not completely with address size 101 * will return the invalid value 102 */ 103 if (ee->haveaddr > 0 && ee->haveaddr < ee->asize) { 104 return 0xff; 105 } 106 107 ret = ee->mem[ee->cur]; 108 109 ee->cur = (ee->cur + 1u) % ee->rsize; 110 DPRINTK("Recv %02x %c\n", ret, ret); 111 112 return ret; 113 } 114 115 static 116 int at24c_eeprom_send(I2CSlave *s, uint8_t data) 117 { 118 EEPROMState *ee = AT24C_EE(s); 119 120 if (ee->haveaddr < ee->asize) { 121 ee->cur <<= 8; 122 ee->cur |= data; 123 ee->haveaddr++; 124 if (ee->haveaddr == ee->asize) { 125 ee->cur %= ee->rsize; 126 DPRINTK("Set pointer %04x\n", ee->cur); 127 } 128 129 } else { 130 if (ee->writable) { 131 DPRINTK("Send %02x\n", data); 132 ee->mem[ee->cur] = data; 133 ee->changed = true; 134 } else { 135 DPRINTK("Send error %02x read-only\n", data); 136 } 137 ee->cur = (ee->cur + 1u) % ee->rsize; 138 139 } 140 141 return 0; 142 } 143 144 I2CSlave *at24c_eeprom_init(I2CBus *bus, uint8_t address, uint32_t rom_size) 145 { 146 return at24c_eeprom_init_rom(bus, address, rom_size, NULL, 0); 147 } 148 149 I2CSlave *at24c_eeprom_init_rom(I2CBus *bus, uint8_t address, uint32_t rom_size, 150 const uint8_t *init_rom, uint32_t init_rom_size) 151 { 152 EEPROMState *s; 153 154 s = AT24C_EE(i2c_slave_new(TYPE_AT24C_EE, address)); 155 156 qdev_prop_set_uint32(DEVICE(s), "rom-size", rom_size); 157 158 /* TODO: Model init_rom with QOM properties. */ 159 s->init_rom = init_rom; 160 s->init_rom_size = init_rom_size; 161 162 i2c_slave_realize_and_unref(I2C_SLAVE(s), bus, &error_abort); 163 164 return I2C_SLAVE(s); 165 } 166 167 static void at24c_eeprom_realize(DeviceState *dev, Error **errp) 168 { 169 EEPROMState *ee = AT24C_EE(dev); 170 171 if (ee->init_rom_size > ee->rsize) { 172 error_setg(errp, "%s: init rom is larger than rom: %u > %u", 173 TYPE_AT24C_EE, ee->init_rom_size, ee->rsize); 174 return; 175 } 176 177 if (ee->blk) { 178 int64_t len = blk_getlength(ee->blk); 179 180 if (len != ee->rsize) { 181 error_setg(errp, "%s: Backing file size %" PRId64 " != %u", 182 TYPE_AT24C_EE, len, ee->rsize); 183 return; 184 } 185 186 if (blk_set_perm(ee->blk, BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE, 187 BLK_PERM_ALL, &error_fatal) < 0) 188 { 189 error_setg(errp, "%s: Backing file incorrect permission", 190 TYPE_AT24C_EE); 191 return; 192 } 193 } 194 195 ee->mem = g_malloc0(ee->rsize); 196 memset(ee->mem, 0, ee->rsize); 197 198 if (ee->init_rom) { 199 memcpy(ee->mem, ee->init_rom, MIN(ee->init_rom_size, ee->rsize)); 200 } 201 202 if (ee->blk) { 203 int ret = blk_pread(ee->blk, 0, ee->rsize, ee->mem, 0); 204 205 if (ret < 0) { 206 ERR(TYPE_AT24C_EE 207 " : Failed initial sync with backing file\n"); 208 } 209 DPRINTK("Reset read backing file\n"); 210 } 211 212 /* 213 * If address size didn't define with property set 214 * value is 0 as default, setting it by Rom size detecting. 215 */ 216 if (ee->asize == 0) { 217 if (ee->rsize <= 256) { 218 ee->asize = 1; 219 } else { 220 ee->asize = 2; 221 } 222 } 223 } 224 225 static 226 void at24c_eeprom_reset(DeviceState *state) 227 { 228 EEPROMState *ee = AT24C_EE(state); 229 230 ee->changed = false; 231 ee->cur = 0; 232 ee->haveaddr = 0; 233 } 234 235 static const Property at24c_eeprom_props[] = { 236 DEFINE_PROP_UINT32("rom-size", EEPROMState, rsize, 0), 237 DEFINE_PROP_UINT8("address-size", EEPROMState, asize, 0), 238 DEFINE_PROP_BOOL("writable", EEPROMState, writable, true), 239 DEFINE_PROP_DRIVE("drive", EEPROMState, blk), 240 }; 241 242 static 243 void at24c_eeprom_class_init(ObjectClass *klass, void *data) 244 { 245 DeviceClass *dc = DEVICE_CLASS(klass); 246 I2CSlaveClass *k = I2C_SLAVE_CLASS(klass); 247 248 dc->realize = &at24c_eeprom_realize; 249 k->event = &at24c_eeprom_event; 250 k->recv = &at24c_eeprom_recv; 251 k->send = &at24c_eeprom_send; 252 253 device_class_set_props(dc, at24c_eeprom_props); 254 device_class_set_legacy_reset(dc, at24c_eeprom_reset); 255 } 256 257 static 258 const TypeInfo at24c_eeprom_type = { 259 .name = TYPE_AT24C_EE, 260 .parent = TYPE_I2C_SLAVE, 261 .instance_size = sizeof(EEPROMState), 262 .class_size = sizeof(I2CSlaveClass), 263 .class_init = at24c_eeprom_class_init, 264 }; 265 266 static void at24c_eeprom_register(void) 267 { 268 type_register_static(&at24c_eeprom_type); 269 } 270 271 type_init(at24c_eeprom_register) 272