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

     2  *

     3  *  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 "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 ec_command_init(ec_command_t *cmd)

    27 {

    28   cmd->type = EC_COMMAND_NONE;

    29   cmd->address.logical = 0x00000000;

    30   cmd->data_length = 0;

    31   cmd->state = EC_COMMAND_STATE_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 ec_command_clear(ec_command_t *cmd)

    47 {

    48   ec_command_init(cmd);

    49 }

    50 

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

    52 

    53 #define EC_FUNC_HEADER \

    54   ec_command_init(cmd)

    55 

    56 #define EC_FUNC_WRITE_FOOTER \

    57   cmd->data_length = length; \

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

    59 

    60 #define EC_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 ec_command_read(ec_command_t *cmd, unsigned short node_address,

    75                      unsigned short offset, unsigned int length)

    76 {

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

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

    79 

    80   EC_FUNC_HEADER;

    81 

    82   cmd->type = EC_COMMAND_NPRD;

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

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

    85 

    86   EC_FUNC_READ_FOOTER;

    87 }

    88 

    89 /*****************************************************************************/

    90 

    91 /**

    92    Initialisiert ein EtherCAT-NPWR-Kommando.

    93 

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

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

    96 

    97    @param cmd Zeiger auf das Kommando

    98    @param node_address Adresse des Knotens (Slaves)

    99    @param offset Physikalische Speicheradresse im Slave

   100    @param length Länge der zu schreibenden Daten

   101    @param data Zeiger auf Speicher mit zu schreibenden Daten

   102 */

   103 

   104 void ec_command_write(ec_command_t *cmd, unsigned short node_address,

   105                       unsigned short offset, unsigned int length,

   106                       const unsigned char *data)

   107 {

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

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

   110 

   111   EC_FUNC_HEADER;

   112 

   113   cmd->type = EC_COMMAND_NPWR;

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

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

   116 

   117   EC_FUNC_WRITE_FOOTER;

   118 }

   119 

   120 /*****************************************************************************/

   121 

   122 /**

   123    Initialisiert ein EtherCAT-APRD-Kommando.

   124 

   125    Alloziert ein "autoincerement physical read"-Kommando

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

   127 

   128    @param cmd Zeiger auf das Kommando

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

   130    @param offset Physikalische Speicheradresse im Slave

   131    @param length Länge der zu lesenden Daten

   132 */

   133 

   134 void ec_command_position_read(ec_command_t *cmd, short ring_position,

   135                               unsigned short offset, unsigned int length)

   136 {

   137   EC_FUNC_HEADER;

   138 

   139   cmd->type = EC_COMMAND_APRD;

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

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

   142 

   143   EC_FUNC_READ_FOOTER;

   144 }

   145 

   146 /*****************************************************************************/

   147 

   148 /**

   149    Initialisiert ein EtherCAT-APWR-Kommando.

   150 

   151    Alloziert ein "autoincrement physical write"-Kommando

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

   153 

   154    @param cmd Zeiger auf das Kommando

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

   156    @param offset Physikalische Speicheradresse im Slave

   157    @param length Länge der zu schreibenden Daten

   158    @param data Zeiger auf Speicher mit zu schreibenden Daten

   159 */

   160 

   161 void ec_command_position_write(ec_command_t *cmd, short ring_position,

   162                                unsigned short offset, unsigned int length,

   163                                const unsigned char *data)

   164 {

   165   EC_FUNC_HEADER;

   166 

   167   cmd->type = EC_COMMAND_APWR;

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

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

   170 

   171   EC_FUNC_WRITE_FOOTER;

   172 }

   173 

   174 /*****************************************************************************/

   175 

   176 /**

   177    Initialisiert ein EtherCAT-BRD-Kommando.

   178 

   179    Alloziert ein "broadcast read"-Kommando

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

   181 

   182    @param cmd Zeiger auf das Kommando

   183    @param offset Physikalische Speicheradresse im Slave

   184    @param length Länge der zu lesenden Daten

   185 */

   186 

   187 void ec_command_broadcast_read(ec_command_t *cmd, unsigned short offset,

   188                                unsigned int length)

   189 {

   190   EC_FUNC_HEADER;

   191 

   192   cmd->type = EC_COMMAND_BRD;

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

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

   195 

   196   EC_FUNC_READ_FOOTER;

   197 }

   198 

   199 /*****************************************************************************/

   200 

   201 /**

   202    Initialisiert ein EtherCAT-BWR-Kommando.

   203 

   204    Alloziert ein "broadcast write"-Kommando

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

   206 

   207    @param cmd Zeiger auf das Kommando

   208    @param offset Physikalische Speicheradresse im Slave

   209    @param length Länge der zu schreibenden Daten

   210    @param data Zeiger auf Speicher mit zu schreibenden Daten

   211 */

   212 

   213 void ec_command_broadcast_write(ec_command_t *cmd, unsigned short offset,

   214                                 unsigned int length, const unsigned char *data)

   215 {

   216   EC_FUNC_HEADER;

   217 

   218   cmd->type = EC_COMMAND_BWR;

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

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

   221 

   222   EC_FUNC_WRITE_FOOTER;

   223 }

   224 

   225 /*****************************************************************************/

   226 

   227 /**

   228    Initialisiert ein EtherCAT-LRW-Kommando.

   229 

   230    Alloziert ein "logical read write"-Kommando

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

   232 

   233    @param cmd Zeiger auf das Kommando

   234    @param offset Logische Speicheradresse

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

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

   237 */

   238 

   239 void ec_command_logical_read_write(ec_command_t *cmd, unsigned int offset,

   240                                    unsigned int length, unsigned char *data)

   241 {

   242   EC_FUNC_HEADER;

   243 

   244   cmd->type = EC_COMMAND_LRW;

   245   cmd->address.logical = offset;

   246 

   247   EC_FUNC_WRITE_FOOTER;

   248 }

   249 

   250 /*****************************************************************************/