1

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

     2

 *

     3

 * $Id$

     4

 *

     5

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

     6

     7

#include <iostream>

     8

#include <iomanip>

     9

#include <fstream>

    10

using namespace std;

    11

    12

#include "CommandPhyWrite.h"

    13

#include "sii_crc.h"

    14

#include "byteorder.h"

    15

    16

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

    17

    18

CommandPhyWrite::CommandPhyWrite():

    19

    Command("phy_write", "Write data to a slave's physical memory.")

    20

{

    21

}

    22

    23

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

    24

    25

string CommandPhyWrite::helpString() const

    26

{

    27

    stringstream str;

    28

    29

    str << getName() << " [OPTIONS] <OFFSET> <FILENAME>" << endl

    30

        << endl 

    31

        << getBriefDescription() << endl

    32

        << endl

    33

        << "This command requires a single slave to be selected." << endl

    34

    	<< endl

    35

        << "Arguments:" << endl

    36

        << "  OFFSET   must be the physical memory offset to start." << endl

    37

        << "  FILENAME must be a path to a file with data to write." << endl

    38

        << "           If it is '-', data are read from stdin." << endl

    39

        << endl

    40

        << "Command-specific options:" << endl

    41

        << "  --alias    -a <alias>" << endl

    42

        << "  --position -p <pos>    Slave selection. See the help of" << endl

    43

        << "                         the 'slaves' command." << endl

    44

        << endl

    45

        << numericInfo();

    46

    47

    return str.str();

    48

}

    49

    50

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

    51

    52

void CommandPhyWrite::execute(MasterDevice &m, const StringVector &args)

    53

{

    54

    stringstream strOffset, err;

    55

    ec_ioctl_slave_phy_t data;

    56

    ifstream file;

    57

    SlaveList slaves;

    58

    59

    if (args.size() != 2) {

    60

        err << "'" << getName() << "' takes exactly one argument!";

    61

        throwInvalidUsageException(err);

    62

    }

    63

    64

    strOffset << args[0];

    65

    strOffset

    66

        >> resetiosflags(ios::basefield) // guess base from prefix

    67

        >> data.offset;

    68

    if (strOffset.fail()) {

    69

        err << "Invalid offset '" << args[0] << "'!";

    70

        throwInvalidUsageException(err);

    71

    }

    72

    73

    if (args[1] == "-") {

    74

        loadPhyData(&data, cin);

    75

    } else {

    76

        file.open(args[1].c_str(), ifstream::in | ifstream::binary);

    77

        if (file.fail()) {

    78

            err << "Failed to open '" << args[0] << "'!";

    79

            throwCommandException(err);

    80

        }

    81

        loadPhyData(&data, file);

    82

        file.close();

    83

    }

    84

    85

    if ((uint32_t) data.offset + data.length > 0xffff) {

    86

        err << "Offset and length exceeding 64k!";

    87

        delete [] data.data;

    88

        throwInvalidUsageException(err);

    89

    }

    90

    91

    try {

    92

        m.open(MasterDevice::ReadWrite);

    93

    } catch (MasterDeviceException &e) {

    94

        delete [] data.data;

    95

        throw e;

    96

    }

    97

    98

    slaves = selectedSlaves(m);

    99

    if (slaves.size() != 1) {

   100

        delete [] data.data;

   101

        throwSingleSlaveRequired(slaves.size());

   102

    }

   103

    data.slave_position = slaves.front().position;

   104

   105

    // send data to master

   106

    try {

   107

        m.writePhy(&data);

   108

    } catch (MasterDeviceException &e) {

   109

        delete [] data.data;

   110

        throw e;

   111

    }

   112

   113

    if (getVerbosity() == Verbose) {

   114

        cerr << "Physical memory writing finished." << endl;

   115

    }

   116

   117

    delete [] data.data;

   118

}

   119

   120

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

   121

   122

void CommandPhyWrite::loadPhyData(

   123

        ec_ioctl_slave_phy_t *data,

   124

        const istream &in

   125

        )

   126

{

   127

    stringstream err;

   128

    ostringstream tmp;

   129

   130

    tmp << in.rdbuf();

   131

    string const &contents = tmp.str();

   132

   133

    if (getVerbosity() == Verbose) {

   134

        cerr << "Read " << contents.size() << " bytes of data." << endl;

   135

    }

   136

   137

    if (contents.size() > 0xffff) {

   138

        err << "Invalid data size " << contents.size() << "!";

   139

        throwInvalidUsageException(err);

   140

    }

   141

    data->length = contents.size();

   142

   143

    // allocate buffer and read file into buffer

   144

    data->data = new uint8_t[data->length];

   145

    contents.copy((char *) data->data, contents.size());

   146

}

   147

   148

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