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

// FIXME

    16

const char *help_sii_read =

    17

    "[OPTIONS]\n"

    18

    "\n"

    19

    "\n"

    20

    "Command-specific options:\n";

    21

    22

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

    23

    24

struct CategoryName {

    25

    uint16_t type;

    26

    const char *name;

    27

};

    28

    29

static const CategoryName categoryNames[] = {

    30

    {0x000a, "STRINGS"},

    31

    {0x0014, "DataTypes"},

    32

    {0x001e, "General"},

    33

    {0x0028, "FMMU"},

    34

    {0x0029, "SyncM"},

    35

    {0x0032, "TXPDO"},

    36

    {0x0033, "RXPDO"},

    37

    {0x003c, "DC"},

    38

    {}

    39

};

    40

    41

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

    42

    43

const char *getCategoryName(uint16_t type)

    44

{

    45

    const CategoryName *cn = categoryNames;

    46

    47

    while (cn->type) {

    48

        if (cn->type == type) {

    49

            return cn->name;

    50

        }

    51

        cn++;

    52

    }

    53

    54

    return "unknown";

    55

}

    56

    57

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

    58

    59

void command_sii_read(void)

    60

{

    61

    ec_ioctl_slave_sii_t data;

    62

    ec_ioctl_slave_t slave;

    63

    unsigned int i;

    64

    const uint16_t *categoryHeader;

    65

    uint16_t categoryType, categorySize;

    66

    stringstream err;

    67

    68

    if (slavePosition < 0) {

    72

    }

    73

    data.slave_position = slavePosition;

    74

    75

    masterDev.open(MasterDevice::Read);

    76

    77

    masterDev.getSlave(&slave, slavePosition);

    78

    79

    if (!slave.sii_nwords)

    80

        return;

    81

    82

    data.offset = 0;

    83

    data.nwords = slave.sii_nwords;

    84

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

    85

    86

	try {

    87

		masterDev.readSii(&data);

    88

	} catch (MasterDeviceException &e) {

    89

        delete [] data.words;

    90

		throw e;

    91

	}

    92

    93

    if (verbosity == Verbose) {

    94

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

    95

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

    96

            if (i % BreakAfterBytes) {

    97

                cout << " ";

    98

            } else {

    99

                cout << endl << "  ";

   100

            }

   101

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

   102

        }

   103

        cout << endl;

   104

   105

        if (data.nwords > 0x0040U) {

   106

            // cycle through categories

   107

            categoryHeader = data.words + 0x0040U;

   108

            categoryType = le16tocpu(*categoryHeader);

   109

            while (categoryType != 0xffff) {

   110

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

   111

                    << setw(4) << categoryType

   112

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

   113

   114

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

   115

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

   117

                }

   118

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

   119

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

   120

   121

                if (categoryHeader + 2 + categorySize

   122

                        > data.words + data.nwords) {

   123

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

   125

                }

   126

   127

                cout << hex;

   128

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

   129

                    if (i % BreakAfterBytes) {

   130

                        cout << " ";

   131

                    } else {

   132

                        cout << endl << "  ";

   133

                    }

   134

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

   135

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

   136

                }

   137

                cout << endl;

   138

   139

                if (categoryHeader + 2 + categorySize + 1

   140

                        > data.words + data.nwords) {

   141

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

   143

                }

   144

                categoryHeader += 2 + categorySize;

   145

                categoryType = le16tocpu(*categoryHeader);

   146

            }

   147

        }

   148

    } else {

   149

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

   150

            uint16_t *w = data.words + i;

   151

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

   152

        }

   153

    }

   154

   155

    delete [] data.words;

   156

}

   157

   158

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