1

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

     2

 *

     3

 *  $Id$

     4

 *

     5

 *  Copyright (C) 2006-2008  Florian Pose, Ingenieurgemeinschaft IgH

     6

 *

     7

 *  This file is part of the IgH EtherCAT Master.

     8

 *

     9

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

    10

 *  modify it under the terms of the GNU General Public License version 2, as

    11

 *  published by the Free Software Foundation.

    12

 *

    13

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

    14

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

    15

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General

    16

 *  Public License for more details.

    17

 *

    18

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

    19

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

    20

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

    21

 *

    22

 *  Using the EtherCAT technology and brand is permitted in compliance with

    23

 *  the industrial property and similar rights of Beckhoff Automation GmbH.

    24

 *

    25

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

    26

    27

/**

    28

   \file

    29

   Mailbox functionality.

    30

*/

    31

    32

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

    33

    34

#include <linux/slab.h>

    35

#include <linux/delay.h>

    36

    37

#include "mailbox.h"

    38

#include "datagram.h"

    39

#include "master.h"

    40

    41

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

    42

    43

/**

    44

   Prepares a mailbox-send datagram.

    45

   \return pointer to mailbox datagram data

    46

*/

    47

    48

uint8_t *ec_slave_mbox_prepare_send(const ec_slave_t *slave, /**< slave */

    49

                                    ec_datagram_t *datagram, /**< datagram */

    50

                                    uint8_t type, /**< mailbox protocol */

    51

                                    size_t size /**< size of the data */

    52

                                    )

    53

{

    54

    size_t total_size;

    55

    uint16_t mailbox_offset, mailbox_size;

    56

    57

    if (unlikely(!slave->sii.mailbox_protocols)) {

    58

        EC_ERR("Slave %u does not support mailbox communication!\n",

    59

               slave->ring_position);

    60

        return NULL;

    61

    }

    62

    63

    total_size = size + 6;

    64

    65

    if (slave->current_state != EC_SLAVE_STATE_BOOT) {

    66

        mailbox_offset = slave->sii.std_rx_mailbox_offset;

    67

        mailbox_size = slave->sii.std_rx_mailbox_size;

    68

    } else {

    69

        mailbox_offset = slave->sii.boot_rx_mailbox_offset;

    70

        mailbox_size = slave->sii.boot_rx_mailbox_size;

    71

    }

    72

    73

    if (unlikely(total_size > mailbox_size)) {

    74

        EC_ERR("Data size does not fit in mailbox!\n");

    75

        return NULL;

    76

    }

    77

    78

    if (ec_datagram_fpwr(datagram, slave->station_address,

    79

                         mailbox_offset, mailbox_size))

    80

        return NULL;

    81

    82

    EC_WRITE_U16(datagram->data,     size); // mailbox service data length

    83

    EC_WRITE_U16(datagram->data + 2, slave->station_address); // station addr.

    84

    EC_WRITE_U8 (datagram->data + 4, 0x00); // channel & priority

    85

    EC_WRITE_U8 (datagram->data + 5, type); // underlying protocol type

    86

    87

    return datagram->data + 6;

    88

}

    89

    90

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

    91

    92

/**

    93

   Prepares a datagram for checking the mailbox state.

    94

   \todo Determine sync manager used for receive mailbox

    95

   \return 0 in case of success, else < 0

    96

*/

    97

    98

int ec_slave_mbox_prepare_check(const ec_slave_t *slave, /**< slave */

    99

                                ec_datagram_t *datagram /**< datagram */

   100

                                )

   101

{

   102

    if (ec_datagram_fprd(datagram, slave->station_address, 0x808, 8))

   103

        return -1;

   104

   105

    return 0;

   106

}

   107

   108

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

   109

   110

/**

   111

   Processes a mailbox state checking datagram.

   112

   \return 0 in case of success, else < 0

   113

*/

   114

   115

int ec_slave_mbox_check(const ec_datagram_t *datagram /**< datagram */)

   116

{

   117

    return EC_READ_U8(datagram->data + 5) & 8 ? 1 : 0;

   118

}

   119

   120

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

   121

   122

/**

   123

   Prepares a datagram to fetch mailbox data.

   124

   \return 0 in case of success, else < 0

   125

*/

   126

   127

