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 */

   109                              size_t *size /**< Größe der empfangenen

   110                                              Daten */

   111                              )

   112 {

   113     ec_command_t *command = &slave->mbox_command;

   114     size_t data_size;

   115 

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

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

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

   119                slave->ring_position);

   120         return NULL;

   121     }

   122 

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

   124         slave->sii_tx_mailbox_size - 6) {

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

   126         return NULL;

   127     }

   128 

   129     *size = data_size;

   130     return command->data + 6;

   131 }

   132 

   133 /*****************************************************************************/

   134 

   135 /**

   136    Sendet und wartet auf den Empfang eines Mailbox-Kommandos.

   137  */

   138 

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

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

   141                                                  Daten */

   142                                  )

   143 {

   144     uint8_t type;

   145     ec_command_t *command;

   146 

   147     command = &slave->mbox_command;

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

   149 

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

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

   152                slave->ring_position);

   153         return NULL;

   154     }

   155 

   156     return ec_slave_mbox_simple_receive(slave, type, size);

   157 }

   158 

   159 /*****************************************************************************/

   160 

   161 /**

   162    Wartet auf den Empfang eines Mailbox-Kommandos.

   163  */

   164 

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

   166                                       uint8_t type, /**< Protokoll */

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

   168                                                       Daten */

   169                                       )

   170 {

   171     cycles_t start, end, timeout;

   172     ec_command_t *command;

   173 

   174     command = &slave->mbox_command;

   175     start = get_cycles();

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

   177 

   178     while (1)

   179     {

   180         if (ec_slave_mbox_prepare_check(slave)) return NULL;

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

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

   183                    slave->ring_position);

   184             return NULL;

   185         }

   186 

   187         end = get_cycles();

   188 

   189         if (ec_slave_mbox_check(slave))

   190             break; // Proceed with receiving data

   191 

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

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

   194                    slave->ring_position);

   195             return NULL;

   196         }

   197 

   198         udelay(100);

   199     }

   200 

   201     if (ec_slave_mbox_prepare_fetch(slave)) return NULL;

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

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

   204                slave->ring_position);

   205         return NULL;

   206     }

   207 

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

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

   210                                                 / cpu_khz));

   211 

   212     return ec_slave_mbox_fetch(slave, type, size);

   213 }

   214 

   215 /*****************************************************************************/

   216 

   217 #if 0

   218 /**

   219    Sendet ein Mailbox-Kommando.

   220  */

   221 

   222 int ec_slave_mbox_send(ec_slave_t *slave, /**< EtherCAT-Slave */

   223                        uint8_t type, /**< Unterliegendes Protokoll */

   224                        const uint8_t *prot_data, /**< Protokoll-Daten */

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

   226                        )

   227 {

   228     uint8_t *data;

   229     ec_command_t command;

   230 

   231 

   232     }

   233 

   234     if (!(data = kmalloc(slave->sii_rx_mailbox_size, GFP_KERNEL))) {

   235         EC_ERR("Failed to allocate %i bytes of memory for mailbox data!\n",

   236                slave->sii_rx_mailbox_size);

   237         return -1;

   238     }

   239 

   240     memset(data, 0x00, slave->sii_rx_mailbox_size);

   241     EC_WRITE_U16(data,      size); // Length of the Mailbox service data

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

   243     EC_WRITE_U8 (data + 4,  0x00); // Channel & priority

   244     EC_WRITE_U8 (data + 5,  type); // Underlying protocol type

   245     memcpy(data + 6, prot_data, size);

   246 

   247     ec_command_init_npwr(&command, slave->station_address,

   248                          slave->sii_rx_mailbox_offset,

   249                          slave->sii_rx_mailbox_size, data);

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

   251         EC_ERR("Mailbox sending failed on slave %i!\n", slave->ring_position);

   252         kfree(data);

   253         return -1;

   254     }

   255 

   256     kfree(data);

   257     return 0;

   258 }

   259 

   260 /*****************************************************************************/

   261 

   262 /**

   263    Sendet ein Mailbox-Kommando.

   264  */

   265 

   266 int ec_slave_mailbox_receive(ec_slave_t *slave, /**< EtherCAT-Slave */

   267                              uint8_t type, /**< Unterliegendes Protokoll */

   268                              uint8_t *prot_data, /**< Protokoll-Daten */

   269                              size_t *size /**< Datengröße des Puffers, später

   270                                              Größe der gelesenen Daten */

   271                              )

   272 {

   273     ec_command_t command;

   274     size_t data_size;

   275     cycles_t start, end, timeout;

   276 

   277     // Read "written bit" of Sync-Manager

   278     start = get_cycles();

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

   280 

   281     while (1)

   282     {

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

   284         ec_command_init_nprd(&command, slave->station_address, 0x808, 8);

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

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

   287                    slave->ring_position);

   288             return -1;

   289         }

   290 

   291         end = get_cycles();

   292 

   293         if (EC_READ_U8(command.data + 5) & 8)

   294             break; // Proceed with received data

   295 

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

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

   298                    slave->ring_position);

   299             return -1;

   300         }

   301 

   302         udelay(100);

   303     }

   304 

   305     ec_command_init_nprd(&command, slave->station_address,

   306                          slave->sii_tx_mailbox_offset,

   307                          slave->sii_tx_mailbox_size);

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

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

   310                slave->ring_position);

   311         return -1;

   312     }

   313 

   314     if ((EC_READ_U8(command.data + 5) & 0x0F) != type) {

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

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

   317                slave->ring_position);

   318         return -1;

   319     }

   320 

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

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

   323                                                 / cpu_khz));

   324 

   325     if ((data_size = EC_READ_U16(command.data)) > *size) {

   326         EC_ERR("Mailbox service data does not fit into buffer (%i > %i).\n",

   327                data_size, *size);

   328         return -1;

   329     }

   330 

   331     if (data_size > slave->sii_tx_mailbox_size - 6) {

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

   333         return -1;

   334     }

   335 

   336     memcpy(prot_data, command.data + 6, data_size);

   337     *size = data_size;

   338     return 0;

   339 }

   340 

   341 /*****************************************************************************/

   342 

   343 uint8_t *ec_slave_init_mbox_send_cmd(ec_slave_t *slave, /**< EtherCAT-Slave */

   344                                      ec_command_t *command, /**< Kommando */

   345                                      uint8_t type, /**< Protokolltyp */

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

   347                                      )

   348 {

   349     size_t total_size;

   350     uint8_t *data;

   351 

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

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

   354                slave->ring_position);

   355         return NULL;

   356     }

   357 

   358     total_size = size + 6;

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

   360         EC_ERR("Data size does not fit into mailbox of slave %i!\n",

   361                slave->ring_position);

   362         return NULL;

   363     }

   364 

   365     data = command->data;

   366 

   367     memset(data, 0x00, slave->sii_rx_mailbox_size);

   368     EC_WRITE_U16(data,     size); // Length of the Mailbox service data

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

   370     EC_WRITE_U8 (data + 4, 0x00); // Channel & priority

   371     EC_WRITE_U8 (data + 5, type); // Underlying protocol type

   372 

   373     return data + 6;

   374 }

   375 #endif

   376 

   377 /*****************************************************************************/