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_sii_read =

    16     "[OPTIONS]\n"

    17     "\n"

    18     "\n"

    19     "Command-specific options:\n";

    20 

    21 /****************************************************************************/

    22 

    23 struct CategoryName {

    24     uint16_t type;

    25     const char *name;

    26 };

    27 

    28 static const CategoryName categoryNames[] = {

    29     {0x000a, "STRINGS"},

    30     {0x0014, "DataTypes"},

    31     {0x001e, "General"},

    32     {0x0028, "FMMU"},

    33     {0x0029, "SyncM"},

    34     {0x0032, "TXPDO"},

    35     {0x0033, "RXPDO"},

    36     {0x003c, "DC"},

    37     {}

    38 };

    39 

    40 /****************************************************************************/

    41 

    42 const char *getCategoryName(uint16_t type)

    43 {

    44     const CategoryName *cn = categoryNames;

    45 

    46     while (cn->type) {

    47         if (cn->type == type) {

    48             return cn->name;

    49         }

    50         cn++;

    51     }

    52 

    53     return "unknown";

    54 }

    55 

    56 /****************************************************************************/

    57 

    58 void command_sii_read(void)

    59 {

    60     ec_ioctl_slave_sii_t data;

    61     ec_ioctl_slave_t slave;

    62     unsigned int i;

    63     const uint16_t *categoryHeader;

    64     uint16_t categoryType, categorySize;

    65     stringstream err;

    66 

    67     if (slavePosition < 0) {

    68         stringstream err;

    69         err << "'sii_read' requires a slave! Please specify --slave.";

    70         throw MasterDeviceException(err.str());

    71     }

    72     data.slave_position = slavePosition;

    73 

    74     masterDev.open(MasterDevice::Read);

    75 

    76     masterDev.getSlave(&slave, slavePosition);

    77 

    78     if (!slave.sii_nwords)

    79         return;

    80 

    81     data.offset = 0;

    82     data.nwords = slave.sii_nwords;

    83     data.words = new uint16_t[data.nwords];

    84 

    85 	try {

    86 		masterDev.readSii(&data);

    87 	} catch (MasterDeviceException &e) {

    88         delete [] data.words;

    89 		throw e;

    90 	}

    91 

    92     if (verbosity == Verbose) {

    93         cout << "SII Area:" << hex << setfill('0');

    94         for (i = 0; i < min(data.nwords, 0x0040U) * 2; i++) {

    95             if (i % BreakAfterBytes) {

    96                 cout << " ";

    97             } else {

    98                 cout << endl << "  ";

    99             }

   100             cout << setw(2) << (unsigned int) *((uint8_t *) data.words + i);

   101         }

   102         cout << endl;

   103 

   104         if (data.nwords > 0x0040U) {

   105             // cycle through categories

   106             categoryHeader = data.words + 0x0040U;

   107             categoryType = le16tocpu(*categoryHeader);

   108             while (categoryType != 0xffff) {

   109                 cout << "SII Category 0x" << hex

   110                     << setw(4) << categoryType

   111                     << " (" << getCategoryName(categoryType) << ")" << flush;

   112 

   113                 if (categoryHeader + 1 > data.words + data.nwords) {

   114                     err << "SII data seem to be corrupted!";

   115                     throw MasterDeviceException(err.str());

   116                 }

   117                 categorySize = le16tocpu(*(categoryHeader + 1));

   118                 cout << ", " << dec << categorySize << " words" << flush;

   119 

   120                 if (categoryHeader + 2 + categorySize

   121                         > data.words + data.nwords) {

   122                     err << "SII data seem to be corrupted!";

   123                     throw MasterDeviceException(err.str());

   124                 }

   125 

   126                 cout << hex;

   127                 for (i = 0; i < categorySize * 2U; i++) {

   128                     if (i % BreakAfterBytes) {

   129                         cout << " ";

   130                     } else {

   131                         cout << endl << "  ";

   132                     }

   133                     cout << setw(2) << (unsigned int)

   134                         *((uint8_t *) (categoryHeader + 2) + i);

   135                 }

   136                 cout << endl;

   137 

   138                 if (categoryHeader + 2 + categorySize + 1

   139                         > data.words + data.nwords) {

   140                     err << "SII data seem to be corrupted!"; 

   141                     throw MasterDeviceException(err.str());

   142                 }

   143                 categoryHeader += 2 + categorySize;

   144                 categoryType = le16tocpu(*categoryHeader);

   145             }

   146         }

   147     } else {

   148         for (i = 0; i < data.nwords; i++) {

   149             uint16_t *w = data.words + i;

   150             cout << *(uint8_t *) w << *((uint8_t *) w + 1);

   151         }

   152     }

   153 

   154     delete [] data.words;

   155 }

   156 

   157 /*****************************************************************************/