1

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

     2

 *

     3

 *  m a i l b o x . c

     4

 *

     5

 *  Mailbox-Funktionen

     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

   Bereitet ein Mailbox-Send-Kommando vor.

    22

 */

    23

    24

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

    25

                                    uint8_t type, /**< Mailbox-Protokoll */

    26

                                    size_t size /**< Datengröße */

    27

                                    )

    28

{

    29

    ec_command_t *command = &slave->mbox_command;

    30

    size_t total_size;

    31

    32

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

    33

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

    34

               slave->ring_position);

    35

        return NULL;

    36

    }

    37

    38

    total_size = size + 6;

    39

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

    40

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

    41

        return NULL;

    42

    }

    43

    44

    if (ec_command_npwr(command, slave->station_address,

    45

                        slave->sii_rx_mailbox_offset,

    46

                        slave->sii_rx_mailbox_size))

    47

        return NULL;

    48

    49

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

    50

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

    51

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

    52

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

    53

    54

    return command->data + 6;

    55

}

    56

    57

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

    58

    59

/**

    60

   Bereitet ein Kommando zum Abfragen des Mailbox-Zustandes vor.

    61

 */

    62

    63

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

    64

{

    65

    ec_command_t *command = &slave->mbox_command;

    66

    67

    // FIXME: Zweiter Sync-Manager nicht immer TX-Mailbox?

    68

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

    69

        return -1;

    70

    71

    return 0;

    72

}

    73

    74

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

    75

    76

/**

    77

   Liest den Mailbox-Zustand aus einem empfangenen Kommando.

    78

 */

    79

    80

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

    81

{

    82

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

    83

}

    84

    85

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

    86

    87

/**

    88

   Bereitet ein Kommando zum Laden von Daten von der Mailbox vor.

    89

 */

    90

    91

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

    92

{

    93

    ec_command_t *command = &slave->mbox_command;

    94

    95

    if (ec_command_nprd(command, slave->station_address,

    96

                        slave->sii_tx_mailbox_offset,

    97

                        slave->sii_tx_mailbox_size)) return -1;

    98

    return 0;

    99

}

   100

   101

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

   102

   103

/**

   104

   Verarbeitet empfangene Mailbox-Daten.

   105

 */

   106

   107

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

   108

                             uint8_t type, /**< Protokoll */

   110

                             )

   111

{

   112

    ec_command_t *command = &slave->mbox_command;

   113

    size_t data_size;

   114

   115

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

   116

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

   117

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

   118

               slave->ring_position);

   119

        return NULL;

   120

    }

   121

   122

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

   123

        slave->sii_tx_mailbox_size - 6) {

   124

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

   125

        return NULL;

   126

    }

   127

   128

    *size = data_size;

   129

    return command->data + 6;

   130

}

   131

   132

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

   133

   134

/**

   135

   Sendet und wartet auf den Empfang eines Mailbox-Kommandos.

   136

 */

   137

   138

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

   139

                                 size_t *size /**< Größe der gelesenen

   140

                                                 Daten */

   141

                                 )

   142

{

   143

    uint8_t type;

   144

    ec_command_t *command;

   145

   146

    command = &slave->mbox_command;

   147

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

   148

   149

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

   150

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

   151

               slave->ring_position);

   152

        return NULL;

   153

    }

   154

   155

    return ec_slave_mbox_simple_receive(slave, type, size);

   156

}

   157

   158

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

   159

   160

/**

   161

   Wartet auf den Empfang eines Mailbox-Kommandos.

   162

 */

   163

   164

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

   165

                                      uint8_t type, /**< Protokoll */

   166

                                      size_t *size /**< Größe der gelesenen

   167

                                                      Daten */

   168

                                      )

   169

{

   170

    cycles_t start, end, timeout;

   171

    ec_command_t *command;

   172

   173

    command = &slave->mbox_command;

   174

    start = get_cycles();

   175

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

   176

   177

    while (1)

   178

    {

   179

        if (ec_slave_mbox_prepare_check(slave)) return NULL;

   180

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

   181

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

   182

                   slave->ring_position);

   183

            return NULL;

   184

        }

   185

   186

        end = get_cycles();

   187

   188

        if (ec_slave_mbox_check(slave))

   189

            break; // Proceed with receiving data

   190

   191

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

   192

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

   193

                   slave->ring_position);

   194

            return NULL;

   195

        }

   196

   197

        udelay(100);

   198

    }

   199

   200

    if (ec_slave_mbox_prepare_fetch(slave)) return NULL;

   201

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

   202

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

   203

               slave->ring_position);

   204

        return NULL;

   205

    }

   206

   207

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

   208

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

   209

                                                / cpu_khz));

   210

   211

    return ec_slave_mbox_fetch(slave, type, size);

   212

}

   213

   214

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