URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [or1ksim/] [peripheral/] [atahost.c] - Blame information for rev 33

Go to most recent revision | Details | Compare with Previous | View Log


/* atahost.c -- ATA Host code simulation
 
   Copyright (C) 2002 Richard Herveille, rherveille@opencores.org
   Copyright (C) 2008 Embecosm Limited
 
   Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>
 
   This file is part of Or1ksim, the OpenRISC 1000 Architectural Simulator.
 
   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/>.  */
 
/* This program is commented throughout in a fashion suitable for processing
   with Doxygen. */
 
 
/* Autoconf and/or portability configuration */
#include "config.h"
#include "port.h"
 
/* System includes */
#include <stdlib.h>
 
/* Package includes */
#include "atahost.h"
#include "sim-config.h"
#include "abstract.h"
#include "pic.h"
#include "toplevel-support.h"
#include "sim-cmd.h"
 
 
/* default timing reset values */
#define PIO_MODE0_T1 6
#define PIO_MODE0_T2 28
#define PIO_MODE0_T4 2
#define PIO_MODE0_TEOC 23
 
#define DMA_MODE0_TM 4
#define DMA_MODE0_TD 21
#define DMA_MODE0_TEOC 21
 
 
/* reset and initialize ATA host core(s) */
static void
ata_reset (void *dat)
{
  struct ata_host *ata = dat;
 
  // reset the core registers
  ata->regs.ctrl = 0x0001;
  ata->regs.stat = (ata->dev_id << 28) | (ata->rev << 24);
  ata->regs.pctr = (ata->pio_mode0_teoc << ATA_TEOC) |
    (ata->pio_mode0_t4 << ATA_T4) |
    (ata->pio_mode0_t2 << ATA_T2) | (ata->pio_mode0_t1 << ATA_T1);
  ata->regs.pftr0 = ata->regs.pctr;
  ata->regs.pftr1 = ata->regs.pctr;
  ata->regs.dtr0 = (ata->dma_mode0_teoc << ATA_TEOC) |
    (ata->dma_mode0_td << ATA_TD) | (ata->dma_mode0_tm << ATA_TM);
  ata->regs.dtr1 = ata->regs.dtr0;
  ata->regs.txb = 0;
 
  // inform simulator about new read/write delay timings
  adjust_rw_delay (ata->mem, ata_pio_delay (ata->regs.pctr),
                   ata_pio_delay (ata->regs.pctr));
 
  /* the reset bit in the control register 'ctrl' is set, reset connect ata-devices */
  ata_devices_hw_reset (&ata->devices, 1);
}
 
/* ========================================================================= */
 
 
/* Assert interrupt */
void
ata_int (void *dat)
{
  struct ata_host *ata = dat;
  if (!(ata->regs.stat & ATA_IDEIS))
    {
      ata->regs.stat |= ATA_IDEIS;
      report_interrupt (ata->irq);
    }
}
 
/* ========================================================================= */
 
 
/*
  Read a register
*/
static uint32_t
ata_read32 (oraddr_t addr, void *dat)
{
  struct ata_host *ata = dat;
 
  /* determine if ata_host or ata_device addressed */
  if (is_ata_hostadr (addr))
    {
      // Accesses to internal register take 2cycles
      adjust_rw_delay (ata->mem, 2, 2);
 
      switch (addr)
        {
        case ATA_CTRL:
          return ata->regs.ctrl;
 
        case ATA_STAT:
          return ata->regs.stat;
 
        case ATA_PCTR:
          return ata->regs.pctr;
 
        case ATA_PFTR0:
          return ata->dev_id > 1 ? ata->regs.pftr0 : 0;
 
        case ATA_PFTR1:
          return ata->dev_id > 1 ? ata->regs.pftr1 : 0;
 
        case ATA_DTR0:
          return ata->dev_id > 2 ? ata->regs.dtr0 : 0;
 
        case ATA_DTR1:
          return ata->dev_id > 2 ? ata->regs.dtr1 : 0;
 
        case ATA_RXB:
          return ata->dev_id > 2 ? ata->regs.rxb : 0;
 
        default:
          return 0;
        }
    }
 
  /* check if the controller is enabled */
  if (ata->regs.ctrl & ATA_IDE_EN)
    {
      // make sure simulator uses correct read/write delay timings
      if (((addr & 0x7f) == ATA_DR) && ata->dev_id > 1)
        {
          if (ata->dev_sel)
            adjust_rw_delay (ata->mem, ata_pio_delay (ata->regs.pftr1),
                             ata_pio_delay (ata->regs.pftr1));
          else
            adjust_rw_delay (ata->mem, ata_pio_delay (ata->regs.pftr0),
                             ata_pio_delay (ata->regs.pftr0));
        }
      else
        adjust_rw_delay (ata->mem, ata_pio_delay (ata->regs.pctr),
                         ata_pio_delay (ata->regs.pctr));
 
      return ata_devices_read (&ata->devices, addr & 0x7f);
    }
  return 0;
}
 
