1

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

     2

 *

     3

 *  m a i l b o x . c

     4

 *

     5

 *  Mailbox functionality.

     6

 *

     7

 *  $Id$

     8

 *

     9

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

    10

    11

#include <linux/slab.h>

    12

#include <linux/delay.h>

    13

    14

#include "mailbox.h"

    15

#include "command.h"

    16

#include "master.h"

    17

    18

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

    19

    20

/**

    21

   Prepares a mailbox-send command.

    22

   \return pointer to mailbox command data

    23

*/

    24

    25

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

    26

                                    uint8_t type, /**< mailbox protocol */

    27

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

    28

                                    )

    29

{

    30

    ec_command_t *command = &slave->mbox_command;

    31

    size_t total_size;

    32

    33

    if (unlikely(!slave->sii_mailbox_protocols)) {

    34

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

    35

               slave->ring_position);

    36

        return NULL;

    37

    }

    38

    39

    total_size = size + 6;

    40

    if (unlikely(total_size > slave->sii_rx_mailbox_size)) {

    41

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

    42

        return NULL;

    43

    }

    44

    45

    if (ec_command_npwr(command, slave->station_address,

    46

                        slave->sii_rx_mailbox_offset,

    47

                        slave->sii_rx_mailbox_size))

    48

        return NULL;

    49

    50

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

    51

    EC_WRITE_U16(command->data + 2, slave->station_address); // station address

    52

    EC_WRITE_U8 (command->data + 4, 0x00); // hhannel & priority

    53

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

    54

    55

    return command->data + 6;

    56

}

    57

    58

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

    59

    60

/**

    61

   Prepares a command for checking the mailbox state.

    62

   \return 0 in case of success, else < 0

    63

*/

    64

    65

int ec_slave_mbox_prepare_check(ec_slave_t *slave /**< slave */)

    66

{

    67

    ec_command_t *command = &slave->mbox_command;

    68

    69

    // FIXME: second sync manager?

    70

    if (ec_command_nprd(command, slave->station_address, 0x808, 8))

    71

        return -1;

    72

    73

    return 0;

    74

}

    75

    76

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

    77

    78

/**

    79

   Processes a mailbox state checking command.

    80

   \return 0 in case of success, else < 0

    81

*/

    82

    83

int ec_slave_mbox_check(const ec_slave_t *slave /**< slave */)

    84

{

    85

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

    86

}

    87

    88

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

    89

    90

/**

    91

   Prepares a command to fetch mailbox data.

    92

   \return 0 in case of success, else < 0

    93

*/

    94

    95

int ec_slave_mbox_prepare_fetch(ec_slave_t *slave /**< slave */)

    96

{

    97

    ec_command_t *command = &slave->mbox_command;

    98

    99

    if (ec_command_nprd(command, slave->station_address,

   100

                        slave->sii_tx_mailbox_offset,

   101

                        slave->sii_tx_mailbox_size)) return -1;

   102

    return 0;

   103

}

   104

   105

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

   106

   107

/**

   108

   Processes received mailbox data.

   109

   \return pointer to the received data

   110

*/

   111

   112

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

   113

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

   114

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

   115

                             )

   116

{

   117

    ec_command_t *command = &slave->mbox_command;

   118

    size_t data_size;

   119

   120

    if ((EC_READ_U8(command->data + 5) & 0x0F) != type) {

   121

        EC_ERR("Unexpected mailbox protocol 0x%02X (exp.: 0x%02X) at"

   122

               " slave %i!\n", EC_READ_U8(command->data + 5), type,

   123

               slave->ring_position);

   124

        return NULL;

   125

    }

   126

   127

    if ((data_size = EC_READ_U16(command->data)) >

   128

        slave->sii_tx_mailbox_size - 6) {

   129

        EC_ERR("Currupt mailbox response detected!\n");

   130

        return NULL;

   131

    }

   132

   133

    *size = data_size;

   134

    return command->data + 6;

   135

}

   136

   137

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

   138

   139

/**

   140

   Sends a mailbox command and waits for its reception.

   141

   \return pointer to the received data

   142

*/

   143

   144

uint8_t *ec_slave_mbox_simple_io(ec_slave_t *slave, /**< slave */

   145

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

   146

                                 )

   147

{

   148

    uint8_t type;

   149

    ec_command_t *command;

   150

   151

    command = &slave->mbox_command;

   152

    type = EC_READ_U8(command->data + 5);

   153

   154

    if (unlikely(ec_master_simple_io(slave->master, command))) {

   155

        EC_ERR("Mailbox checking failed on slave %i!\n",

   156

               slave->ring_position);

   157

        return NULL;

   158

    }

   159

   160

    return ec_slave_mbox_simple_receive(slave, type, size);

   161

}

   162

   163

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

   164

   165

/**

   166

   Waits for the reception of a mailbox command.

   167

   \return pointer to the received data

   168

*/

   169

   170

uint8_t *ec_slave_mbox_simple_receive(ec_slave_t *slave, /**< slave */

   171

                                      uint8_t type, /**< expected protocol */

   172

                                      size_t *size /**< received data size */

   173

                                      )

   174

{

   175

    cycles_t start, end, timeout;

   176

    ec_command_t *command;

   177

   178

    command = &slave->mbox_command;

   179

    start = get_cycles();

   180

    timeout = (cycles_t) 100 * cpu_khz; // 100ms

   181

   182

    while (1)

   183

    {

   184

        if (ec_slave_mbox_prepare_check(slave)) return NULL;

   185

        if (unlikely(ec_master_simple_io(slave->master, command))) {

   186

            EC_ERR("Mailbox checking failed on slave %i!\n",

   187

                   slave->ring_position);

   188

            return NULL;

   189

        }

   190

   191

        end = get_cycles();

   192

   193

        if (ec_slave_mbox_check(slave))

   194

            break; // proceed with receiving data

   195

   196

        if ((end - start) >= timeout) {

   197

            EC_ERR("Mailbox check - Slave %i timed out.\n",

   198

                   slave->ring_position);

   199

            return NULL;

   200

        }

   201

   202

        udelay(100);

   203

    }

   204

   205

    if (ec_slave_mbox_prepare_fetch(slave)) return NULL;

   206

    if (unlikely(ec_master_simple_io(slave->master, command))) {

   207

        EC_ERR("Mailbox receiving failed on slave %i!\n",

   208

               slave->ring_position);

   209

        return NULL;

   210

    }

   211

   212

    if (unlikely(slave->master->debug_level) > 1)

   213

        EC_DBG("Mailbox receive took %ius.\n", ((u32) (end - start) * 1000

   214

                                                / cpu_khz));

   215

   216

    return ec_slave_mbox_fetch(slave, type, size);

   217

}

   218

   219

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