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

/*****************************************************************************/