/* ========================================================================= */
 
 
/*
  Write a register
*/
static void
ata_write32 (oraddr_t addr, uint32_t value, void *dat)
{
  struct ata_host *ata = dat;
 
  /* determine if ata_host or ata_device addressed */
  if (is_ata_hostadr (addr))
    {
      // Accesses to internal register take 2cycles
      adjust_rw_delay (ata->mem, 2, 2);
 
      switch (addr)
        {
        case ATA_CTRL:
          ata->regs.ctrl = value;
 
          /* check if reset bit set, if so reset ata-devices    */
          if (value & ATA_RST)
            ata_devices_hw_reset (&ata->devices, 1);
          else
            ata_devices_hw_reset (&ata->devices, 0);
          break;
 
        case ATA_STAT:
          if (!(value & ATA_IDEIS) && (ata->regs.stat & ATA_IDEIS))
            {
              clear_interrupt (ata->irq);
              ata->regs.stat &= ~ATA_IDEIS;
            }
          break;
 
        case ATA_PCTR:
          ata->regs.pctr = value;
          break;
 
        case ATA_PFTR0:
          ata->regs.pftr0 = value;
          break;
 
        case ATA_PFTR1:
          ata->regs.pftr1 = value;
          break;
 
        case ATA_DTR0:
          ata->regs.dtr0 = value;
          break;
 
        case ATA_DTR1:
          ata->regs.dtr1 = value;
          break;
 
        case ATA_TXB:
          ata->regs.txb = value;
          break;
 
        default:
          /* ERROR-macro currently only supports simple strings. */
          /*
             fprintf(stderr, "ERROR  : Unknown register for OCIDEC(%1d).\n", DEV_ID );
 
             Tried to show some useful info here.
             But when using 'DM'-simulator-command, the screen gets filled with these messages.
             Thereby eradicating the usefulness of the message
           */
          break;
        }
      return;
    }
 
  /* check if the controller is enabled */
  if (ata->regs.ctrl & ATA_IDE_EN)
    {
      // make sure simulator uses correct read/write delay timings
      if (((addr & 0x7f) == ATA_DR) && (ata->dev_id > 1))
        {
          if (ata->dev_sel)
            adjust_rw_delay (ata->mem, ata_pio_delay (ata->regs.pftr1),
                             ata_pio_delay (ata->regs.pftr1));
          else
            adjust_rw_delay (ata->mem, ata_pio_delay (ata->regs.pftr0),
                             ata_pio_delay (ata->regs.pftr0));
        }
      else
        adjust_rw_delay (ata->mem, ata_pio_delay (ata->regs.pctr),
                         ata_pio_delay (ata->regs.pctr));
 
      if ((addr & 0x7f) == ATA_DHR)
        ata->dev_sel = value & ATA_DHR_DEV;
 
      ata_devices_write (&ata->devices, addr & 0x7f, value);
    }
}
 
/* ========================================================================= */
 
 
/* Dump status */
static void
ata_status (void *dat)
{
  struct ata_host *ata = dat;
 
  if (ata->baseaddr == 0)
    return;
 
  PRINTF ("\nOCIDEC-%1d at: 0x%" PRIxADDR "\n", ata->dev_id, ata->baseaddr);
  PRINTF ("ATA CTRL     : 0x%08" PRIx32 "\n", ata->regs.ctrl);
  PRINTF ("ATA STAT     : 0x%08" PRIx32 "\n", ata->regs.stat);
  PRINTF ("ATA PCTR     : 0x%08" PRIx32 "n", ata->regs.pctr);
 
  if (ata->dev_id > 1)
    {
      PRINTF ("ATA FCTR0    : 0x%08" PRIx32 "\n", ata->regs.pftr0);
      PRINTF ("ATA FCTR1    : 0x%08" PRIx32 "\n", ata->regs.pftr1);
    }
 
  if (ata->dev_id > 2)
    {
      PRINTF ("ATA DTR0     : 0x%08" PRIx32 "\n", ata->regs.dtr0);
      PRINTF ("ATA DTR1     : 0x%08" PRIx32 "\n", ata->regs.dtr1);
      PRINTF ("ATA TXD      : 0x%08" PRIx32 "\n", ata->regs.txb);
      PRINTF ("ATA RXD      : 0x%08" PRIx32 "\n", ata->regs.rxb);
    }
}
 
/* ========================================================================= */
 
/*----------------------------------------------------[ ATA Configuration ]---*/
static unsigned int conf_dev;
 
static void
ata_baseaddr (union param_val val, void *dat)
{
  struct ata_host *ata = dat;
  ata->baseaddr = val.addr_val;
}
 
static void
ata_irq (union param_val val, void *dat)
{
  struct ata_host *ata = dat;
  ata->irq = val.int_val;
}
 
static void
ata_dev_id (union param_val val, void *dat)
{
  struct ata_host *ata = dat;
  if (val.int_val < 1 || val.int_val > 3)
    {
      fprintf (stderr, "Peripheral ATA: Unknown device id %d, useing 1\n",
               val.int_val);
      ata->dev_id = 1;
      return;
    }
 
  ata->dev_id = val.int_val;
}
 
 
/*---------------------------------------------------------------------------*/
/*!Set the ATA revision
 
   This must be in the range 0-15, to fit in the relevant field. Anything
   larger is truncated with a warning.
 
   @param[in] val  The value to use
   @param[in] dat  The config data structure                                 */
/*---------------------------------------------------------------------------*/
static void
ata_rev (union param_val val, void *dat)
{
  struct ata_host *ata = dat;
 
  if (val.int_val > 0xf)
    {
      fprintf (stderr, "Warning: ATA rev > 4 bits: truncated\n");
    }
 
  ata->rev = val.int_val & 0xf;
}
 
static void
ata_pio_mode0_t1 (union param_val val, void *dat)
{
  struct ata_host *ata = dat;
 
  if (val.int_val < 0 || val.int_val > 255)
    {
      fprintf (stderr, "Peripheral ATA: Invalid pio_mode0_t1: %d\n",
               val.int_val);
      return;
    }
 
  ata->pio_mode0_t1 = val.int_val;
}
 
static void
ata_pio_mode0_t2 (union param_val val, void *dat)
{
  struct ata_host *ata = dat;
 
  if (val.int_val < 0 || val.int_val > 255)
    {
      fprintf (stderr, "Peripheral ATA: Invalid pio_mode0_t2: %d\n",
               val.int_val);
      return;
    }
 
  ata->pio_mode0_t2 = val.int_val;
}
 
static void
ata_pio_mode0_t4 (union param_val val, void *dat)
{
  struct ata_host *ata = dat;
 
  if (val.int_val < 0 || val.int_val > 255)
    {
      fprintf (stderr, "Peripheral ATA: Invalid pio_mode0_t4: %d\n",
               val.int_val);
      return;
    }
 
  ata->pio_mode0_t4 = val.int_val;
}
 
static void
ata_pio_mode0_teoc (union param_val val, void *dat)
{
  struct ata_host *ata = dat;
 
  if (val.int_val < 0 || val.int_val > 255)
    {
      fprintf (stderr, "Peripheral ATA: Invalid pio_mode0_teoc: %d\n",
               val.int_val);
      return;
    }
 
  ata->pio_mode0_teoc = val.int_val;
}
 
static void
ata_dma_mode0_tm (union param_val val, void *dat)
{
  struct ata_host *ata = dat;
 
  if (val.int_val < 0 || val.int_val > 255)
    {
      fprintf (stderr, "Peripheral ATA: Invalid dma_mode0_tm: %d\n",
               val.int_val);
      return;
    }
 
  ata->dma_mode0_tm = val.int_val;
}
 
