/*
 * Filename:
 * 
 *   dmec.c
 *
 * Description:
 *
 *   C program to dump the MEC registers.
 *
 * ChangeLog:
 *
 *   $Log: dmec.c,v $
 *   Revision 1.1  1998/07/02 14:08:46  nettleto
 *   Initial revision
 *
 */


char *
tf (int b)
{
  if (b)
    return "true";
  else
    return "false";
}

int
dump_meccr (const unsigned long *mec_regs)
{
  unsigned long mcr = mec_regs [0];
  int v;

  printf ("---------------------------------------------------------------------------\n");
  printf ("MEC Control Register : %08x\n", mcr);
  printf ("---------------------------------------------------------------------------\n");

  v = (mcr >>  0) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "PRD", "Power Down", v,
    v? "Enabled (allowed)": "Disabled");

  v = (mcr >>  1) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "SWR", "Software Reset", v,
    v? "Enabled (allowed)": "Disabled");

  v = (mcr >>  2) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "BTO", "Bus Timeout", v,
    v? "Enabled": "Disabled");

  v = (mcr >>  3) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "BP", "Block protection", v,
    v? "Enabled": "Disabled");

  v = (mcr >>  4) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "WDCS", "Watchdog Clock Supply", v,
    v?
    "Ext + prescaler / 16": "External clock no prescaler");

  v = (mcr >>  5) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "IUEMMSK", "IU Error Mode Mask", v,
    v? "Error masked (=disabled)": "Error not masked");

  v = (mcr >>  6) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "RHIUEM", "Reset or Halt when IU Error Mode", v,
    v? "Reset": "Halt");

  v = (mcr >>  7) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "IUHEMSK", "IU Hardware Error Mask", v,
    v? "Error masked (=disabled)": "Error not masked");

  v = (mcr >>  8) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "RHIUHE", "Reset or Halt when IU Hardware Error", v,
    v? "Reset": "Halt");

  v = (mcr >>  9) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "IUCMPMSK", "IU Comparison Error Mask", v,
    v? "Error masked (=disabled)": "Error not masked");

  v = (mcr >> 10) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "RHIUCMP", "Reset or Halt when IU Hardware Error", v,
    v? "Reset": "Halt");

  v = (mcr >> 11) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "FPUCMPMASK", "FPU Comparison Error Mask", v,
    v? "Error masked (=disabled)": "Error not masked");

  v = (mcr >> 12) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "RHFPUCMP", "Reset or Halt when FPU Hardware Error", v,
    v? "Reset": "Halt");

  v = (mcr >> 13) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "MECHEMSK", "MEC Hardware Error Mask", v,
    v? "Error masked (=disabled)": "Error not masked");

  v = (mcr >> 14) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "RHMECHE", "Reset or Halt when MEC Hardware Error", v,
    v? "Reset": "Halt");

  v = (mcr >> 16) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "DMAE", "DMA Enable", v,
    v? "Enabled": "Disabled");

  v = (mcr >> 17) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "DPE", "DMA Parity Enable", v,
    v? "Enabled": "Disabled");

  v = (mcr >> 18) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "DST", "DMA Session Timeout", v,
    v? "Enabled": "Disabled");

  v = (mcr >> 19) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "UBR", "UART Baud Rate", v,
    v? "scaler rate": "scaler rate / 2");

  v = (mcr >> 20) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "UPE", "UART Parity Enable", v,
    v? "Enabled": "Disabled");

  v = (mcr >> 21) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "UP", "UART Parity", v,
    v? "Odd": "Even");

  v = (mcr >> 22) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "USB", "UART Stop Bits", v,
    v? "Two": "One");

  v = (mcr >> 23) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "UCS", "UART Clock Supply", v,
    v? "External": "System");

  v = (mcr >> 24) & 0x000000ff;
  printf (" %-10s %-38s: %d: %s\n", "Scaler", "UART Divide Factor", v,
    v? "": "UART stopped");

}

int
dump_mcr (const unsigned long *mec_regs)
{
  int v;
  unsigned long mcr = mec_regs [0x10 >> 2];
  const char *size [] = {
    "128K bytes",
    "256K bytes", "512K bytes", "1M bytes", "2M bytes",
    "4M bytes", "8M bytes", "16M bytes", "32M bytes"};

  const char *esize [] = {
    "4K bytes", "8K bytes", "16K bytes", "32K bytes",
    "64K bytes", "128K bytes", "256K bytes", "512K bytes"};

  printf ("---------------------------------------------------------------------------\n");
  printf ("Memory Configuration Register : %08x\n", mcr);
  printf ("---------------------------------------------------------------------------\n");

  v = (mcr >>  0) & 0x00000003;
  printf (" %-10s %-38s: %d: %s\n", "RBCS", "Number of RAM Blocks", v,
    "");

  v = (mcr >>  2) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "RBS0", "Redundant RAM Block 0 Selected", v,
    v? "Selected": "Not selected");

  v = (mcr >>  3) & 0x00000007;
  printf (" %-10s %-38s: %d: %s\n", "RBR0", "Redundant RAM Block 0", v,
    "");

  v = (mcr >>  6) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "RBS1", "Redundant RAM Block 1 Selected", v,
    v? "Selected": "Not selected");

  v = (mcr >>  7) & 0x00000007;
  printf (" %-10s %-38s: %d: %s\n", "RBR1", "Redundant RAM Block 1", v,
    "");

  v = (mcr >> 10) & 0x00000007;
  printf (" %-10s %-38s: %d: %s\n", "RSIZ", "RAM Size", v,
    size [v + 1]);

  v = (mcr >> 13) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "RPA", "RAM Memory Parity Protected", v,
    tf (v));

  v = (mcr >> 14) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "REC", "RAM EDAC Protected", v,
    tf (v));

  v = (mcr >> 16) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "PWR", "PROM Write Function", v,
    tf (v));

  v = (mcr >> 17) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "P8", "PROM 8-bit Wide", v,
    tf (v));

  v = (mcr >> 18) & 0x00000007;
  printf (" %-10s %-38s: %d: %s\n", "PSIZ", "PROM Size", v,
    size [v]);

  v = (mcr >> 24) & 0x00000007;
  printf (" %-10s %-38s: %d: %s\n", "ESIZ", "Exchange Memory Size", v,
    esize [v]);

  v = (mcr >> 27) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "EPA", "Exchange Memory Parity Protected", v,
    tf (v));

  v = (mcr >> 28) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "EEC", "Exchange Memory EDAC Protected", v,
    tf (v));

  v = (mcr >> 29) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "EEX", "Exchange Memory Exists", v,
    tf (v));

}

