1 /*****************************************************************************

     2  *

     3  * $Id$

     4  *

     5  ****************************************************************************/

     6 

     7 #include <iostream>

     8 #include <iomanip>

     9 using namespace std;

    10 

    11 #include "globals.h"

    12 

    13 /*****************************************************************************/

    14 

    15 const char *help_domains =

    16     "[OPTIONS]\n"

    17     "\n"

    18     "Show information about the application's configured domains.\n"

    19     "\n"

    20     "Without the --verbose option, the domains are displayed one-per-line.\n"

    21     "Example:\n"

    22     "\n"

    23     "Domain0: LogBaseAddr 0x00000000, Size   6, WorkingCounter 0/1\n"

    24     "\n"

    25     "The domain's base address for the logical datagram (LRD/LWR/LRW)\n"

    26     "is displayed followed by the domain's process data size in byte.\n"

    27     "The last values are the current datagram working counter sum and\n"

    28     "the expected working counter sum. If the values are equal, all\n"

    29     "Pdos are exchanged.\n"

    30     "\n"

    31     "If the --verbose option is given, the participating slave\n"

    32     "configurations/FMMUs and the current process data are additionally\n"

    33     "displayed:\n"

    34     "\n"

    35     "Domain1: LogBaseAddr 0x00000006, Size   6, WorkingCounter 0/1\n"

    36     "  SlaveConfig 1001:0, SM3 ( Input), LogAddr 0x00000006, Size 6\n"

    37     "    00 00 00 00 00 00\n"

    38     "\n"

    39     "The process data are displayed as hexadecimal bytes.\n"

    40     "\n"

    41     "Command-specific options:\n"

    42     "  --domain   -d <index> Positive numerical domain index, or 'all'\n"

    43     "                        for all domains (default).\n"

    44     "  --verbose  -v         Show FMMUs and process data additionally.\n"

    45     "\n"

    46     "Numerical values can be specified either with decimal (no prefix),\n"

    47     "octal (prefix '0') or hexadecimal (prefix '0x') base.\n";

    48 

    49 /****************************************************************************/

    50 

    51 void showDomain(unsigned int);

    52 

    53 /****************************************************************************/

    54 

    55 void command_domains(void)

    56 {

    57     masterDev.open(MasterDevice::Read);

    58 

    59     if (domainIndex == -1) {

    60         unsigned int i;

    61         ec_ioctl_master_t master;

    62 

    63         masterDev.getMaster(&master);

    64 

    65         for (i = 0; i < master.domain_count; i++) {

    66             showDomain(i);

    67         }

    68     } else {

    69         showDomain(domainIndex);

    70     }

    71 }

    72 

    73 /****************************************************************************/

    74 

    75 void showDomain(unsigned int domainIndex)

    76 {

    77     ec_ioctl_domain_t domain;

    78     unsigned char *processData;

    79     ec_ioctl_domain_data_t data;

    80     unsigned int i, j;

    81     ec_ioctl_domain_fmmu_t fmmu;

    82     unsigned int dataOffset;

    83     

    84     masterDev.getDomain(&domain, domainIndex);

    85 

    86 	cout << "Domain" << dec << domainIndex << ":"

    87 		<< " LogBaseAddr 0x"

    88 		<< hex << setfill('0')

    89         << setw(8) << domain.logical_base_address

    90 		<< ", Size " << dec << setfill(' ')

    91         << setw(3) << domain.data_size

    92 		<< ", WorkingCounter "

    93 		<< domain.working_counter << "/"

    94         << domain.expected_working_counter << endl;

    95 

    96     if (!domain.data_size || verbosity != Verbose)

    97         return;

    98 

    99     processData = new unsigned char[domain.data_size];

   100 

   101     try {

   102         masterDev.getData(&data, domainIndex, domain.data_size, processData);

   103     } catch (MasterDeviceException &e) {

   104         delete [] processData;

   105         throw e;

   106     }

   107 

   108     for (i = 0; i < domain.fmmu_count; i++) {

   109         masterDev.getFmmu(&fmmu, domainIndex, i);

   110 

   111         cout << "  SlaveConfig "

   112             << dec << fmmu.slave_config_alias

   113             << ":" << fmmu.slave_config_position

   114             << ", SM" << (unsigned int) fmmu.sync_index << " ("

   115             << setfill(' ') << setw(6)

   116             << (fmmu.dir == EC_DIR_INPUT ? "Input" : "Output")

   117             << "), LogAddr 0x"

   118             << hex << setfill('0')

   119             << setw(8) << fmmu.logical_address

   120             << ", Size " << dec << fmmu.data_size << endl;

   121 

   122         dataOffset = fmmu.logical_address - domain.logical_base_address;

   123         if (dataOffset + fmmu.data_size > domain.data_size) {

   124             stringstream err;

   125             delete [] processData;

   126             err << "Fmmu information corrupted!";

   127             throw CommandException(err);

   128         }

   129 

   130         cout << "    " << hex << setfill('0');

   131         for (j = 0; j < fmmu.data_size; j++) {

   132             if (j && !(j % BreakAfterBytes))

   133                 cout << endl << "    ";

   134             cout << setw(2)

   135                 << (unsigned int) *(processData + dataOffset + j) << " ";

   136         }

   137         cout << endl;

   138     }

   139 

   140     delete [] processData;

   141 }

   142 

   143 /*****************************************************************************/