1 /* dv-m68hc11eepr.c -- Simulation of the 68HC11 Internal EEPROM.
2 Copyright (C) 1999-2014 Free Software Foundation, Inc.
3 Written by Stephane Carrez (stcarrez@nerim.fr)
4 (From a driver model Contributed by Cygnus Solutions.)
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 3 of the License, or
9 (at your option) any later version.
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.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
24 #include "sim-assert.h"
25 #include "sim-events.h"
35 m68hc11eepr - m68hc11 EEPROM
40 Implements the 68HC11 eeprom device described in the m68hc11
41 user guide (Chapter 4 in the pink book).
48 Base of eeprom and its length.
52 Path of the EEPROM file. The default is 'm6811.eeprom'.
63 /* static functions */
74 static const struct hw_port_descriptor m68hc11eepr_ports
[] =
76 { "reset", RESET_PORT
, 0, input_port
, },
82 /* The timer/counter register internal state. Note that we store
83 state using the control register images, in host endian order. */
87 address_word base_address
; /* control register base */
92 /* Current state of the eeprom programing:
93 - eeprom_wmode indicates whether the EEPROM address and byte have
95 - eeprom_waddr indicates the EEPROM address that was latched
96 and eeprom_wbyte is the byte that was latched.
97 - eeprom_wcycle indicates the CPU absolute cycle type when
98 the high voltage was applied (successfully) on the EEPROM.
100 These data members are setup only when we detect good EEPROM programing
101 conditions (see Motorola EEPROM Programming and PPROG register usage).
102 When the high voltage is switched off, we look at the CPU absolute
103 cycle time to see if the EEPROM command must succeeds or not.
104 The EEPROM content is updated and saved only at that time.
105 (EEPROM command is: byte zero bits program, byte erase, row erase
108 The CONFIG register is programmed in the same way. It is physically
109 located at the end of the EEPROM (eeprom size + 1). It is not mapped
110 in memory but it's saved in the EEPROM file. */
111 unsigned long eeprom_wcycle
;
118 /* Minimum time in CPU cycles for programming the EEPROM. */
119 unsigned long eeprom_min_cycles
;
121 const char* file_name
;
126 /* Finish off the partially created hw device. Attach our local
127 callbacks. Wire up our port names etc. */
129 static hw_io_read_buffer_method m68hc11eepr_io_read_buffer
;
130 static hw_io_write_buffer_method m68hc11eepr_io_write_buffer
;
131 static hw_ioctl_method m68hc11eepr_ioctl
;
133 /* Read or write the memory bank content from/to a file.
134 Returns 0 if the operation succeeded and -1 if it failed. */
136 m6811eepr_memory_rw (struct m68hc11eepr
*controller
, int mode
)
138 const char *name
= controller
->file_name
;
142 size
= controller
->size
;
143 fd
= open (name
, mode
, 0644);
146 if (mode
== O_RDONLY
)
148 memset (controller
->eeprom
, 0xFF, size
);
149 /* Default value for CONFIG register (0xFF should be ok):
150 controller->eeprom[size - 1] = M6811_NOSEC | M6811_NOCOP
151 | M6811_ROMON | M6811_EEON; */
157 if (mode
== O_RDONLY
)
159 if (read (fd
, controller
->eeprom
, size
) != size
)
167 if (write (fd
, controller
->eeprom
, size
) != size
)
182 attach_m68hc11eepr_regs (struct hw
*me
,
183 struct m68hc11eepr
*controller
)
185 unsigned_word attach_address
;
187 unsigned attach_size
;
188 reg_property_spec reg
;
190 if (hw_find_property (me
, "reg") == NULL
)
191 hw_abort (me
, "Missing \"reg\" property");
193 if (!hw_find_reg_array_property (me
, "reg", 0, ®
))
194 hw_abort (me
, "\"reg\" property must contain one addr/size entry");
196 hw_unit_address_to_attach_address (hw_parent (me
),
201 hw_unit_size_to_attach_size (hw_parent (me
),
205 /* Attach the two IO registers that control the EEPROM.
206 The EEPROM is only attached at reset time because it may
207 be enabled/disabled by the EEON bit in the CONFIG register. */
208 hw_attach_address (hw_parent (me
), M6811_IO_LEVEL
,
209 io_map
, M6811_PPROG
, 1, me
);
210 hw_attach_address (hw_parent (me
), M6811_IO_LEVEL
,
211 io_map
, M6811_CONFIG
, 1, me
);
213 if (hw_find_property (me
, "file") == NULL
)
214 controller
->file_name
= "m6811.eeprom";
216 controller
->file_name
= hw_find_string_property (me
, "file");
218 controller
->attach_space
= attach_space
;
219 controller
->base_address
= attach_address
;
220 controller
->eeprom
= (char*) hw_malloc (me
, attach_size
+ 1);
221 controller
->eeprom_min_cycles
= 10000;
222 controller
->size
= attach_size
+ 1;
223 controller
->mapped
= 0;
225 m6811eepr_memory_rw (controller
, O_RDONLY
);
229 /* An event arrives on an interrupt port. */
232 m68hc11eepr_port_event (struct hw
*me
,
239 struct m68hc11eepr
*controller
;
242 controller
= hw_data (me
);
244 cpu
= STATE_CPU (sd
, 0);
249 HW_TRACE ((me
, "EEPROM reset"));
251 /* Re-read the EEPROM from the file. This gives the chance
252 to users to erase this file before doing a reset and have
253 a fresh EEPROM taken into account. */
254 m6811eepr_memory_rw (controller
, O_RDONLY
);
256 /* Reset the state of EEPROM programmer. The CONFIG register
257 is also initialized from the EEPROM/file content. */
258 cpu
->ios
[M6811_PPROG
] = 0;
259 if (cpu
->cpu_use_local_config
)
260 cpu
->ios
[M6811_CONFIG
] = cpu
->cpu_config
;
262 cpu
->ios
[M6811_CONFIG
] = controller
->eeprom
[controller
->size
-1];
263 controller
->eeprom_wmode
= 0;
264 controller
->eeprom_waddr
= 0;
265 controller
->eeprom_wbyte
= 0;
267 /* Attach or detach to the bus depending on the EEPROM enable bit.
268 The EEPROM CONFIG register is still enabled and can be programmed
269 for a next configuration (taken into account only after a reset,
270 see Motorola spec). */
271 if (!(cpu
->ios
[M6811_CONFIG
] & M6811_EEON
))
273 if (controller
->mapped
)
274 hw_detach_address (hw_parent (me
), M6811_EEPROM_LEVEL
,
275 controller
->attach_space
,
276 controller
->base_address
,
277 controller
->size
- 1,
279 controller
->mapped
= 0;
283 if (!controller
->mapped
)
284 hw_attach_address (hw_parent (me
), M6811_EEPROM_LEVEL
,
285 controller
->attach_space
,
286 controller
->base_address
,
287 controller
->size
- 1,
289 controller
->mapped
= 1;
295 hw_abort (me
, "Event on unknown port %d", my_port
);
302 m68hc11eepr_finish (struct hw
*me
)
304 struct m68hc11eepr
*controller
;
306 controller
= HW_ZALLOC (me
, struct m68hc11eepr
);
307 set_hw_data (me
, controller
);
308 set_hw_io_read_buffer (me
, m68hc11eepr_io_read_buffer
);
309 set_hw_io_write_buffer (me
, m68hc11eepr_io_write_buffer
);
310 set_hw_ports (me
, m68hc11eepr_ports
);
311 set_hw_port_event (me
, m68hc11eepr_port_event
);
313 set_hw_ioctl (me
, m68hc11eepr_ioctl
);
315 me
->to_ioctl
= m68hc11eepr_ioctl
;
318 attach_m68hc11eepr_regs (me
, controller
);
323 static io_reg_desc pprog_desc
[] = {
324 { M6811_BYTE
, "BYTE ", "Byte Program Mode" },
325 { M6811_ROW
, "ROW ", "Row Program Mode" },
326 { M6811_ERASE
, "ERASE ", "Erase Mode" },
327 { M6811_EELAT
, "EELAT ", "EEProm Latch Control" },
328 { M6811_EEPGM
, "EEPGM ", "EEProm Programming Voltable Enable" },
331 extern io_reg_desc config_desc
[];
334 /* Describe the state of the EEPROM device. */
336 m68hc11eepr_info (struct hw
*me
)
341 struct m68hc11eepr
*controller
;
345 cpu
= STATE_CPU (sd
, 0);
346 controller
= hw_data (me
);
347 base
= cpu_get_io_base (cpu
);
349 sim_io_printf (sd
, "M68HC11 EEprom:\n");
351 val
= cpu
->ios
[M6811_PPROG
];
352 print_io_byte (sd
, "PPROG ", pprog_desc
, val
, base
+ M6811_PPROG
);
353 sim_io_printf (sd
, "\n");
355 val
= cpu
->ios
[M6811_CONFIG
];
356 print_io_byte (sd
, "CONFIG ", config_desc
, val
, base
+ M6811_CONFIG
);
357 sim_io_printf (sd
, "\n");
359 val
= controller
->eeprom
[controller
->size
- 1];
360 print_io_byte (sd
, "(*NEXT*) ", config_desc
, val
, base
+ M6811_CONFIG
);
361 sim_io_printf (sd
, "\n");
363 /* Describe internal state of EEPROM. */
364 if (controller
->eeprom_wmode
)
366 if (controller
->eeprom_waddr
== controller
->size
- 1)
367 sim_io_printf (sd
, " Programming CONFIG register ");
369 sim_io_printf (sd
, " Programming: 0x%04x ",
370 controller
->eeprom_waddr
+ controller
->base_address
);
372 sim_io_printf (sd
, "with 0x%02x\n",
373 controller
->eeprom_wbyte
);
376 sim_io_printf (sd
, " EEProm file: %s\n",
377 controller
->file_name
);
381 m68hc11eepr_ioctl (struct hw
*me
,
382 hw_ioctl_request request
,
385 m68hc11eepr_info (me
);
389 /* generic read/write */
392 m68hc11eepr_io_read_buffer (struct hw
*me
,
399 struct m68hc11eepr
*controller
;
402 HW_TRACE ((me
, "read 0x%08lx %d", (long) base
, (int) nr_bytes
));
405 controller
= hw_data (me
);
406 cpu
= STATE_CPU (sd
, 0);
412 while (nr_bytes
!= 0)
418 *((uint8
*) dest
) = cpu
->ios
[base
];
422 hw_abort (me
, "reading wrong register 0x%04x", base
);
424 dest
= (uint8
*) (dest
) + 1;
432 /* In theory, we can't read the EEPROM when it's being programmed. */
433 if ((cpu
->ios
[M6811_PPROG
] & M6811_EELAT
) != 0
434 && cpu_is_running (cpu
))
436 sim_memory_error (cpu
, SIM_SIGBUS
, base
,
437 "EEprom not configured for reading");
440 base
= base
- controller
->base_address
;
441 memcpy (dest
, &controller
->eeprom
[base
], nr_bytes
);
447 m68hc11eepr_io_write_buffer (struct hw
*me
,
454 struct m68hc11eepr
*controller
;
458 HW_TRACE ((me
, "write 0x%08lx %d", (long) base
, (int) nr_bytes
));
461 controller
= hw_data (me
);
462 cpu
= STATE_CPU (sd
, 0);
464 /* Programming several bytes at a time is not possible. */
465 if (space
!= io_map
&& nr_bytes
!= 1)
467 sim_memory_error (cpu
, SIM_SIGBUS
, base
,
468 "EEprom write error (only 1 byte can be programmed)");
473 hw_abort (me
, "Cannot write more than 1 byte to EEPROM device at a time");
475 val
= *((const uint8
*) source
);
477 /* Write to the EEPROM control register. */
478 if (space
== io_map
&& base
== M6811_PPROG
)
483 addr
= base
+ cpu_get_io_base (cpu
);
485 /* Setting EELAT and EEPGM at the same time is an error.
486 Clearing them both is ok. */
487 wrong_bits
= (cpu
->ios
[M6811_PPROG
] ^ val
) & val
;
488 wrong_bits
&= (M6811_EELAT
| M6811_EEPGM
);
490 if (wrong_bits
== (M6811_EEPGM
|M6811_EELAT
))
492 sim_memory_error (cpu
, SIM_SIGBUS
, addr
,
493 "Wrong eeprom programing value");
497 if ((val
& M6811_EELAT
) == 0)
501 if ((val
& M6811_EEPGM
) && !(cpu
->ios
[M6811_PPROG
] & M6811_EELAT
))
503 sim_memory_error (cpu
, SIM_SIGBUS
, addr
,
504 "EEProm high voltage applied after EELAT");
506 if ((val
& M6811_EEPGM
) && controller
->eeprom_wmode
== 0)
508 sim_memory_error (cpu
, SIM_SIGSEGV
, addr
,
509 "EEProm high voltage applied without address");
511 if (val
& M6811_EEPGM
)
513 controller
->eeprom_wcycle
= cpu_current_cycle (cpu
);
515 else if (cpu
->ios
[M6811_PPROG
] & M6811_PPROG
)
518 unsigned long t
= cpu_current_cycle (cpu
);
520 t
-= controller
->eeprom_wcycle
;
521 if (t
< controller
->eeprom_min_cycles
)
523 sim_memory_error (cpu
, SIM_SIGILL
, addr
,
524 "EEprom programmed only for %lu cycles",
528 /* Program the byte by clearing some bits. */
529 if (!(cpu
->ios
[M6811_PPROG
] & M6811_ERASE
))
531 controller
->eeprom
[controller
->eeprom_waddr
]
532 &= controller
->eeprom_wbyte
;
535 /* Erase a byte, row or the complete eeprom. Erased value is 0xFF.
536 Ignore row or complete eeprom erase when we are programming the
537 CONFIG register (last EEPROM byte). */
538 else if ((cpu
->ios
[M6811_PPROG
] & M6811_BYTE
)
539 || controller
->eeprom_waddr
== controller
->size
- 1)
541 controller
->eeprom
[controller
->eeprom_waddr
] = 0xff;
543 else if (cpu
->ios
[M6811_BYTE
] & M6811_ROW
)
547 /* Size of EEPROM (-1 because the last byte is the
549 max_size
= controller
->size
;
550 controller
->eeprom_waddr
&= 0xFFF0;
552 && controller
->eeprom_waddr
< max_size
; i
++)
554 controller
->eeprom
[controller
->eeprom_waddr
] = 0xff;
555 controller
->eeprom_waddr
++;
562 max_size
= controller
->size
;
563 for (i
= 0; i
< max_size
; i
++)
565 controller
->eeprom
[i
] = 0xff;
569 /* Save the eeprom in a file. We have to save after each
570 change because the simulator can be stopped or crash... */
571 if (m6811eepr_memory_rw (controller
, O_WRONLY
| O_CREAT
) != 0)
573 sim_memory_error (cpu
, SIM_SIGABRT
, addr
,
574 "EEPROM programing failed: errno=%d", errno
);
576 controller
->eeprom_wmode
= 0;
578 cpu
->ios
[M6811_PPROG
] = val
;
582 /* The CONFIG IO register is mapped at end of EEPROM.
584 if (space
== io_map
&& base
== M6811_CONFIG
)
586 base
= controller
->size
- 1;
590 base
= base
- controller
->base_address
;
593 /* Writing the memory is allowed for the Debugger or simulator
594 (cpu not running). */
595 if (cpu_is_running (cpu
))
597 if ((cpu
->ios
[M6811_PPROG
] & M6811_EELAT
) == 0)
599 sim_memory_error (cpu
, SIM_SIGSEGV
, base
,
600 "EEprom not configured for writing");
603 if (controller
->eeprom_wmode
!= 0)
605 sim_memory_error (cpu
, SIM_SIGSEGV
, base
,
606 "EEprom write error");
609 controller
->eeprom_wmode
= 1;
610 controller
->eeprom_waddr
= base
;
611 controller
->eeprom_wbyte
= val
;
615 controller
->eeprom
[base
] = val
;
616 m6811eepr_memory_rw (controller
, O_WRONLY
);
622 const struct hw_descriptor dv_m68hc11eepr_descriptor
[] = {
623 { "m68hc11eepr", m68hc11eepr_finish
},
624 { "m68hc12eepr", m68hc11eepr_finish
},