int
dump_iocr (const unsigned long *mec_regs)
{
  const unsigned long iocr = mec_regs [0x14 >> 2];
  int v;
  const char *size [] = {
    "512 bytes", "1K bytes", "2K bytes", "4K bytes",
    "8K bytes", "16K bytes", "32K bytes", "64K bytes",
    "128K bytes", "256K bytes", "512K bytes", "1M bytes",
    "2M bytes", "4M bytes", "8M bytes", "16M bytes"};

  printf ("---------------------------------------------------------------------------\n");
  printf ("Input/Output Configuration Register : %08x\n", iocr);
  printf ("---------------------------------------------------------------------------\n");

  v = (iocr >>  0) & 0x0000000f;
  printf (" %-10s %-38s: %d: %s\n", "SIZ0", "IO Unit 0 Size", v, size [v]);

  v = (iocr >>  4) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "IO0", "Parity Supplied by IO Unit 0", v, tf (v));

  v = (iocr >>  5) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "PA0", "IO Unit 0 Parity Protected", v, tf (v));

  v = (iocr >>  8) & 0x0000000f;
  printf (" %-10s %-38s: %d: %s\n", "SIZ1", "IO Unit 1 Size", v, size [v]);

  v = (iocr >> 12) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "IO1", "Parity Supplied by IO Unit 1", v, tf (v));

  v = (iocr >> 13) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "PA1", "IO Unit 1 Parity Protected", v, tf (v));

  v = (iocr >> 16) & 0x0000000f;
  printf (" %-10s %-38s: %d: %s\n", "SIZ2", "IO Unit 2 Size", v, size [v]);

  v = (iocr >> 20) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "IO2", "Parity Supplied by IO Unit 2", v, tf (v));

  v = (iocr >> 21) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "PA2", "IO Unit 2 Parity Protected", v, tf (v));

  v = (iocr >> 24) & 0x0000000f;
  printf (" %-10s %-38s: %d: %s\n", "SIZ3", "IO Unit 3 Size", v, size [v]);

  v = (iocr >> 28) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "IO3", "Parity Supplied by IO Unit 3", v, tf (v));

  v = (iocr >> 29) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "PA3", "IO Unit 3 Parity Protected", v, tf (v));

}

int
dump_apr (const unsigned long *mec_regs)
{
  const unsigned long base1 = mec_regs [0x20 >> 2];
  const unsigned long base2 = mec_regs [0x28 >> 2];
  const unsigned long end1 = mec_regs [0x24 >> 2];
  const unsigned long end2 = mec_regs [0x2c >> 2];
  int v;

  printf ("---------------------------------------------------------------------------\n");
  printf ("Access Protection Segment 1 Registers : %08x, %08x\n", base1, end1);
  printf ("---------------------------------------------------------------------------\n");

  v = (base1 >>  0) & 0x003fffff;
  printf (" %-10s %-38s: %d: 0x%08x\n", "SEGBASE", "Segment Start Address", v,
    0x02000000 + v * 4);

  v = (end1 >>  0) & 0x003fffff;
  printf (" %-10s %-38s: %d: 0x%08x\n", "SEGEND", "Segment End Address", v,
    0x02000000 + v * 4);

  v = (base1 >> 23) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "UE", "User Mode Enable", v,
    v? "Protection enabled": "Protection disabled");

  v = (base1 >> 24) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "SE", "Supervisor Mode Enable", v,
    v? "Protection enabled": "Protection disabled");

  printf ("---------------------------------------------------------------------------\n");
  printf ("Access Protection Segment 2 Registers : %08x, %08x\n", base2, end2);
  printf ("---------------------------------------------------------------------------\n");

  v = (base2 >>  0) & 0x003fffff;
  printf (" %-10s %-38s: %d: 0x%08x\n", "SEGBASE", "Segment Start Address", v,
    0x02000000 + v * 4);

  v = (end2 >>  0) & 0x003fffff;
  printf (" %-10s %-38s: %d: 0x%08x\n", "SEGEND", "Segment End Address", v,
    0x02000000 + v * 4);

  v = (base2 >> 23) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "UE", "User Mode Enable", v,
    v? "Access protection enabled": "Protection disabled");

  v = (base2 >> 24) & 0x00000001;
  printf (" %-10s %-38s: %d: %s\n", "SE", "Supervisor Mode Enable", v,
    v? "Access protection enabled": "Protection disabled");

}

int
main ()
{
  const unsigned long *mec_regs = (const unsigned long *)0x01f80000;

  dump_meccr (mec_regs);
  dump_mcr (mec_regs);
  dump_iocr (mec_regs);
  dump_apr (mec_regs);

  printf ("---------------------------------------------------------------------------\n");
}