static void
ata_dma_mode0_td (union param_val val, void *dat)
{
  struct ata_host *ata = dat;
 
  if (val.int_val < 0 || val.int_val > 255)
    {
      fprintf (stderr, "Peripheral ATA: Invalid dma_mode0_td: %d\n",
               val.int_val);
      return;
    }
 
  ata->dma_mode0_td = val.int_val;
}
 
static void
ata_dma_mode0_teoc (union param_val val, void *dat)
{
  struct ata_host *ata = dat;
 
  if (val.int_val < 0 || val.int_val > 255)
    {
      fprintf (stderr, "Peripheral ATA: Invalid dma_mode0_teoc: %d\n",
               val.int_val);
      return;
    }
 
  ata->dma_mode0_teoc = val.int_val;
}
 
static void
ata_type (union param_val val, void *dat)
{
  struct ata_host *ata = dat;
  if (conf_dev <= 1)
    ata->devices.device[conf_dev].conf.type = val.int_val;
}
 
 
/*---------------------------------------------------------------------------*/
/*!Set the ATA file
 
   Free any previously allocated value. Only used if device type is 1.
 
   @param[in] val  The value to use
   @param[in] dat  The config data structure                                 */
/*---------------------------------------------------------------------------*/
static void
ata_file (union param_val val, void *dat)
{
  struct ata_host *ata = dat;
 
  if (conf_dev <= 1)
    {
      if (NULL != ata->devices.device[conf_dev].conf.file)
        {
          free (ata->devices.device[conf_dev].conf.file);
          ata->devices.device[conf_dev].conf.file = NULL;
        }
 
      if (!(ata->devices.device[conf_dev].conf.file = strdup (val.str_val)))
        {
          fprintf (stderr, "Peripheral ATA: Run out of memory\n");
          exit (-1);
        }
    }
}       /* ata_file() */
 
 
static void
ata_size (union param_val val, void *dat)
{
  struct ata_host *ata = dat;
  if (conf_dev <= 1)
    ata->devices.device[conf_dev].conf.size = val.int_val << 20;
}
 
static void
ata_packet (union param_val val, void *dat)
{
  struct ata_host *ata = dat;
  if (conf_dev <= 1)
    ata->devices.device[conf_dev].conf.packet = val.int_val;
}
 
static void
ata_enabled (union param_val val, void *dat)
{
  struct ata_host *ata = dat;
  ata->enabled = val.int_val;
}
 
static void
ata_heads (union param_val val, void *dat)
{
  struct ata_host *ata = dat;
  if (conf_dev <= 1)
    ata->devices.device[conf_dev].conf.heads = val.int_val;
}
 
static void
ata_sectors (union param_val val, void *dat)
{
  struct ata_host *ata = dat;
  if (conf_dev <= 1)
    ata->devices.device[conf_dev].conf.sectors = val.int_val;
}
 
static void
ata_firmware (union param_val val, void *dat)
{
  struct ata_host *ata = dat;
  if (conf_dev <= 1)
    if (!(ata->devices.device[conf_dev].conf.firmware = strdup (val.str_val)))
      {
        fprintf (stderr, "Peripheral ATA: Run out of memory\n");
        exit (-1);
      }
}
 
 
/*---------------------------------------------------------------------------*/
/*!Set the ATA multi-word DMA mode
 
   Must be -1, 0, 1 or 2.
 
   @param[in] val  The value to use
   @param[in] dat  The config data structure                                 */
/*---------------------------------------------------------------------------*/
static void
ata_mwdma (union param_val  val,
           void            *dat)
{
  struct ata_host *ata = dat;
 
  if ((val.int_val >= -1) && (val.int_val <= 2))
    {
      ata->devices.device[conf_dev].conf.mwdma = val.int_val;
    }
  else
    {
      fprintf (stderr, "Warning: invalid ATA multi-word DMA mode: ignored\n");
    }
}       /* ata_mwdma() */
 
 
/*---------------------------------------------------------------------------*/
/*!Set the ATA programmed I/O mode
 
   Must be 0, 1, 2, 3 or 4.
 
   @param[in] val  The value to use
   @param[in] dat  The config data structure                                 */
/*---------------------------------------------------------------------------*/
static void
ata_pio (union param_val  val,
         void            *dat)
{
  struct ata_host *ata = dat;
 
  if ((val.int_val >= 0) && (val.int_val <= 4))
    {
      ata->devices.device[conf_dev].conf.pio = val.int_val;
    }
  else
    {
      fprintf (stderr, "Warning: invalid ATA programmed I/O mode: ignored\n");
    }
}       /* ata_pio() */
 
 
static void
ata_start_device (union param_val val, void *dat)
{
  conf_dev = val.int_val;
 
  if (conf_dev > 1)
    fprintf (stderr, "Device %d out-of-range\n", conf_dev);
}
 
static void
ata_enddevice (union param_val val, void *dat)
{
  conf_dev = 2;
}
 
/*---------------------------------------------------------------------------*/
/*!Initialize a new ATA configuration
 
   ALL parameters are set explicitly to default values.                      */
