1

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

     2

 *

     3

 *  EtherCAT realtime interface.

     4

 *

     5

 *  $Id$

     6

 *

    24

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

    25

    26

#ifndef __ECRT_H__

    27

#define __ECRT_H__

    28

    29

#include <asm/byteorder.h>

    30

    31

#ifdef __KERNEL__

    32

#include <linux/types.h>

    33

#else

    34

#include <stdint.h>

    35

#endif

    36

    37

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

    38

    39

struct ec_master;

    40

typedef struct ec_master ec_master_t;

    41

    42

struct ec_domain;

    43

typedef struct ec_domain ec_domain_t;

    44

    45

struct ec_slave;

    46

typedef struct ec_slave ec_slave_t;

    47

    48

typedef struct

    49

{

    50

    void **data_ptr;

    51

    const char *slave_address;

    52

    const char *vendor_name;

    53

    const char *product_name;

    54

    const char *field_name;

    55

    unsigned int field_index;

    56

    unsigned int field_count;

    57

}

    58

ec_field_init_t;

    59

    60

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

    61

// Master request functions

    62

    63

ec_master_t *ecrt_request_master(unsigned int master_index);

    64

void ecrt_release_master(ec_master_t *master);

    65

    66

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

    67

// Master methods

    68

    69

ec_domain_t *ecrt_master_create_domain(ec_master_t *master);

    70

    71

int ecrt_master_activate(ec_master_t *master);

    72

void ecrt_master_deactivate(ec_master_t *master);

    73

    74

int ecrt_master_fetch_sdo_lists(ec_master_t *master);

    75

    76

void ecrt_master_sync_io(ec_master_t *master);

    77

void ecrt_master_async_send(ec_master_t *master);

    78

void ecrt_master_async_receive(ec_master_t *master);

    79

void ecrt_master_prepare_async_io(ec_master_t *master);

    80

    81

void ecrt_master_run(ec_master_t *master);

    82

    83

void ecrt_master_debug(ec_master_t *master, int level);

    84

void ecrt_master_print(const ec_master_t *master, unsigned int verbosity);

    85

    86

ec_slave_t *ecrt_master_get_slave(const ec_master_t *, const char *);

    87

    88

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

    89

// Domain Methods

    90

    91

ec_slave_t *ecrt_domain_register_field(ec_domain_t *domain,

    92

                                       const char *address,

    93

                                       const char *vendor_name,

    94

                                       const char *product_name,

    95

                                       void **data_ptr, const char *field_name,

    96

                                       unsigned int field_index,

    97

                                       unsigned int field_count);

    98

int ecrt_domain_register_field_list(ec_domain_t *domain,

    99

                                    const ec_field_init_t *fields);

   100

   101

void ecrt_domain_queue(ec_domain_t *domain);

   102

void ecrt_domain_process(ec_domain_t *domain);

   103

   104

int ecrt_domain_state(ec_domain_t *domain);

   105

   106

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

   107

// Slave Methods

   108

   109

int ecrt_slave_sdo_read_exp8(ec_slave_t *slave, uint16_t sdo_index,

   110

                              uint8_t sdo_subindex, uint8_t *value);

   111

int ecrt_slave_sdo_read_exp16(ec_slave_t *slave, uint16_t sdo_index,

   112

                              uint8_t sdo_subindex, uint16_t *value);

   113

int ecrt_slave_sdo_read_exp32(ec_slave_t *slave, uint16_t sdo_index,

   114

                              uint8_t sdo_subindex, uint32_t *value);

   115

int ecrt_slave_sdo_write_exp8(ec_slave_t *slave, uint16_t sdo_index,

   116

                              uint8_t sdo_subindex, uint8_t value);

   117

int ecrt_slave_sdo_write_exp16(ec_slave_t *slave, uint16_t sdo_index,

   118

                               uint8_t sdo_subindex, uint16_t value);

   119

int ecrt_slave_sdo_write_exp32(ec_slave_t *slave, uint16_t sdo_index,

   120

                               uint8_t sdo_subindex, uint32_t value);

   121

int ecrt_slave_sdo_read(ec_slave_t *slave, uint16_t sdo_index,

   122

                        uint8_t sdo_subindex, uint8_t *data, size_t *size);

   123

   124

int ecrt_slave_write_alias(ec_slave_t *slave, uint16_t alias);

   125

   126

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

   127

// Bitwise read/write macros

   128

   129

#define EC_READ_BIT(PD, CH) ((*((uint8_t *) (PD)) >> (CH)) & 0x01)

   130

   131

#define EC_WRITE_BIT(PD, CH, VAL) \

   132

    do { \

   133

        if (VAL) *((uint8_t *) (PD)) |=  (1 << (CH)); \

   134

        else     *((uint8_t *) (PD)) &= ~(1 << (CH)); \

   135

    } while (0)

   136

   137

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

   138

// Read macros

   139

   140

#define EC_READ_U8(PD) ((uint8_t) *((uint8_t *) (PD)))

   141

#define EC_READ_S8(PD) ((int8_t)  *((uint8_t *) (PD)))

   142

   143

#define EC_READ_U16(PD) ((uint16_t) le16_to_cpup((void *) (PD)))

   144

#define EC_READ_S16(PD) ((int16_t)  le16_to_cpup((void *) (PD)))

   145

   146

#define EC_READ_U32(PD) ((uint32_t) le32_to_cpup((void *) (PD)))

   147

#define EC_READ_S32(PD) ((int32_t)  le32_to_cpup((void *) (PD)))

   148

   149

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

   150

// Write macros

   151

   152

#define EC_WRITE_U8(PD, VAL) \

   153

    do { \

   154

        *((uint8_t *)(PD)) = ((uint8_t) (VAL)); \

   155

    } while (0)

   156

   157

#define EC_WRITE_S8(PD, VAL) EC_WRITE_U8(PD, VAL)

   158

   159

#define EC_WRITE_U16(PD, VAL) \

   160

    do { \

   161

        *((uint16_t *) (PD)) = (uint16_t) (VAL); \

   162

        cpu_to_le16s(PD); \

   163

    } while (0)

   164

   165

#define EC_WRITE_S16(PD, VAL) EC_WRITE_U16(PD, VAL)

   166

   167

#define EC_WRITE_U32(PD, VAL) \

   168

    do { \

   169

        *((uint32_t *) (PD)) = (uint32_t) (VAL); \

   170

        cpu_to_le16s(PD); \

   171

    } while (0)

   172

   173

#define EC_WRITE_S32(PD, VAL) EC_WRITE_U32(PD, VAL)

   174

   175

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

   176

   177

#endif