text: /*  dv-m68hc11eepr.c -- Simulation of the 68HC11 Internal EEPROM.
      Copyright (C) 1999, 2000, 2001, 2002, 2007, 2008, 2009, 2010, 2011
      Free Software Foundation, Inc.
      Written by Stephane Carrez (stcarrez@nerim.fr)
      (From a driver model Contributed by Cygnus Solutions.)
      
      This program is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published by
      the Free Software Foundation; either version 3 of the License, or
      (at your option) any later version.
  
      This program is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      GNU General Public License for more details.
  
      You should have received a copy of the GNU General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
      
      */
  
  
  #include "sim-main.h"
  #include "hw-main.h"
  #include "sim-assert.h"
  #include "sim-events.h"
  
  #include <unistd.h>
  #include <fcntl.h>
  #include <errno.h>
  
  
  
  /* DEVICE
  
          m68hc11eepr - m68hc11 EEPROM
  
     
     DESCRIPTION
  
          Implements the 68HC11 eeprom device described in the m68hc11
          user guide (Chapter 4 in the pink book).
  
  
     PROPERTIES
  
     reg <base> <length>
  
          Base of eeprom and its length.
  
     file <path>
  
          Path of the EEPROM file.  The default is 'm6811.eeprom'.
  
  
     PORTS
  
          None
  
     */
  
  
  
  /* static functions */
  
  
  /* port ID's */
  
  enum
  {
    RESET_PORT
  };
  
  
  static const struct hw_port_descriptor m68hc11eepr_ports[] = 
  {
    { "reset", RESET_PORT, 0, input_port, },
    { NULL, },
  };
  
  
  
  /* The timer/counter register internal state.  Note that we store
     state using the control register images, in host endian order.  */
  
  struct m68hc11eepr 
  {
    address_word  base_address; /* control register base */
    int           attach_space;
    unsigned      size;
    int           mapped;
    
    /* Current state of the eeprom programing:
       - eeprom_wmode indicates whether the EEPROM address and byte have
         been latched.
       - eeprom_waddr indicates the EEPROM address that was latched
         and eeprom_wbyte is the byte that was latched.
       - eeprom_wcycle indicates the CPU absolute cycle type when
         the high voltage was applied (successfully) on the EEPROM.
     
       These data members are setup only when we detect good EEPROM programing
       conditions (see Motorola EEPROM Programming and PPROG register usage).
       When the high voltage is switched off, we look at the CPU absolute
       cycle time to see if the EEPROM command must succeeds or not.
       The EEPROM content is updated and saved only at that time.
       (EEPROM command is: byte zero bits program, byte erase, row erase
       and bulk erase).
      
       The CONFIG register is programmed in the same way.  It is physically
       located at the end of the EEPROM (eeprom size + 1).  It is not mapped
       in memory but it's saved in the EEPROM file.  */
    unsigned long		eeprom_wcycle;
    uint16		eeprom_waddr;
    uint8			eeprom_wbyte;
    uint8			eeprom_wmode;
  
    uint8*		eeprom;
    
    /* Minimum time in CPU cycles for programming the EEPROM.  */
    unsigned long         eeprom_min_cycles;
  
    const char*           file_name;
  };
  
  
  
  /* Finish off the partially created hw device.  Attach our local
     callbacks.  Wire up our port names etc.  */
  
  static hw_io_read_buffer_method m68hc11eepr_io_read_buffer;
  static hw_io_write_buffer_method m68hc11eepr_io_write_buffer;
  static hw_ioctl_method m68hc11eepr_ioctl;
  
  /* Read or write the memory bank content from/to a file.
     Returns 0 if the operation succeeded and -1 if it failed.  */
  static int
  m6811eepr_memory_rw (struct m68hc11eepr *controller, int mode)
  {
    const char *name = controller->file_name;
    int fd;
    size_t size;
    
    size = controller->size;
    fd = open (name, mode, 0644);
    if (fd < 0)
      {
        if (mode == O_RDONLY)
          {
            memset (controller->eeprom, 0xFF, size);
            /* Default value for CONFIG register (0xFF should be ok):
               controller->eeprom[size - 1] = M6811_NOSEC | M6811_NOCOP
                                              | M6811_ROMON | M6811_EEON;  */
            return 0;
          }
        return -1;
      }
  
    if (mode == O_RDONLY)
      {
        if (read (fd, controller->eeprom, size) != size)
  	{
  	  close (fd);
  	  return -1;
  	}
      }
    else
      {
        if (write (fd, controller->eeprom, size) != size)
  	{
  	  close (fd);
  	  return -1;
  	}
      }
    close (fd);
  
    return 0;
  }
  
  
  
  
  static void
  attach_m68hc11eepr_regs (struct hw *me,
                           struct m68hc11eepr *controller)
  {
    unsigned_word attach_address;
    int attach_space;
    unsigned attach_size;
    reg_property_spec reg;
  
    if (hw_find_property (me, "reg") == NULL)
      hw_abort (me, "Missing \"reg\" property");
  
    if (!hw_find_reg_array_property (me, "reg", 0, &reg))
      hw_abort (me, "\"reg\" property must contain one addr/size entry");
  
    hw_unit_address_to_attach_address (hw_parent (me),
  				     &reg.address,
  				     &attach_space,
  				     &attach_address,
  				     me);
    hw_unit_size_to_attach_size (hw_parent (me),
  			       &reg.size,
  			       &attach_size, me);
  
    /* Attach the two IO registers that control the EEPROM.
       The EEPROM is only attached at reset time because it may
       be enabled/disabled by the EEON bit in the CONFIG register.  */
    hw_attach_address (hw_parent (me), M6811_IO_LEVEL,
                       io_map, M6811_PPROG, 1, me);
    hw_attach_address (hw_parent (me), M6811_IO_LEVEL,
                       io_map, M6811_CONFIG, 1, me);
  
    if (hw_find_property (me, "file") == NULL)
      controller->file_name = "m6811.eeprom";
    else
      controller->file_name = hw_find_string_property (me, "file");
    
    controller->attach_space = attach_space;
    controller->base_address = attach_address;
    controller->eeprom = (char*) hw_malloc (me, attach_size + 1);
    controller->eeprom_min_cycles = 10000;
    controller->size = attach_size + 1;
    controller->mapped = 0;
    
    m6811eepr_memory_rw (controller, O_RDONLY);
  }
  
  
  /* An event arrives on an interrupt port.  */
  
  static void
  m68hc11eepr_port_event (struct hw *me,
                          int my_port,
                          struct hw *source,
                          int source_port,
                          int level)
  {
    SIM_DESC sd;
    struct m68hc11eepr *controller;
    sim_cpu *cpu;
    
    controller = hw_data (me);
    sd         = hw_system (me);
    cpu        = STATE_CPU (sd, 0);
    switch (my_port)
      {
      case RESET_PORT:
        {
  	HW_TRACE ((me, "EEPROM reset"));
  
          /* Re-read the EEPROM from the file.  This gives the chance
             to users to erase this file before doing a reset and have
             a fresh EEPROM taken into account.  */
          m6811eepr_memory_rw (controller, O_RDONLY);
  
          /* Reset the state of EEPROM programmer.  The CONFIG register
             is also initialized from the EEPROM/file content.  */
          cpu->ios[M6811_PPROG]    = 0;
          if (cpu->cpu_use_local_config)
            cpu->ios[M6811_CONFIG] = cpu->cpu_config;
          else
            cpu->ios[M6811_CONFIG]   = controller->eeprom[controller->size-1];
          controller->eeprom_wmode = 0;
          controller->eeprom_waddr = 0;
          controller->eeprom_wbyte = 0;
  
          /* Attach or detach to the bus depending on the EEPROM enable bit.
             The EEPROM CONFIG register is still enabled and can be programmed
             for a next configuration (taken into account only after a reset,
             see Motorola spec).  */
          if (!(cpu->ios[M6811_CONFIG] & M6811_EEON))
            {
              if (controller->mapped)
                hw_detach_address (hw_parent (me), M6811_EEPROM_LEVEL,
                                   controller->attach_space,
                                   controller->base_address,
                                   controller->size - 1,
                                   me);
              controller->mapped = 0;
            }
          else
            {
              if (!controller->mapped)
                hw_attach_address (hw_parent (me), M6811_EEPROM_LEVEL,
                                   controller->attach_space,
                                   controller->base_address,
                                   controller->size - 1,
                                   me);
              controller->mapped = 1;
            }
          break;
        }
  
      default:
        hw_abort (me, "Event on unknown port %d", my_port);
        break;
      }
  }
  
  
  static void
  m68hc11eepr_finish (struct hw *me)
  {
    struct m68hc11eepr *controller;
  
    controller = HW_ZALLOC (me, struct m68hc11eepr);
    set_hw_data (me, controller);
    set_hw_io_read_buffer (me, m68hc11eepr_io_read_buffer);
    set_hw_io_write_buffer (me, m68hc11eepr_io_write_buffer);
    set_hw_ports (me, m68hc11eepr_ports);
    set_hw_port_event (me, m68hc11eepr_port_event);
  #ifdef set_hw_ioctl
    set_hw_ioctl (me, m68hc11eepr_ioctl);
  #else
    me->to_ioctl = m68hc11eepr_ioctl;
  #endif
  
    attach_m68hc11eepr_regs (me, controller);
  }
   
  
  
  static io_reg_desc pprog_desc[] = {
    { M6811_BYTE,  "BYTE  ", "Byte Program Mode" },
    { M6811_ROW,   "ROW   ", "Row Program Mode" },
    { M6811_ERASE, "ERASE ", "Erase Mode" },
    { M6811_EELAT, "EELAT ", "EEProm Latch Control" },
    { M6811_EEPGM, "EEPGM ", "EEProm Programming Voltable Enable" },
    { 0,  0, 0 }
  };
  extern io_reg_desc config_desc[];
  
  
  /* Describe the state of the EEPROM device.  */
  static void
  m68hc11eepr_info (struct hw *me)
  {
    SIM_DESC sd;
    uint16 base = 0;
    sim_cpu *cpu;
    struct m68hc11eepr *controller;
    uint8 val;
    
    sd         = hw_system (me);
    cpu        = STATE_CPU (sd, 0);
    controller = hw_data (me);
    base       = cpu_get_io_base (cpu);
    
    sim_io_printf (sd, "M68HC11 EEprom:\n");
  
    val = cpu->ios[M6811_PPROG];
    print_io_byte (sd, "PPROG  ", pprog_desc, val, base + M6811_PPROG);
    sim_io_printf (sd, "\n");
  
    val = cpu->ios[M6811_CONFIG];
    print_io_byte (sd, "CONFIG ", config_desc, val, base + M6811_CONFIG);
    sim_io_printf (sd, "\n");
  
    val = controller->eeprom[controller->size - 1];
    print_io_byte (sd, "(*NEXT*) ", config_desc, val, base + M6811_CONFIG);
    sim_io_printf (sd, "\n");
    
    /* Describe internal state of EEPROM.  */
    if (controller->eeprom_wmode)
      {
        if (controller->eeprom_waddr == controller->size - 1)
          sim_io_printf (sd, "  Programming CONFIG register ");
        else
          sim_io_printf (sd, "  Programming: 0x%04x ",
                         controller->eeprom_waddr + controller->base_address);
  
        sim_io_printf (sd, "with 0x%02x\n",
  		     controller->eeprom_wbyte);
      }
  
    sim_io_printf (sd, "  EEProm file: %s\n",
                   controller->file_name);
  }
  
  static int
  m68hc11eepr_ioctl (struct hw *me,
  		   hw_ioctl_request request,
  		   va_list ap)
  {
    m68hc11eepr_info (me);
    return 0;
  }
  
  /* generic read/write */
  
  static unsigned
  m68hc11eepr_io_read_buffer (struct hw *me,
  			    void *dest,
  			    int space,
  			    unsigned_word base,
  			    unsigned nr_bytes)
  {
    SIM_DESC sd;
    struct m68hc11eepr *controller;
    sim_cpu *cpu;
    
    HW_TRACE ((me, "read 0x%08lx %d", (long) base, (int) nr_bytes));
  
    sd         = hw_system (me);
    controller = hw_data (me);
    cpu        = STATE_CPU (sd, 0);
  
    if (space == io_map)
      {
        unsigned cnt = 0;
        
        while (nr_bytes != 0)
          {
            switch (base)
              {
              case M6811_PPROG:
              case M6811_CONFIG:
                *((uint8*) dest) = cpu->ios[base];
                break;
  
              default:
                hw_abort (me, "reading wrong register 0x%04x", base);
              }
            dest = (uint8*) (dest) + 1;
            base++;
            nr_bytes--;
            cnt++;
          }
        return cnt;
      }
  
    /* In theory, we can't read the EEPROM when it's being programmed.  */
    if ((cpu->ios[M6811_PPROG] & M6811_EELAT) != 0
        && cpu_is_running (cpu))
      {
        sim_memory_error (cpu, SIM_SIGBUS, base,
  			"EEprom not configured for reading");
      }
  
    base = base - controller->base_address;
    memcpy (dest, &controller->eeprom[base], nr_bytes);
    return nr_bytes;
  }
  
  
  static unsigned
  m68hc11eepr_io_write_buffer (struct hw *me,
  			     const void *source,
  			     int space,
  			     unsigned_word base,
  			     unsigned nr_bytes)
  {
    SIM_DESC sd;
    struct m68hc11eepr *controller;
    sim_cpu *cpu;
    uint8 val;
  
    HW_TRACE ((me, "write 0x%08lx %d", (long) base, (int) nr_bytes));
  
    sd         = hw_system (me);
    controller = hw_data (me);
    cpu        = STATE_CPU (sd, 0);
  
    /* Programming several bytes at a time is not possible.  */
    if (space != io_map && nr_bytes != 1)
      {
        sim_memory_error (cpu, SIM_SIGBUS, base,
  			"EEprom write error (only 1 byte can be programmed)");
        return 0;
      }
    
    if (nr_bytes != 1)
      hw_abort (me, "Cannot write more than 1 byte to EEPROM device at a time");
  
    val = *((const uint8*) source);
  
    /* Write to the EEPROM control register.  */
    if (space == io_map && base == M6811_PPROG)
      {
        uint8 wrong_bits;
        uint16 addr;
        
        addr = base + cpu_get_io_base (cpu);
  
        /* Setting EELAT and EEPGM at the same time is an error.
           Clearing them both is ok.  */
        wrong_bits = (cpu->ios[M6811_PPROG] ^ val) & val;
        wrong_bits &= (M6811_EELAT | M6811_EEPGM);
  
        if (wrong_bits == (M6811_EEPGM|M6811_EELAT))
  	{
  	  sim_memory_error (cpu, SIM_SIGBUS, addr,
  			    "Wrong eeprom programing value");
  	  return 0;
  	}
  
        if ((val & M6811_EELAT) == 0)
  	{
  	  val = 0;
  	}
        if ((val & M6811_EEPGM) && !(cpu->ios[M6811_PPROG] & M6811_EELAT))
  	{
  	  sim_memory_error (cpu, SIM_SIGBUS, addr,
  			    "EEProm high voltage applied after EELAT");
  	}
        if ((val & M6811_EEPGM) && controller->eeprom_wmode == 0)
  	{
  	  sim_memory_error (cpu, SIM_SIGSEGV, addr,
  			    "EEProm high voltage applied without address");
  	}
        if (val & M6811_EEPGM)
  	{
  	  controller->eeprom_wcycle = cpu_current_cycle (cpu);
  	}
        else if (cpu->ios[M6811_PPROG] & M6811_PPROG)
  	{
  	  int i;
  	  unsigned long t = cpu_current_cycle (cpu);
  
  	  t -= controller->eeprom_wcycle;
  	  if (t < controller->eeprom_min_cycles)
  	    {
  	      sim_memory_error (cpu, SIM_SIGILL, addr,
  				"EEprom programmed only for %lu cycles",
  				t);
  	    }
  
  	  /* Program the byte by clearing some bits.  */
  	  if (!(cpu->ios[M6811_PPROG] & M6811_ERASE))
  	    {
  	      controller->eeprom[controller->eeprom_waddr]
  		&= controller->eeprom_wbyte;
  	    }
  
  	  /* Erase a byte, row or the complete eeprom.  Erased value is 0xFF.
               Ignore row or complete eeprom erase when we are programming the
               CONFIG register (last EEPROM byte).  */
  	  else if ((cpu->ios[M6811_PPROG] & M6811_BYTE)
                     || controller->eeprom_waddr == controller->size - 1)
  	    {
  	      controller->eeprom[controller->eeprom_waddr] = 0xff;
  	    }
  	  else if (cpu->ios[M6811_BYTE] & M6811_ROW)
  	    {
                size_t max_size;
  
                /* Size of EEPROM (-1 because the last byte is the
                   CONFIG register.  */
                max_size = controller->size;
  	      controller->eeprom_waddr &= 0xFFF0;
  	      for (i = 0; i < 16
                       && controller->eeprom_waddr < max_size; i++)
  		{
  		  controller->eeprom[controller->eeprom_waddr] = 0xff;
  		  controller->eeprom_waddr ++;
  		}
  	    }
  	  else
  	    {
                size_t max_size;
  
                max_size = controller->size;
  	      for (i = 0; i < max_size; i++)
  		{
  		  controller->eeprom[i] = 0xff;
  		}
  	    }
  
  	  /* Save the eeprom in a file.  We have to save after each
  	     change because the simulator can be stopped or crash...  */
  	  if (m6811eepr_memory_rw (controller, O_WRONLY | O_CREAT) != 0)
  	    {
  	      sim_memory_error (cpu, SIM_SIGABRT, addr,
  				"EEPROM programing failed: errno=%d", errno);
  	    }
  	  controller->eeprom_wmode = 0;
  	}
        cpu->ios[M6811_PPROG] = val;
        return 1;
      }
  
    /* The CONFIG IO register is mapped at end of EEPROM.
       It's not visible.  */
    if (space == io_map && base == M6811_CONFIG)
      {
        base = controller->size - 1;
      }
    else
      {
        base = base - controller->base_address;
      }
  
    /* Writing the memory is allowed for the Debugger or simulator
       (cpu not running).  */
    if (cpu_is_running (cpu))
      {
        if ((cpu->ios[M6811_PPROG] & M6811_EELAT) == 0)
  	{
  	  sim_memory_error (cpu, SIM_SIGSEGV, base,
  			    "EEprom not configured for writing");
  	  return 0;
  	}
        if (controller->eeprom_wmode != 0)
  	{
  	  sim_memory_error (cpu, SIM_SIGSEGV, base,
  			    "EEprom write error");
  	  return 0;
  	}
        controller->eeprom_wmode = 1;
        controller->eeprom_waddr = base;
        controller->eeprom_wbyte = val;
      }
    else
      {
        controller->eeprom[base] = val;
        m6811eepr_memory_rw (controller, O_WRONLY);
      }
    
    return 1;
  }
  
  const struct hw_descriptor dv_m68hc11eepr_descriptor[] = {
    { "m68hc11eepr", m68hc11eepr_finish },
    { "m68hc12eepr", m68hc11eepr_finish },
    { NULL },
  };
  
  