int ec_slave_mbox_prepare_fetch(const ec_slave_t *slave, /**< slave */

   128

                                ec_datagram_t *datagram /**< datagram */

   129

                                )

   130

{

   131

    uint16_t mailbox_offset, mailbox_size;

   132

   133

    if (slave->current_state != EC_SLAVE_STATE_BOOT) {

   134

        mailbox_offset = slave->sii.std_tx_mailbox_offset;

   135

        mailbox_size = slave->sii.std_tx_mailbox_size;

   136

    } else {

   137

        mailbox_offset = slave->sii.boot_tx_mailbox_offset;

   138

        mailbox_size = slave->sii.boot_tx_mailbox_size;

   139

    }

   140

   141

    if (ec_datagram_fprd(datagram, slave->station_address,

   142

                         mailbox_offset, mailbox_size))

   143

        return -1;

   144

   145

    return 0;

   146

}

   147

   148

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

   149

   150

/**

   151

   Mailbox error codes.

   152

*/

   153

   154

const ec_code_msg_t mbox_error_messages[] = {

   155

    {0x00000001, "MBXERR_SYNTAX"},

   156

    {0x00000002, "MBXERR_UNSUPPORTEDPROTOCOL"},

   157

    {0x00000003, "MBXERR_INVAILDCHANNEL"},

   158

    {0x00000004, "MBXERR_SERVICENOTSUPPORTED"},

   159

    {0x00000005, "MBXERR_INVALIDHEADER"},

   160

    {0x00000006, "MBXERR_SIZETOOSHORT"},

   161

    {0x00000007, "MBXERR_NOMOREMEMORY"},

   162

    {0x00000008, "MBXERR_INVALIDSIZE"},

   163

    {}

   164

};

   165

   166

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

   167

   168

/**

   169

   Processes received mailbox data.

   170

   \return pointer to the received data

   171

*/

   172

   173

uint8_t *ec_slave_mbox_fetch(const ec_slave_t *slave, /**< slave */

   174

                             ec_datagram_t *datagram, /**< datagram */

   175

                             uint8_t *type, /**< expected mailbox protocol */

   176

                             size_t *size /**< size of the received data */

   177

                             )

   178

{

   179

    size_t data_size;

   180

    uint16_t mailbox_offset, mailbox_size;

   181

   182

    if (slave->current_state != EC_SLAVE_STATE_BOOT) {

   183

        mailbox_offset = slave->sii.std_tx_mailbox_offset;

   184

        mailbox_size = slave->sii.std_tx_mailbox_size;

   185

    } else {

   186

        mailbox_offset = slave->sii.boot_tx_mailbox_offset;

   187

        mailbox_size = slave->sii.boot_tx_mailbox_size;

   188

    }

   189

   190

    data_size = EC_READ_U16(datagram->data);

   191

   192

    if (data_size > mailbox_size - 6) {

   193

        EC_ERR("Corrupt mailbox response received from slave %u!\n",

   194

               slave->ring_position);

   195

        ec_print_data(datagram->data, mailbox_size);

   196

        return NULL;

   197

    }

   198

   199

    *type = EC_READ_U8(datagram->data + 5) & 0x0F;

   200

    *size = data_size;

   201

   202

    if (*type == 0x00) {

   203

        const ec_code_msg_t *mbox_msg;

   204

        uint16_t code = EC_READ_U16(datagram->data + 8);

   205

   206

        EC_ERR("Mailbox error response received from slave %u - ",

   207

                slave->ring_position);

   208

   209

        for (mbox_msg = mbox_error_messages; mbox_msg->code; mbox_msg++) {

   210

            if (mbox_msg->code != code)

   211

                continue;

   212

            printk("Code 0x%04X: \"%s\".\n",

   213

                    mbox_msg->code, mbox_msg->message);

   214

            break;

   215

        }

   216

   217

        if (!mbox_msg->code)

   218

            printk("Unknown error reply code 0x%04X.\n", code);

   219

   220

        if (slave->master->debug_level)

   221

            ec_print_data(datagram->data + 6, data_size);

   222

   223

        return NULL;

   224

    }

   225

   226

    return datagram->data + 6;

   227

}

   228

   229

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