1

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

     2

 *

     3

 *  m a i l b o x . c

     4

 *

     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

/**

    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

    54

    55

    return command->data + 6;

    56

}

    57

    58

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

    59

    60

/**

    70

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

    71

        return -1;

    72

    73

    return 0;

    74

}

    75

    76

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

    77

    78

/**

    84

{

    85

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

    86

}

    87

    88

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

    89

    90

/**

    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

/**

   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

/**

   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

/**

   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))

   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

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