/*---------------------------------------------------------------------------*/
static void *
ata_sec_start (void)
{
  struct ata_host *new = malloc (sizeof (struct ata_host));
 
  if (!new)
    {
      fprintf (stderr, "Peripheral ATA: Run out of memory\n");
      exit (-1);
    }
 
  memset (new, 0, sizeof (struct ata_host));
 
  new->enabled        = 1;
  new->baseaddr       = 0;
  new->irq            = 0;
  new->dev_id         = 1;
  new->rev            = 0;
 
  new->pio_mode0_t1   = PIO_MODE0_T1;
  new->pio_mode0_t2   = PIO_MODE0_T2;
  new->pio_mode0_t4   = PIO_MODE0_T4;
  new->pio_mode0_teoc = PIO_MODE0_TEOC;
 
  new->dma_mode0_tm   = DMA_MODE0_TM;
  new->dma_mode0_td   = DMA_MODE0_TD;
  new->dma_mode0_teoc = DMA_MODE0_TEOC;
 
  new->devices.device[0].conf.type     = 0;
  new->devices.device[0].conf.file     = strdup ("ata_file0");
  new->devices.device[0].conf.size     = 0;
  new->devices.device[0].conf.packet   = 0;
  new->devices.device[0].conf.heads    = 7;
  new->devices.device[0].conf.sectors  = 32;
  new->devices.device[0].conf.firmware = "02207031";
  new->devices.device[0].conf.mwdma    = 2;
  new->devices.device[0].conf.pio      = 4;
 
  new->devices.device[1].conf.type     = 0;
  new->devices.device[1].conf.file     = strdup ("ata_file1");
  new->devices.device[1].conf.size     = 0;
  new->devices.device[1].conf.packet   = 0;
  new->devices.device[1].conf.heads    = 7;
  new->devices.device[1].conf.sectors  = 32;
  new->devices.device[1].conf.firmware = "02207031";
  new->devices.device[1].conf.mwdma    = 2;
  new->devices.device[1].conf.pio      = 4;
 
  return new;
 
}       /* ata_sec_start() */
 
 
static void
ata_sec_end (void *dat)
{
  struct ata_host *ata = dat;
  struct mem_ops ops;
 
  if (!ata->enabled)
    {
      free (dat);
      return;
    }
 
  /* Connect ata_devices.                                            */
  ata_devices_init (&ata->devices);
  ata->devices.device[0].internals.host = ata;
  ata->devices.device[1].internals.host = ata;
 
  memset (&ops, 0, sizeof (struct mem_ops));
 
  ops.readfunc32 = ata_read32;
  ops.read_dat32 = dat;
  ops.writefunc32 = ata_write32;
  ops.write_dat32 = dat;
 
  /* Delays will be readjusted later */
  ops.delayr = 2;
  ops.delayw = 2;
 
  ata->mem = reg_mem_area (ata->baseaddr, ATA_ADDR_SPACE, 0, &ops);
 
  reg_sim_reset (ata_reset, dat);
  reg_sim_stat (ata_status, dat);
}
 
void
reg_ata_sec ()
{
  struct config_section *sec =
    reg_config_sec ("ata", ata_sec_start, ata_sec_end);
 
  reg_config_param (sec, "enabled", paramt_int, ata_enabled);
  reg_config_param (sec, "baseaddr", paramt_addr, ata_baseaddr);
  reg_config_param (sec, "irq", paramt_int, ata_irq);
  reg_config_param (sec, "dev_id", paramt_int, ata_dev_id);
  reg_config_param (sec, "rev", paramt_int, ata_rev);
 
  reg_config_param (sec, "pio_mode0_t1", paramt_int, ata_pio_mode0_t1);
  reg_config_param (sec, "pio_mode0_t2", paramt_int, ata_pio_mode0_t2);
  reg_config_param (sec, "pio_mode0_t4", paramt_int, ata_pio_mode0_t4);
  reg_config_param (sec, "pio_mode0_teoc", paramt_int, ata_pio_mode0_teoc);
 
  reg_config_param (sec, "dma_mode0_tm", paramt_int, ata_dma_mode0_tm);
  reg_config_param (sec, "dma_mode0_td", paramt_int, ata_dma_mode0_td);
  reg_config_param (sec, "dma_mode0_teoc", paramt_int, ata_dma_mode0_teoc);
 
  reg_config_param (sec, "device", paramt_int, ata_start_device);
  reg_config_param (sec, "enddevice", paramt_int, ata_enddevice);
 
  reg_config_param (sec, "type", paramt_int, ata_type);
  reg_config_param (sec, "file", paramt_str, ata_file);
  reg_config_param (sec, "size", paramt_int, ata_size);
  reg_config_param (sec, "packet", paramt_int, ata_packet);
  reg_config_param (sec, "heads", paramt_int, ata_heads);
  reg_config_param (sec, "sectors", paramt_int, ata_sectors);
  reg_config_param (sec, "firmware", paramt_str, ata_firmware);
  reg_config_param (sec, "mwdma", paramt_int, ata_mwdma);
  reg_config_param (sec, "pio", paramt_int, ata_pio);
}

Browse

Tools

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [or1ksim/] [peripheral/] [atahost.c] - Blame information for rev 33

