]>
Commit | Line | Data |
---|---|---|
663e8e51 TS |
1 | /* |
2 | * QEMU EEPROM 93xx emulation | |
3 | * | |
4 | * Copyright (c) 2006-2007 Stefan Weil | |
5 | * | |
6 | * This program is free software; you can redistribute it and/or modify | |
7 | * it under the terms of the GNU General Public License as published by | |
8 | * the Free Software Foundation; either version 2 of the License, or | |
9 | * (at your option) any later version. | |
10 | * | |
11 | * This program is distributed in the hope that it will be useful, | |
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | * GNU General Public License for more details. | |
15 | * | |
16 | * You should have received a copy of the GNU General Public License | |
8167ee88 | 17 | * along with this program; if not, see <http://www.gnu.org/licenses/>. |
663e8e51 TS |
18 | */ |
19 | ||
20 | /* Emulation for serial EEPROMs: | |
21 | * NMC93C06 256-Bit (16 x 16) | |
22 | * NMC93C46 1024-Bit (64 x 16) | |
23 | * NMC93C56 2028 Bit (128 x 16) | |
24 | * NMC93C66 4096 Bit (256 x 16) | |
25 | * Compatible devices include FM93C46 and others. | |
26 | * | |
27 | * Other drivers use these interface functions: | |
28 | * eeprom93xx_new - add a new EEPROM (with 16, 64 or 256 words) | |
29 | * eeprom93xx_free - destroy EEPROM | |
30 | * eeprom93xx_read - read data from the EEPROM | |
31 | * eeprom93xx_write - write data to the EEPROM | |
32 | * eeprom93xx_data - get EEPROM data array for external manipulation | |
33 | * | |
34 | * Todo list: | |
35 | * - No emulation of EEPROM timings. | |
36 | */ | |
37 | ||
0430891c | 38 | #include "qemu/osdep.h" |
83c9f4ca | 39 | #include "hw/hw.h" |
0d09e41a | 40 | #include "hw/nvram/eeprom93xx.h" |
663e8e51 TS |
41 | |
42 | /* Debug EEPROM emulation. */ | |
43 | //~ #define DEBUG_EEPROM | |
44 | ||
45 | #ifdef DEBUG_EEPROM | |
001faf32 | 46 | #define logout(fmt, ...) fprintf(stderr, "EEPROM\t%-24s" fmt, __func__, ## __VA_ARGS__) |
663e8e51 | 47 | #else |
001faf32 | 48 | #define logout(fmt, ...) ((void)0) |
663e8e51 TS |
49 | #endif |
50 | ||
7ab2589c AJ |
51 | #define EEPROM_INSTANCE 0 |
52 | #define OLD_EEPROM_VERSION 20061112 | |
53 | #define EEPROM_VERSION (OLD_EEPROM_VERSION + 1) | |
663e8e51 TS |
54 | |
55 | #if 0 | |
56 | typedef enum { | |
57 | eeprom_read = 0x80, /* read register xx */ | |
58 | eeprom_write = 0x40, /* write register xx */ | |
59 | eeprom_erase = 0xc0, /* erase register xx */ | |
60 | eeprom_ewen = 0x30, /* erase / write enable */ | |
61 | eeprom_ewds = 0x00, /* erase / write disable */ | |
62 | eeprom_eral = 0x20, /* erase all registers */ | |
63 | eeprom_wral = 0x10, /* write all registers */ | |
64 | eeprom_amask = 0x0f, | |
65 | eeprom_imask = 0xf0 | |
66 | } eeprom_instruction_t; | |
67 | #endif | |
68 | ||
69 | #ifdef DEBUG_EEPROM | |
70 | static const char *opstring[] = { | |
71 | "extended", "write", "read", "erase" | |
72 | }; | |
73 | #endif | |
74 | ||
c227f099 | 75 | struct _eeprom_t { |
663e8e51 TS |
76 | uint8_t tick; |
77 | uint8_t address; | |
78 | uint8_t command; | |
ebabb67a | 79 | uint8_t writable; |
663e8e51 TS |
80 | |
81 | uint8_t eecs; | |
82 | uint8_t eesk; | |
83 | uint8_t eedo; | |
84 | ||
85 | uint8_t addrbits; | |
7ab2589c | 86 | uint16_t size; |
663e8e51 TS |
87 | uint16_t data; |
88 | uint16_t contents[0]; | |
89 | }; | |
90 | ||
91 | /* Code for saving and restoring of EEPROM state. */ | |
92 | ||
c4a0f2d3 JQ |
93 | /* Restore an uint16_t from an uint8_t |
94 | This is a Big hack, but it is how the old state did it. | |
95 | */ | |
96 | ||
2c21ee76 JD |
97 | static int get_uint16_from_uint8(QEMUFile *f, void *pv, size_t size, |
98 | VMStateField *field) | |
663e8e51 | 99 | { |
c4a0f2d3 JQ |
100 | uint16_t *v = pv; |
101 | *v = qemu_get_ubyte(f); | |
102 | return 0; | |
103 | } | |
d4ae799c | 104 | |
2c21ee76 JD |
105 | static int put_unused(QEMUFile *f, void *pv, size_t size, VMStateField *field, |
106 | QJSON *vmdesc) | |
c4a0f2d3 JQ |
107 | { |
108 | fprintf(stderr, "uint16_from_uint8 is used only for backwards compatibility.\n"); | |
109 | fprintf(stderr, "Never should be used to write a new state.\n"); | |
110 | exit(0); | |
2c21ee76 JD |
111 | |
112 | return 0; | |
c4a0f2d3 | 113 | } |
d4ae799c | 114 | |
d05ac8fa | 115 | static const VMStateInfo vmstate_hack_uint16_from_uint8 = { |
c4a0f2d3 JQ |
116 | .name = "uint16_from_uint8", |
117 | .get = get_uint16_from_uint8, | |
118 | .put = put_unused, | |
119 | }; | |
d4ae799c | 120 | |
c4a0f2d3 JQ |
121 | #define VMSTATE_UINT16_HACK_TEST(_f, _s, _t) \ |
122 | VMSTATE_SINGLE_TEST(_f, _s, _t, 0, vmstate_hack_uint16_from_uint8, uint16_t) | |
663e8e51 | 123 | |
c4a0f2d3 | 124 | static bool is_old_eeprom_version(void *opaque, int version_id) |
663e8e51 | 125 | { |
c4a0f2d3 JQ |
126 | return version_id == OLD_EEPROM_VERSION; |
127 | } | |
d4ae799c | 128 | |
c4a0f2d3 JQ |
129 | static const VMStateDescription vmstate_eeprom = { |
130 | .name = "eeprom", | |
131 | .version_id = EEPROM_VERSION, | |
132 | .minimum_version_id = OLD_EEPROM_VERSION, | |
d49805ae | 133 | .fields = (VMStateField[]) { |
c4a0f2d3 JQ |
134 | VMSTATE_UINT8(tick, eeprom_t), |
135 | VMSTATE_UINT8(address, eeprom_t), | |
136 | VMSTATE_UINT8(command, eeprom_t), | |
ebabb67a | 137 | VMSTATE_UINT8(writable, eeprom_t), |
d4ae799c | 138 | |
c4a0f2d3 JQ |
139 | VMSTATE_UINT8(eecs, eeprom_t), |
140 | VMSTATE_UINT8(eesk, eeprom_t), | |
141 | VMSTATE_UINT8(eedo, eeprom_t), | |
d4ae799c | 142 | |
c4a0f2d3 JQ |
143 | VMSTATE_UINT8(addrbits, eeprom_t), |
144 | VMSTATE_UINT16_HACK_TEST(size, eeprom_t, is_old_eeprom_version), | |
145 | VMSTATE_UNUSED_TEST(is_old_eeprom_version, 1), | |
d2164ad3 | 146 | VMSTATE_UINT16_EQUAL_V(size, eeprom_t, EEPROM_VERSION, NULL), |
c4a0f2d3 JQ |
147 | VMSTATE_UINT16(data, eeprom_t), |
148 | VMSTATE_VARRAY_UINT16_UNSAFE(contents, eeprom_t, size, 0, | |
149 | vmstate_info_uint16, uint16_t), | |
150 | VMSTATE_END_OF_LIST() | |
663e8e51 | 151 | } |
c4a0f2d3 | 152 | }; |
663e8e51 | 153 | |
c227f099 | 154 | void eeprom93xx_write(eeprom_t *eeprom, int eecs, int eesk, int eedi) |
663e8e51 TS |
155 | { |
156 | uint8_t tick = eeprom->tick; | |
157 | uint8_t eedo = eeprom->eedo; | |
158 | uint16_t address = eeprom->address; | |
159 | uint8_t command = eeprom->command; | |
160 | ||
161 | logout("CS=%u SK=%u DI=%u DO=%u, tick = %u\n", | |
162 | eecs, eesk, eedi, eedo, tick); | |
163 | ||
6fedcaa1 | 164 | if (!eeprom->eecs && eecs) { |
663e8e51 TS |
165 | /* Start chip select cycle. */ |
166 | logout("Cycle start, waiting for 1st start bit (0)\n"); | |
167 | tick = 0; | |
168 | command = 0x0; | |
169 | address = 0x0; | |
6fedcaa1 | 170 | } else if (eeprom->eecs && !eecs) { |
663e8e51 | 171 | /* End chip select cycle. This triggers write / erase. */ |
ebabb67a | 172 | if (eeprom->writable) { |
663e8e51 TS |
173 | uint8_t subcommand = address >> (eeprom->addrbits - 2); |
174 | if (command == 0 && subcommand == 2) { | |
175 | /* Erase all. */ | |
176 | for (address = 0; address < eeprom->size; address++) { | |
177 | eeprom->contents[address] = 0xffff; | |
178 | } | |
179 | } else if (command == 3) { | |
180 | /* Erase word. */ | |
181 | eeprom->contents[address] = 0xffff; | |
182 | } else if (tick >= 2 + 2 + eeprom->addrbits + 16) { | |
183 | if (command == 1) { | |
184 | /* Write word. */ | |
185 | eeprom->contents[address] &= eeprom->data; | |
186 | } else if (command == 0 && subcommand == 1) { | |
187 | /* Write all. */ | |
188 | for (address = 0; address < eeprom->size; address++) { | |
189 | eeprom->contents[address] &= eeprom->data; | |
190 | } | |
191 | } | |
192 | } | |
193 | } | |
194 | /* Output DO is tristate, read results in 1. */ | |
195 | eedo = 1; | |
6fedcaa1 | 196 | } else if (eecs && !eeprom->eesk && eesk) { |
663e8e51 TS |
197 | /* Raising edge of clock shifts data in. */ |
198 | if (tick == 0) { | |
199 | /* Wait for 1st start bit. */ | |
200 | if (eedi == 0) { | |
201 | logout("Got correct 1st start bit, waiting for 2nd start bit (1)\n"); | |
202 | tick++; | |
203 | } else { | |
204 | logout("wrong 1st start bit (is 1, should be 0)\n"); | |
205 | tick = 2; | |
206 | //~ assert(!"wrong start bit"); | |
207 | } | |
208 | } else if (tick == 1) { | |
209 | /* Wait for 2nd start bit. */ | |
210 | if (eedi != 0) { | |
211 | logout("Got correct 2nd start bit, getting command + address\n"); | |
212 | tick++; | |
213 | } else { | |
214 | logout("1st start bit is longer than needed\n"); | |
215 | } | |
216 | } else if (tick < 2 + 2) { | |
217 | /* Got 2 start bits, transfer 2 opcode bits. */ | |
218 | tick++; | |
219 | command <<= 1; | |
220 | if (eedi) { | |
221 | command += 1; | |
222 | } | |
223 | } else if (tick < 2 + 2 + eeprom->addrbits) { | |
224 | /* Got 2 start bits and 2 opcode bits, transfer all address bits. */ | |
225 | tick++; | |
226 | address = ((address << 1) | eedi); | |
227 | if (tick == 2 + 2 + eeprom->addrbits) { | |
228 | logout("%s command, address = 0x%02x (value 0x%04x)\n", | |
229 | opstring[command], address, eeprom->contents[address]); | |
230 | if (command == 2) { | |
231 | eedo = 0; | |
232 | } | |
233 | address = address % eeprom->size; | |
234 | if (command == 0) { | |
235 | /* Command code in upper 2 bits of address. */ | |
236 | switch (address >> (eeprom->addrbits - 2)) { | |
6fedcaa1 AP |
237 | case 0: |
238 | logout("write disable command\n"); | |
239 | eeprom->writable = 0; | |
240 | break; | |
241 | case 1: | |
242 | logout("write all command\n"); | |
243 | break; | |
244 | case 2: | |
245 | logout("erase all command\n"); | |
246 | break; | |
247 | case 3: | |
248 | logout("write enable command\n"); | |
249 | eeprom->writable = 1; | |
250 | break; | |
663e8e51 TS |
251 | } |
252 | } else { | |
253 | /* Read, write or erase word. */ | |
254 | eeprom->data = eeprom->contents[address]; | |
255 | } | |
256 | } | |
257 | } else if (tick < 2 + 2 + eeprom->addrbits + 16) { | |
258 | /* Transfer 16 data bits. */ | |
259 | tick++; | |
260 | if (command == 2) { | |
261 | /* Read word. */ | |
262 | eedo = ((eeprom->data & 0x8000) != 0); | |
263 | } | |
264 | eeprom->data <<= 1; | |
265 | eeprom->data += eedi; | |
266 | } else { | |
267 | logout("additional unneeded tick, not processed\n"); | |
268 | } | |
269 | } | |
270 | /* Save status of EEPROM. */ | |
271 | eeprom->tick = tick; | |
272 | eeprom->eecs = eecs; | |
273 | eeprom->eesk = eesk; | |
274 | eeprom->eedo = eedo; | |
275 | eeprom->address = address; | |
276 | eeprom->command = command; | |
277 | } | |
278 | ||
c227f099 | 279 | uint16_t eeprom93xx_read(eeprom_t *eeprom) |
663e8e51 TS |
280 | { |
281 | /* Return status of pin DO (0 or 1). */ | |
282 | logout("CS=%u DO=%u\n", eeprom->eecs, eeprom->eedo); | |
6fedcaa1 | 283 | return eeprom->eedo; |
663e8e51 TS |
284 | } |
285 | ||
286 | #if 0 | |
287 | void eeprom93xx_reset(eeprom_t *eeprom) | |
288 | { | |
289 | /* prepare eeprom */ | |
290 | logout("eeprom = 0x%p\n", eeprom); | |
291 | eeprom->tick = 0; | |
292 | eeprom->command = 0; | |
293 | } | |
294 | #endif | |
295 | ||
5fce2b3e | 296 | eeprom_t *eeprom93xx_new(DeviceState *dev, uint16_t nwords) |
663e8e51 TS |
297 | { |
298 | /* Add a new EEPROM (with 16, 64 or 256 words). */ | |
c227f099 | 299 | eeprom_t *eeprom; |
663e8e51 TS |
300 | uint8_t addrbits; |
301 | ||
302 | switch (nwords) { | |
6fedcaa1 AP |
303 | case 16: |
304 | case 64: | |
305 | addrbits = 6; | |
306 | break; | |
307 | case 128: | |
308 | case 256: | |
309 | addrbits = 8; | |
310 | break; | |
311 | default: | |
312 | assert(!"Unsupported EEPROM size, fallback to 64 words!"); | |
313 | nwords = 64; | |
314 | addrbits = 6; | |
663e8e51 TS |
315 | } |
316 | ||
7267c094 | 317 | eeprom = (eeprom_t *)g_malloc0(sizeof(*eeprom) + nwords * 2); |
663e8e51 TS |
318 | eeprom->size = nwords; |
319 | eeprom->addrbits = addrbits; | |
320 | /* Output DO is tristate, read results in 1. */ | |
321 | eeprom->eedo = 1; | |
322 | logout("eeprom = 0x%p, nwords = %u\n", eeprom, nwords); | |
5fce2b3e | 323 | vmstate_register(dev, 0, &vmstate_eeprom, eeprom); |
663e8e51 TS |
324 | return eeprom; |
325 | } | |
326 | ||
5fce2b3e | 327 | void eeprom93xx_free(DeviceState *dev, eeprom_t *eeprom) |
663e8e51 TS |
328 | { |
329 | /* Destroy EEPROM. */ | |
330 | logout("eeprom = 0x%p\n", eeprom); | |
5fce2b3e | 331 | vmstate_unregister(dev, &vmstate_eeprom, eeprom); |
7267c094 | 332 | g_free(eeprom); |
663e8e51 TS |
333 | } |
334 | ||
c227f099 | 335 | uint16_t *eeprom93xx_data(eeprom_t *eeprom) |
663e8e51 TS |
336 | { |
337 | /* Get EEPROM data array. */ | |
338 | return &eeprom->contents[0]; | |
339 | } | |
340 | ||
341 | /* eof */ |