1

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

     2

 *

     3

 *  e t h e r n e t . c

     4

 *

     5

 *  Ethernet-over-EtherCAT (EoE)

     6

 *

     7

 *  $Id$

     8

 *

     9

 *  Copyright (C) 2006  Florian Pose, Ingenieurgemeinschaft IgH

    10

 *

    11

 *  This file is part of the IgH EtherCAT Master.

    12

 *

    13

 *  The IgH EtherCAT Master is free software; you can redistribute it

    14

 *  and/or modify it under the terms of the GNU General Public License

    15

 *  as published by the Free Software Foundation; version 2 of the License.

    16

 *

    17

 *  The IgH EtherCAT Master is distributed in the hope that it will be

    18

 *  useful, but WITHOUT ANY WARRANTY; without even the implied warranty of

    19

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    20

 *  GNU General Public License for more details.

    21

 *

    22

 *  You should have received a copy of the GNU General Public License

    23

 *  along with the IgH EtherCAT Master; if not, write to the Free Software

    24

 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    25

 *

    26

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

    27

    28

#include "../include/ecrt.h"

    29

#include "globals.h"

    30

#include "master.h"

    31

#include "slave.h"

    32

#include "mailbox.h"

    33

#include "ethernet.h"

    34

    35

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

    36

    37

/**

    38

   \ingroup EoE

    39

*/

    40

    41

void ec_eoe_init(ec_eoe_t *eoe, ec_slave_t *slave)

    42

{

    43

    eoe->slave = slave;

    44

    eoe->rx_state = EC_EOE_IDLE;

    45

}

    46

    47

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

    48

    49

/**

    50

   \ingroup EoE

    51

*/

    52

    53

void ec_eoe_clear(ec_eoe_t *eoe)

    54

{

    55

}

    56

    57

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

    58

    59

/**

    60

   \ingroup EoE

    61

*/

    62

    63

void ec_eoe_run(ec_eoe_t *eoe)

    64

{

    65

    uint8_t *data;

    66

    ec_master_t *master;

    67

    size_t rec_size;

    68

#if 0

    69

    unsigned int i;

    70

    uint8_t fragment_number;

    71

    uint8_t complete_size;

    72

    uint8_t frame_number;

    73

    uint8_t last_fragment;

    74

#endif

    75

    76

    master = eoe->slave->master;

    77

    78

    if (eoe->rx_state == EC_EOE_IDLE) {

    79

        ec_slave_mbox_prepare_check(eoe->slave);

    80

        ec_master_queue_command(master, &eoe->slave->mbox_command);

    81

        eoe->rx_state = EC_EOE_CHECKING;

    82

        return;

    83

    }

    84

    85

    if (eoe->rx_state == EC_EOE_CHECKING) {

    86

        if (eoe->slave->mbox_command.state != EC_CMD_RECEIVED) {

    87

            master->stats.eoe_errors++;

    88

            eoe->rx_state = EC_EOE_IDLE;

    89

            return;

    90

        }

    91

        if (!ec_slave_mbox_check(eoe->slave)) {

    92

            eoe->rx_state = EC_EOE_IDLE;

    93

            return;

    94

        }

    95

        ec_slave_mbox_prepare_fetch(eoe->slave);

    96

        ec_master_queue_command(master, &eoe->slave->mbox_command);

    97

        eoe->rx_state = EC_EOE_FETCHING;

    98

        return;

    99

    }

   100

   101

    if (eoe->rx_state == EC_EOE_FETCHING) {

   102

        if (eoe->slave->mbox_command.state != EC_CMD_RECEIVED) {

   103

            master->stats.eoe_errors++;

   104

            eoe->rx_state = EC_EOE_IDLE;

   105

            return;

   106

        }

   107

        if (!(data = ec_slave_mbox_fetch(eoe->slave, 0x02, &rec_size))) {

   108

            master->stats.eoe_errors++;

   109

            eoe->rx_state = EC_EOE_IDLE;

   110

            return;

   111

        }

   112

   113

#if 0

   114

        fragment_number = EC_READ_U16(data + 2) & 0x003F;

   115

        complete_size = (EC_READ_U16(data + 2) >> 6) & 0x003F;

   116

        frame_number = (EC_READ_U16(data + 2) >> 12) & 0x0003;

   117

        last_fragment = (EC_READ_U16(data + 2) >> 15) & 0x0001;

   118

   119

        EC_DBG("EOE %s received, fragment: %i, complete size: %i (0x%02X),"

   120

               " frame %i%s\n",

   121

               fragment_number ? "fragment" : "initiate", fragment_number,

   122

               (complete_size - 31) / 32, complete_size, frame_number,

   123

               last_fragment ? ", last fragment" : "");

   124

        EC_DBG("");

   125

        for (i = 0; i < rec_size - 2; i++) {

   126

            printk("%02X ", data[i + 2]);

   127

            if ((i + 1) % 16 == 0) {

   128

                printk("\n");

   129

                EC_DBG("");

   130

            }

   131

        }

   132

        printk("\n");

   133

#endif

   134

   135

        eoe->rx_state = EC_EOE_IDLE;

   136

        return;

   137

    }

   138

}

   139

   140

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

   141

   142

/**

   143

   \ingroup EoE

   144

*/

   145

   146

void ec_eoe_print(const ec_eoe_t *eoe)

   147

{

   148

    EC_INFO("  EoE slave %i\n", eoe->slave->ring_position);

   149

    EC_INFO("    RX State %i\n", eoe->rx_state);

   150

}

   151

   152

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