Line No.	Rev	Author	Line
1	19	jeremybenn	`/* atahost.c -- ATA Host code simulation`
2
3			`Copyright (C) 2002 Richard Herveille, rherveille@opencores.org`
4			`Copyright (C) 2008 Embecosm Limited`
5
6			`Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>`
7
8			`This file is part of Or1ksim, the OpenRISC 1000 Architectural Simulator.`
9
10			`This program is free software; you can redistribute it and/or modify it`
11			`under the terms of the GNU General Public License as published by the Free`
12			`Software Foundation; either version 3 of the License, or (at your option)`
13			`any later version.`
14
15			`This program is distributed in the hope that it will be useful, but WITHOUT`
16			`ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or`
17			`FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for`
18			`more details.`
19
20			`You should have received a copy of the GNU General Public License along`
21			`with this program. If not, see <http://www.gnu.org/licenses/>. */`
22
23			`/* This program is commented throughout in a fashion suitable for processing`
24			`with Doxygen. */`
25
26
27			`/* Autoconf and/or portability configuration */`
28			`#include "config.h"`
29			`#include "port.h"`
30
31			`/* System includes */`
32			`#include <stdlib.h>`
33
34			`/* Package includes */`
35			`#include "atahost.h"`
36			`#include "sim-config.h"`
37			`#include "abstract.h"`
38			`#include "pic.h"`
39			`#include "toplevel-support.h"`
40			`#include "sim-cmd.h"`
41
42
43			`/* default timing reset values */`
44			`#define PIO_MODE0_T1 6`
45			`#define PIO_MODE0_T2 28`
46			`#define PIO_MODE0_T4 2`
47			`#define PIO_MODE0_TEOC 23`
48
49			`#define DMA_MODE0_TM 4`
50			`#define DMA_MODE0_TD 21`
51			`#define DMA_MODE0_TEOC 21`
52
53
54			`/* reset and initialize ATA host core(s) */`
55			`static void`
56			`ata_reset (void *dat)`
57			`{`
58			`struct ata_host *ata = dat;`
59
60			`// reset the core registers`
61			`ata->regs.ctrl = 0x0001;`
62			`ata->regs.stat = (ata->dev_id << 28) \| (ata->rev << 24);`
63			`ata->regs.pctr = (ata->pio_mode0_teoc << ATA_TEOC) \|`
64			`(ata->pio_mode0_t4 << ATA_T4) \|`
65			`(ata->pio_mode0_t2 << ATA_T2) \| (ata->pio_mode0_t1 << ATA_T1);`
66			`ata->regs.pftr0 = ata->regs.pctr;`
67			`ata->regs.pftr1 = ata->regs.pctr;`
68			`ata->regs.dtr0 = (ata->dma_mode0_teoc << ATA_TEOC) \|`
69			`(ata->dma_mode0_td << ATA_TD) \| (ata->dma_mode0_tm << ATA_TM);`
70			`ata->regs.dtr1 = ata->regs.dtr0;`
71			`ata->regs.txb = 0;`
72
73			`// inform simulator about new read/write delay timings`
74			`adjust_rw_delay (ata->mem, ata_pio_delay (ata->regs.pctr),`
75			`ata_pio_delay (ata->regs.pctr));`
76
77			`/* the reset bit in the control register 'ctrl' is set, reset connect ata-devices */`
78			`ata_devices_hw_reset (&ata->devices, 1);`
79			`}`
80
81			`/* ========================================================================= */`
82
83
84			`/* Assert interrupt */`
85			`void`
86			`ata_int (void *dat)`
87			`{`
88			`struct ata_host *ata = dat;`
89			`if (!(ata->regs.stat & ATA_IDEIS))`
90			`{`
91			`ata->regs.stat \|= ATA_IDEIS;`
92			`report_interrupt (ata->irq);`
93			`}`
94			`}`
95
96			`/* ========================================================================= */`
97
98
99			`/*`
100			`Read a register`
101			`*/`
102			`static uint32_t`
103			`ata_read32 (oraddr_t addr, void *dat)`
104			`{`
105			`struct ata_host *ata = dat;`
106
107			`/* determine if ata_host or ata_device addressed */`
108			`if (is_ata_hostadr (addr))`
109			`{`
110			`// Accesses to internal register take 2cycles`
111			`adjust_rw_delay (ata->mem, 2, 2);`
112
113			`switch (addr)`
114			`{`
115			`case ATA_CTRL:`
116			`return ata->regs.ctrl;`
117
118			`case ATA_STAT:`
119			`return ata->regs.stat;`
120
121			`case ATA_PCTR:`
122			`return ata->regs.pctr;`
123
124			`case ATA_PFTR0:`
125			`return ata->dev_id > 1 ? ata->regs.pftr0 : 0;`
126
127			`case ATA_PFTR1:`
128			`return ata->dev_id > 1 ? ata->regs.pftr1 : 0;`
129
130			`case ATA_DTR0:`
131			`return ata->dev_id > 2 ? ata->regs.dtr0 : 0;`
132
133			`case ATA_DTR1:`
134			`return ata->dev_id > 2 ? ata->regs.dtr1 : 0;`
135
136			`case ATA_RXB:`
137			`return ata->dev_id > 2 ? ata->regs.rxb : 0;`
138
139			`default:`
140			`return 0;`
141			`}`
142			`}`
143
144			`/* check if the controller is enabled */`
145			`if (ata->regs.ctrl & ATA_IDE_EN)`
146			`{`
147			`// make sure simulator uses correct read/write delay timings`
148			`if (((addr & 0x7f) == ATA_DR) && ata->dev_id > 1)`
149			`{`
150			`if (ata->dev_sel)`
151			`adjust_rw_delay (ata->mem, ata_pio_delay (ata->regs.pftr1),`
152			`ata_pio_delay (ata->regs.pftr1));`
153			`else`
154			`adjust_rw_delay (ata->mem, ata_pio_delay (ata->regs.pftr0),`
155			`ata_pio_delay (ata->regs.pftr0));`
156			`}`
157			`else`
158			`adjust_rw_delay (ata->mem, ata_pio_delay (ata->regs.pctr),`
159			`ata_pio_delay (ata->regs.pctr));`
160
161			`return ata_devices_read (&ata->devices, addr & 0x7f);`
162			`}`
163			`return 0;`
164			`}`
165
166			`/* ========================================================================= */`
167
168
169			`/*`
170			`Write a register`
171			`*/`
172			`static void`
173			`ata_write32 (oraddr_t addr, uint32_t value, void *dat)`
174			`{`
175			`struct ata_host *ata = dat;`
176
177			`/* determine if ata_host or ata_device addressed */`
178			`if (is_ata_hostadr (addr))`
179			`{`
180			`// Accesses to internal register take 2cycles`
181			`adjust_rw_delay (ata->mem, 2, 2);`
182
183			`switch (addr)`
184			`{`
185			`case ATA_CTRL:`
186			`ata->regs.ctrl = value;`
187
188			`/* check if reset bit set, if so reset ata-devices */`
189			`if (value & ATA_RST)`
190			`ata_devices_hw_reset (&ata->devices, 1);`
191			`else`
192			`ata_devices_hw_reset (&ata->devices, 0);`
193			`break;`
194
195			`case ATA_STAT:`
196			`if (!(value & ATA_IDEIS) && (ata->regs.stat & ATA_IDEIS))`
197			`{`
198			`clear_interrupt (ata->irq);`
199			`ata->regs.stat &= ~ATA_IDEIS;`
200			`}`
201			`break;`
202
203			`case ATA_PCTR:`
204			`ata->regs.pctr = value;`
205			`break;`
206
207			`case ATA_PFTR0:`
208			`ata->regs.pftr0 = value;`
209			`break;`
210
211			`case ATA_PFTR1:`
212			`ata->regs.pftr1 = value;`
213			`break;`
214
215			`case ATA_DTR0:`
216			`ata->regs.dtr0 = value;`
217			`break;`
218
219			`case ATA_DTR1:`
220			`ata->regs.dtr1 = value;`
221			`break;`
222
223			`case ATA_TXB:`
224			`ata->regs.txb = value;`
225			`break;`
226
227			`default:`
228			`/* ERROR-macro currently only supports simple strings. */`
229			`/*`
230			`fprintf(stderr, "ERROR : Unknown register for OCIDEC(%1d).\n", DEV_ID );`
231
232			`Tried to show some useful info here.`
233			`But when using 'DM'-simulator-command, the screen gets filled with these messages.`
234			`Thereby eradicating the usefulness of the message`
235			`*/`
236			`break;`
237			`}`
238			`return;`
239			`}`
240
241			`/* check if the controller is enabled */`
242			`if (ata->regs.ctrl & ATA_IDE_EN)`
243			`{`
244			`// make sure simulator uses correct read/write delay timings`
245			`if (((addr & 0x7f) == ATA_DR) && (ata->dev_id > 1))`
246			`{`
247			`if (ata->dev_sel)`
248			`adjust_rw_delay (ata->mem, ata_pio_delay (ata->regs.pftr1),`
249			`ata_pio_delay (ata->regs.pftr1));`
250			`else`
251			`adjust_rw_delay (ata->mem, ata_pio_delay (ata->regs.pftr0),`
252			`ata_pio_delay (ata->regs.pftr0));`
253			`}`
254			`else`
255			`adjust_rw_delay (ata->mem, ata_pio_delay (ata->regs.pctr),`
256			`ata_pio_delay (ata->regs.pctr));`
257
258			`if ((addr & 0x7f) == ATA_DHR)`
259			`ata->dev_sel = value & ATA_DHR_DEV;`
260
261			`ata_devices_write (&ata->devices, addr & 0x7f, value);`
262			`}`
263			`}`
264
265			`/* ========================================================================= */`
266
267
268			`/* Dump status */`
269			`static void`
270			`ata_status (void *dat)`
271			`{`
272			`struct ata_host *ata = dat;`
273
274			`if (ata->baseaddr == 0)`
275			`return;`
276
277			`PRINTF ("\nOCIDEC-%1d at: 0x%" PRIxADDR "\n", ata->dev_id, ata->baseaddr);`
278			`PRINTF ("ATA CTRL : 0x%08" PRIx32 "\n", ata->regs.ctrl);`
279			`PRINTF ("ATA STAT : 0x%08" PRIx32 "\n", ata->regs.stat);`
280			`PRINTF ("ATA PCTR : 0x%08" PRIx32 "n", ata->regs.pctr);`
281
282			`if (ata->dev_id > 1)`
283			`{`
284			`PRINTF ("ATA FCTR0 : 0x%08" PRIx32 "\n", ata->regs.pftr0);`
285			`PRINTF ("ATA FCTR1 : 0x%08" PRIx32 "\n", ata->regs.pftr1);`
286			`}`
287
288			`if (ata->dev_id > 2)`
289			`{`
290			`PRINTF ("ATA DTR0 : 0x%08" PRIx32 "\n", ata->regs.dtr0);`
291			`PRINTF ("ATA DTR1 : 0x%08" PRIx32 "\n", ata->regs.dtr1);`
292			`PRINTF ("ATA TXD : 0x%08" PRIx32 "\n", ata->regs.txb);`
293			`PRINTF ("ATA RXD : 0x%08" PRIx32 "\n", ata->regs.rxb);`
294			`}`
295			`}`
296
297			`/* ========================================================================= */`
298
299			`/----------------------------------------------------[ ATA Configuration ]---/`
300			`static unsigned int conf_dev;`
301
302			`static void`
303			`ata_baseaddr (union param_val val, void *dat)`
304			`{`
305			`struct ata_host *ata = dat;`
306			`ata->baseaddr = val.addr_val;`
307			`}`
308
309			`static void`
310			`ata_irq (union param_val val, void *dat)`
311			`{`
312			`struct ata_host *ata = dat;`
313			`ata->irq = val.int_val;`
314			`}`
315
316			`static void`
317			`ata_dev_id (union param_val val, void *dat)`
318			`{`
319			`struct ata_host *ata = dat;`
320			`if (val.int_val < 1 \|\| val.int_val > 3)`
321			`{`
322			`fprintf (stderr, "Peripheral ATA: Unknown device id %d, useing 1\n",`
323			`val.int_val);`
324			`ata->dev_id = 1;`
325			`return;`
326			`}`
327
328			`ata->dev_id = val.int_val;`
329			`}`
330
331
332			`/---------------------------------------------------------------------------/`
333			`/*!Set the ATA revision`
334
335			`This must be in the range 0-15, to fit in the relevant field. Anything`
336			`larger is truncated with a warning.`
337
338			`@param[in] val The value to use`
339			`@param[in] dat The config data structure */`
340			`/---------------------------------------------------------------------------/`
341			`static void`
342			`ata_rev (union param_val val, void *dat)`
343			`{`
344			`struct ata_host *ata = dat;`
345
346			`if (val.int_val > 0xf)`
347			`{`
348			`fprintf (stderr, "Warning: ATA rev > 4 bits: truncated\n");`
349			`}`
350
351			`ata->rev = val.int_val & 0xf;`
352			`}`
353
354			`static void`
355			`ata_pio_mode0_t1 (union param_val val, void *dat)`
356			`{`
357			`struct ata_host *ata = dat;`
358
359			`if (val.int_val < 0 \|\| val.int_val > 255)`
360			`{`
361			`fprintf (stderr, "Peripheral ATA: Invalid pio_mode0_t1: %d\n",`
362			`val.int_val);`
363			`return;`
364			`}`
365
366			`ata->pio_mode0_t1 = val.int_val;`
367			`}`
368
369			`static void`
370			`ata_pio_mode0_t2 (union param_val val, void *dat)`
371			`{`
372			`struct ata_host *ata = dat;`
373
374			`if (val.int_val < 0 \|\| val.int_val > 255)`
375			`{`
376			`fprintf (stderr, "Peripheral ATA: Invalid pio_mode0_t2: %d\n",`
377			`val.int_val);`
378			`return;`
379			`}`
380
381			`ata->pio_mode0_t2 = val.int_val;`
382			`}`
383
384			`static void`
385			`ata_pio_mode0_t4 (union param_val val, void *dat)`
386			`{`
387			`struct ata_host *ata = dat;`
388
389			`if (val.int_val < 0 \|\| val.int_val > 255)`
390			`{`
391			`fprintf (stderr, "Peripheral ATA: Invalid pio_mode0_t4: %d\n",`
392			`val.int_val);`
393			`return;`
394			`}`
395
396			`ata->pio_mode0_t4 = val.int_val;`
397			`}`
398
399			`static void`
400			`ata_pio_mode0_teoc (union param_val val, void *dat)`
401			`{`
402			`struct ata_host *ata = dat;`
403
404			`if (val.int_val < 0 \|\| val.int_val > 255)`
405			`{`
406			`fprintf (stderr, "Peripheral ATA: Invalid pio_mode0_teoc: %d\n",`
407			`val.int_val);`
408			`return;`
409			`}`
410
411			`ata->pio_mode0_teoc = val.int_val;`
412			`}`
413
414			`static void`
415			`ata_dma_mode0_tm (union param_val val, void *dat)`
416			`{`
417			`struct ata_host *ata = dat;`
418
419			`if (val.int_val < 0 \|\| val.int_val > 255)`
420			`{`
421			`fprintf (stderr, "Peripheral ATA: Invalid dma_mode0_tm: %d\n",`
422			`val.int_val);`
423			`return;`
424			`}`
425
426			`ata->dma_mode0_tm = val.int_val;`
427			`}`
428
429			`static void`
430			`ata_dma_mode0_td (union param_val val, void *dat)`
431			`{`
432			`struct ata_host *ata = dat;`
433
434			`if (val.int_val < 0 \|\| val.int_val > 255)`
435			`{`
436			`fprintf (stderr, "Peripheral ATA: Invalid dma_mode0_td: %d\n",`
437			`val.int_val);`
438			`return;`
439			`}`
440
441			`ata->dma_mode0_td = val.int_val;`
442			`}`
443
444			`static void`
445			`ata_dma_mode0_teoc (union param_val val, void *dat)`
446			`{`
447			`struct ata_host *ata = dat;`
448
449			`if (val.int_val < 0 \|\| val.int_val > 255)`
450			`{`
451			`fprintf (stderr, "Peripheral ATA: Invalid dma_mode0_teoc: %d\n",`
452			`val.int_val);`
453			`return;`
454			`}`
455
456			`ata->dma_mode0_teoc = val.int_val;`
457			`}`
458
459			`static void`
460			`ata_type (union param_val val, void *dat)`
461			`{`
462			`struct ata_host *ata = dat;`
463			`if (conf_dev <= 1)`
464			`ata->devices.device[conf_dev].conf.type = val.int_val;`
465			`}`
466
467
468			`/---------------------------------------------------------------------------/`
469			`/*!Set the ATA file`
470
471			`Free any previously allocated value. Only used if device type is 1.`
472
473			`@param[in] val The value to use`
474			`@param[in] dat The config data structure */`
475			`/---------------------------------------------------------------------------/`
476			`static void`
477			`ata_file (union param_val val, void *dat)`
478			`{`
479			`struct ata_host *ata = dat;`
480
481			`if (conf_dev <= 1)`
482			`{`
483			`if (NULL != ata->devices.device[conf_dev].conf.file)`
484			`{`
485			`free (ata->devices.device[conf_dev].conf.file);`
486			`ata->devices.device[conf_dev].conf.file = NULL;`
487			`}`
488
489			`if (!(ata->devices.device[conf_dev].conf.file = strdup (val.str_val)))`
490			`{`
491			`fprintf (stderr, "Peripheral ATA: Run out of memory\n");`
492			`exit (-1);`
493			`}`
494			`}`
495			`} /* ata_file() */`
496
497
498			`static void`
499			`ata_size (union param_val val, void *dat)`
500			`{`
501			`struct ata_host *ata = dat;`
502			`if (conf_dev <= 1)`
503			`ata->devices.device[conf_dev].conf.size = val.int_val << 20;`
504			`}`
505
506			`static void`
507			`ata_packet (union param_val val, void *dat)`
508			`{`
509			`struct ata_host *ata = dat;`
510			`if (conf_dev <= 1)`
511			`ata->devices.device[conf_dev].conf.packet = val.int_val;`
512			`}`
513
514			`static void`
515			`ata_enabled (union param_val val, void *dat)`
516			`{`
517			`struct ata_host *ata = dat;`
518			`ata->enabled = val.int_val;`
519			`}`
520
521			`static void`
522			`ata_heads (union param_val val, void *dat)`
523			`{`
524			`struct ata_host *ata = dat;`
525			`if (conf_dev <= 1)`
526			`ata->devices.device[conf_dev].conf.heads = val.int_val;`
527			`}`
528
529			`static void`
530			`ata_sectors (union param_val val, void *dat)`
531			`{`
532			`struct ata_host *ata = dat;`
533			`if (conf_dev <= 1)`
534			`ata->devices.device[conf_dev].conf.sectors = val.int_val;`
535			`}`
536
537			`static void`
538			`ata_firmware (union param_val val, void *dat)`
539			`{`
540			`struct ata_host *ata = dat;`
541			`if (conf_dev <= 1)`
542			`if (!(ata->devices.device[conf_dev].conf.firmware = strdup (val.str_val)))`
543			`{`
544			`fprintf (stderr, "Peripheral ATA: Run out of memory\n");`
545			`exit (-1);`
546			`}`
547			`}`
548
549
550			`/---------------------------------------------------------------------------/`
551			`/*!Set the ATA multi-word DMA mode`
552
553			`Must be -1, 0, 1 or 2.`
554
555			`@param[in] val The value to use`
556			`@param[in] dat The config data structure */`
557			`/---------------------------------------------------------------------------/`
558			`static void`
559			`ata_mwdma (union param_val val,`
560			`void *dat)`
561			`{`
562			`struct ata_host *ata = dat;`
563
564			`if ((val.int_val >= -1) && (val.int_val <= 2))`
565			`{`
566			`ata->devices.device[conf_dev].conf.mwdma = val.int_val;`
567			`}`
568			`else`
569			`{`
570			`fprintf (stderr, "Warning: invalid ATA multi-word DMA mode: ignored\n");`
571			`}`
572			`} /* ata_mwdma() */`
573
574
575			`/---------------------------------------------------------------------------/`
576			`/*!Set the ATA programmed I/O mode`
577
578			`Must be 0, 1, 2, 3 or 4.`
579
580			`@param[in] val The value to use`
581			`@param[in] dat The config data structure */`
582			`/---------------------------------------------------------------------------/`
583			`static void`
584			`ata_pio (union param_val val,`
585			`void *dat)`
586			`{`
587			`struct ata_host *ata = dat;`
588
589			`if ((val.int_val >= 0) && (val.int_val <= 4))`
590			`{`
591			`ata->devices.device[conf_dev].conf.pio = val.int_val;`
592			`}`
593			`else`
594			`{`
595			`fprintf (stderr, "Warning: invalid ATA programmed I/O mode: ignored\n");`
596			`}`
597			`} /* ata_pio() */`
598
599
600			`static void`
601			`ata_start_device (union param_val val, void *dat)`
602			`{`
603			`conf_dev = val.int_val;`
604
605			`if (conf_dev > 1)`
606			`fprintf (stderr, "Device %d out-of-range\n", conf_dev);`
607			`}`
608
609			`static void`
610			`ata_enddevice (union param_val val, void *dat)`
611			`{`
612			`conf_dev = 2;`
613			`}`
614
615			`/---------------------------------------------------------------------------/`
616			`/*!Initialize a new ATA configuration`
617
618			`ALL parameters are set explicitly to default values. */`
619			`/---------------------------------------------------------------------------/`
620			`static void *`
621			`ata_sec_start (void)`
622			`{`
623			`struct ata_host *new = malloc (sizeof (struct ata_host));`
624
625			`if (!new)`
626			`{`
627			`fprintf (stderr, "Peripheral ATA: Run out of memory\n");`
628			`exit (-1);`
629			`}`
630
631			`memset (new, 0, sizeof (struct ata_host));`
632
633			`new->enabled = 1;`
634			`new->baseaddr = 0;`
635			`new->irq = 0;`
636			`new->dev_id = 1;`
637			`new->rev = 0;`
638
639			`new->pio_mode0_t1 = PIO_MODE0_T1;`
640			`new->pio_mode0_t2 = PIO_MODE0_T2;`
641			`new->pio_mode0_t4 = PIO_MODE0_T4;`
642			`new->pio_mode0_teoc = PIO_MODE0_TEOC;`
643
644			`new->dma_mode0_tm = DMA_MODE0_TM;`
645			`new->dma_mode0_td = DMA_MODE0_TD;`
646			`new->dma_mode0_teoc = DMA_MODE0_TEOC;`
647
648			`new->devices.device[0].conf.type = 0;`
649			`new->devices.device[0].conf.file = strdup ("ata_file0");`
650			`new->devices.device[0].conf.size = 0;`
651			`new->devices.device[0].conf.packet = 0;`
652			`new->devices.device[0].conf.heads = 7;`
653			`new->devices.device[0].conf.sectors = 32;`
654			`new->devices.device[0].conf.firmware = "02207031";`
655			`new->devices.device[0].conf.mwdma = 2;`
656			`new->devices.device[0].conf.pio = 4;`
657
658			`new->devices.device[1].conf.type = 0;`
659			`new->devices.device[1].conf.file = strdup ("ata_file1");`
660			`new->devices.device[1].conf.size = 0;`
661			`new->devices.device[1].conf.packet = 0;`
662			`new->devices.device[1].conf.heads = 7;`
663			`new->devices.device[1].conf.sectors = 32;`
664			`new->devices.device[1].conf.firmware = "02207031";`
665			`new->devices.device[1].conf.mwdma = 2;`
666			`new->devices.device[1].conf.pio = 4;`
667
668			`return new;`
669
670			`} /* ata_sec_start() */`
671
672
673			`static void`
674			`ata_sec_end (void *dat)`
675			`{`
676			`struct ata_host *ata = dat;`
677			`struct mem_ops ops;`
678
679			`if (!ata->enabled)`
680			`{`
681			`free (dat);`
682			`return;`
683			`}`
684
685			`/* Connect ata_devices. */`
686			`ata_devices_init (&ata->devices);`
687			`ata->devices.device[0].internals.host = ata;`
688			`ata->devices.device[1].internals.host = ata;`
689
690			`memset (&ops, 0, sizeof (struct mem_ops));`
691
692			`ops.readfunc32 = ata_read32;`
693			`ops.read_dat32 = dat;`
694			`ops.writefunc32 = ata_write32;`
695			`ops.write_dat32 = dat;`
696
697			`/* Delays will be readjusted later */`
698			`ops.delayr = 2;`
699			`ops.delayw = 2;`
700
701			`ata->mem = reg_mem_area (ata->baseaddr, ATA_ADDR_SPACE, 0, &ops);`
702
703			`reg_sim_reset (ata_reset, dat);`
704			`reg_sim_stat (ata_status, dat);`
705			`}`
706
707			`void`
708			`reg_ata_sec ()`
709			`{`
710			`struct config_section *sec =`
711			`reg_config_sec ("ata", ata_sec_start, ata_sec_end);`
712
713			`reg_config_param (sec, "enabled", paramt_int, ata_enabled);`
714			`reg_config_param (sec, "baseaddr", paramt_addr, ata_baseaddr);`
715			`reg_config_param (sec, "irq", paramt_int, ata_irq);`
716			`reg_config_param (sec, "dev_id", paramt_int, ata_dev_id);`
717			`reg_config_param (sec, "rev", paramt_int, ata_rev);`
718
719			`reg_config_param (sec, "pio_mode0_t1", paramt_int, ata_pio_mode0_t1);`
720			`reg_config_param (sec, "pio_mode0_t2", paramt_int, ata_pio_mode0_t2);`
721			`reg_config_param (sec, "pio_mode0_t4", paramt_int, ata_pio_mode0_t4);`
722			`reg_config_param (sec, "pio_mode0_teoc", paramt_int, ata_pio_mode0_teoc);`
723
724			`reg_config_param (sec, "dma_mode0_tm", paramt_int, ata_dma_mode0_tm);`
725			`reg_config_param (sec, "dma_mode0_td", paramt_int, ata_dma_mode0_td);`
726			`reg_config_param (sec, "dma_mode0_teoc", paramt_int, ata_dma_mode0_teoc);`
727
728			`reg_config_param (sec, "device", paramt_int, ata_start_device);`
729			`reg_config_param (sec, "enddevice", paramt_int, ata_enddevice);`
730
731			`reg_config_param (sec, "type", paramt_int, ata_type);`
732			`reg_config_param (sec, "file", paramt_str, ata_file);`
733			`reg_config_param (sec, "size", paramt_int, ata_size);`
734			`reg_config_param (sec, "packet", paramt_int, ata_packet);`
735			`reg_config_param (sec, "heads", paramt_int, ata_heads);`
736			`reg_config_param (sec, "sectors", paramt_int, ata_sectors);`
737			`reg_config_param (sec, "firmware", paramt_str, ata_firmware);`
738			`reg_config_param (sec, "mwdma", paramt_int, ata_mwdma);`
739			`reg_config_param (sec, "pio", paramt_int, ata_pio);`
740			`}`