1 /******************************************************************************

     2  *

     3  *  e c _ c o m m a n d . c

     4  *

     5  *  Methoden für ein EtherCAT-Kommando.

     6  *

     7  *  $Id$

     8  *

     9  *****************************************************************************/

    10 

    11 #include <linux/slab.h>

    12 

    13 #include "ec_command.h"

    14 

    15 /*****************************************************************************/

    16 

    17 /**

    18    Kommando-Konstruktor.

    19 

    20    Initialisiert alle Variablen innerhalb des Kommandos auf die

    21    Default-Werte.

    22 

    23    @param cmd Zeiger auf das zu initialisierende Kommando.

    24 */

    25 

    26 void EtherCAT_command_init(EtherCAT_command_t *cmd)

    27 {

    28   cmd->type = ECAT_CMD_NONE;

    29   cmd->address.logical = 0x00000000;

    30   cmd->data_length = 0;

    31   cmd->state = ECAT_CS_READY;

    32   cmd->index = 0;

    33   cmd->working_counter = 0;

    34 }

    35 

    36 /*****************************************************************************/

    37 

    38 /**

    39    Kommando-Destruktor.

    40 

    41    Setzt alle Attribute auf den Anfangswert zurueck.

    42 

    43    @param cmd Zeiger auf das zu initialisierende Kommando.

    44 */

    45 

    46 void EtherCAT_command_clear(EtherCAT_command_t *cmd)

    47 {

    48   EtherCAT_command_init(cmd);

    49 }

    50 

    51 /*****************************************************************************/

    52 

    53 #define ECAT_FUNC_HEADER \

    54   EtherCAT_command_init(cmd)

    55 

    56 #define ECAT_FUNC_WRITE_FOOTER \

    57   cmd->data_length = length; \

    58   memcpy(cmd->data, data, length);

    59 

    60 #define ECAT_FUNC_READ_FOOTER \

    61   cmd->data_length = length;

    62 

    63 /*****************************************************************************/

    64 

    65 /**

    66    Initialisiert ein EtherCAT-NPRD-Kommando.

    67 

    68    @param cmd Zeiger auf das Kommando

    69    @param node_address Adresse des Knotens (Slaves)

    70    @param offset Physikalische Speicheradresse im Slave

    71    @param length Länge der zu lesenden Daten

    72 */

    73 

    74 void EtherCAT_command_read(EtherCAT_command_t *cmd,

    75                            unsigned short node_address,

    76                            unsigned short offset,

    77                            unsigned int length)

    78 {

    79   if (unlikely(node_address == 0x0000))

    80     printk(KERN_WARNING "EtherCAT: Warning - Using node address 0x0000!\n");

    81 

    82   ECAT_FUNC_HEADER;

    83 

    84   cmd->type = ECAT_CMD_NPRD;

    85   cmd->address.phy.dev.node = node_address;

    86   cmd->address.phy.mem = offset;

    87 

    88   ECAT_FUNC_READ_FOOTER;

    89 }

    90 

    91 /*****************************************************************************/

    92 

    93 /**

    94    Initialisiert ein EtherCAT-NPWR-Kommando.

    95 

    96    Alloziert ein "node-adressed physical write"-Kommando

    97    und fügt es in die Liste des Masters ein.

    98 

    99    @param cmd Zeiger auf das Kommando

   100    @param node_address Adresse des Knotens (Slaves)

   101    @param offset Physikalische Speicheradresse im Slave

   102    @param length Länge der zu schreibenden Daten

   103    @param data Zeiger auf Speicher mit zu schreibenden Daten

   104 */

   105 

   106 void EtherCAT_command_write(EtherCAT_command_t *cmd,

   107                             unsigned short node_address,

   108                             unsigned short offset,

   109                             unsigned int length,

   110                             const unsigned char *data)

   111 {

   112   if (unlikely(node_address == 0x0000))

   113     printk(KERN_WARNING "EtherCAT: Warning - Using node address 0x0000!\n");

   114 

   115   ECAT_FUNC_HEADER;

   116 

   117   cmd->type = ECAT_CMD_NPWR;

   118   cmd->address.phy.dev.node = node_address;

   119   cmd->address.phy.mem = offset;

   120 

   121   ECAT_FUNC_WRITE_FOOTER;

   122 }

   123 

   124 /*****************************************************************************/

   125 

   126 /**

   127    Initialisiert ein EtherCAT-APRD-Kommando.

   128 

   129    Alloziert ein "autoincerement physical read"-Kommando

   130    und fügt es in die Liste des Masters ein.

   131 

   132    @param cmd Zeiger auf das Kommando

   133    @param ring_position (Negative) Position des Slaves im Bus

   134    @param offset Physikalische Speicheradresse im Slave

   135    @param length Länge der zu lesenden Daten

   136 */

   137 

   138 void EtherCAT_command_position_read(EtherCAT_command_t *cmd,

   139                                     short ring_position,

   140                                     unsigned short offset,

   141                                     unsigned int length)

   142 {

   143   ECAT_FUNC_HEADER;

   144 

   145   cmd->type = ECAT_CMD_APRD;

   146   cmd->address.phy.dev.pos = ring_position;

   147   cmd->address.phy.mem = offset;

   148 

   149   ECAT_FUNC_READ_FOOTER;

   150 }

   151 

   152 /*****************************************************************************/

   153 

   154 /**

   155    Initialisiert ein EtherCAT-APWR-Kommando.

   156 

   157    Alloziert ein "autoincrement physical write"-Kommando

   158    und fügt es in die Liste des Masters ein.

   159 

   160    @param cmd Zeiger auf das Kommando

   161    @param ring_position (Negative) Position des Slaves im Bus

   162    @param offset Physikalische Speicheradresse im Slave

   163    @param length Länge der zu schreibenden Daten

   164    @param data Zeiger auf Speicher mit zu schreibenden Daten

   165 */

   166 

   167 void EtherCAT_command_position_write(EtherCAT_command_t *cmd,

   168                                      short ring_position,

   169                                      unsigned short offset,

   170                                      unsigned int length,

   171                                      const unsigned char *data)

   172 {

   173   ECAT_FUNC_HEADER;

   174 

   175   cmd->type = ECAT_CMD_APWR;

   176   cmd->address.phy.dev.pos = ring_position;

   177   cmd->address.phy.mem = offset;

   178 

   179   ECAT_FUNC_WRITE_FOOTER;

   180 }

   181 

   182 /*****************************************************************************/

   183 

   184 /**

   185    Initialisiert ein EtherCAT-BRD-Kommando.

   186 

   187    Alloziert ein "broadcast read"-Kommando

   188    und fügt es in die Liste des Masters ein.

   189 

   190    @param cmd Zeiger auf das Kommando

   191    @param offset Physikalische Speicheradresse im Slave

   192    @param length Länge der zu lesenden Daten

   193 */

   194 

   195 void EtherCAT_command_broadcast_read(EtherCAT_command_t *cmd,

   196                                      unsigned short offset,

   197                                      unsigned int length)

   198 {

   199   ECAT_FUNC_HEADER;

   200 

   201   cmd->type = ECAT_CMD_BRD;

   202   cmd->address.phy.dev.node = 0x0000;

   203   cmd->address.phy.mem = offset;

   204 

   205   ECAT_FUNC_READ_FOOTER;

   206 }

   207 

   208 /*****************************************************************************/

   209 

   210 /**

   211    Initialisiert ein EtherCAT-BWR-Kommando.

   212 

   213    Alloziert ein "broadcast write"-Kommando

   214    und fügt es in die Liste des Masters ein.

   215 

   216    @param cmd Zeiger auf das Kommando

   217    @param offset Physikalische Speicheradresse im Slave

   218    @param length Länge der zu schreibenden Daten

   219    @param data Zeiger auf Speicher mit zu schreibenden Daten

   220 */

   221 

   222 void EtherCAT_command_broadcast_write(EtherCAT_command_t *cmd,

   223                                       unsigned short offset,

   224                                       unsigned int length,

   225                                       const unsigned char *data)

   226 {

   227   ECAT_FUNC_HEADER;

   228 

   229   cmd->type = ECAT_CMD_BWR;

   230   cmd->address.phy.dev.node = 0x0000;

   231   cmd->address.phy.mem = offset;

   232 

   233   ECAT_FUNC_WRITE_FOOTER;

   234 }

   235 

   236 /*****************************************************************************/

   237 

   238 /**

   239    Initialisiert ein EtherCAT-LRW-Kommando.

   240 

   241    Alloziert ein "logical read write"-Kommando

   242    und fügt es in die Liste des Masters ein.

   243 

   244    @param cmd Zeiger auf das Kommando

   245    @param offset Logische Speicheradresse

   246    @param length Länge der zu lesenden/schreibenden Daten

   247    @param data Zeiger auf Speicher mit zu lesenden/schreibenden Daten

   248 */

   249 

   250 void EtherCAT_command_logical_read_write(EtherCAT_command_t *cmd,

   251                                          unsigned int offset,

   252                                          unsigned int length,

   253                                          unsigned char *data)

   254 {

   255   ECAT_FUNC_HEADER;

   256 

   257   cmd->type = ECAT_CMD_LRW;

   258   cmd->address.logical = offset;

   259 

   260   ECAT_FUNC_WRITE_FOOTER;

   261 }

   262 

   263 /*****************************************************************************/