1

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

     2

 *

     3

 *  m i n i . c

     4

 *

     6

 *

     7

 *  $Id$

     8

 *

     9

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

    10

    11

#include <linux/module.h>

    12

#include <linux/delay.h>

    13

#include <linux/timer.h>

    14

    16

    17

#define ASYNC

    21

    22

struct timer_list timer;

    23

    24

// EtherCAT

    25

ec_master_t *master = NULL;

    26

ec_domain_t *domain1 = NULL;

    27

    29

//void *r_ssi_input, *r_ssi_status, *r_4102[3];

    30

    32

uint32_t k_pos;

    33

uint8_t k_stat;

    34

    35

ec_field_init_t domain1_fields[] = {

    37

    {NULL, "2", "Beckhoff", "EL4132", "OutputValue",  0},

    38

    {}

    39

};

    40

    41

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

    42

    43

void run(unsigned long data)

    44

{

    45

    static unsigned int counter = 0;

    46

    47

#ifdef ASYNC

    49

    ecrt_master_async_receive(master);

    50

    ecrt_domain_process(domain1);

    51

#else

    53

    ecrt_domain_queue(domain1);

    54

    ecrt_master_run(master);

    55

    ecrt_master_sync_io(master);

    56

    ecrt_domain_process(domain1);

    57

#endif

    58

    60

    //k_pos = EC_READ_U32(r_ssi);

    61

    62

#ifdef ASYNC

    64

    ecrt_domain_queue(domain1);

    65

    ecrt_master_run(master);

    66

    ecrt_master_async_send(master);

    67

#endif

    68

    69

    if (counter) {

    70

        counter--;

    71

    }

    72

    else {

    74

        //printk(KERN_INFO "k_pos    = %i\n", k_pos);

    75

        //printk(KERN_INFO "k_stat   = 0x%02X\n", k_stat);

    76

    }

    77

    80

    add_timer(&timer);

    81

}

    82

    83

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

    84

    85

int __init init_mini_module(void)

    86

{

    87

    printk(KERN_INFO "=== Starting Minimal EtherCAT environment... ===\n");

    88

    89

    if ((master = ecrt_request_master(0)) == NULL) {

    90

        printk(KERN_ERR "Requesting master 0 failed!\n");

    91

        goto out_return;

    92

    }

    93

    94

    printk(KERN_INFO "Registering domain...\n");

    95

    if (!(domain1 = ecrt_master_create_domain(master)))

    96

    {

    97

        printk(KERN_ERR "Domain creation failed!\n");

    98

        goto out_release_master;

    99

    }

   100

   101

    printk(KERN_INFO "Registering domain fields...\n");

   102

    if (ecrt_domain_register_field_list(domain1, domain1_fields)) {

   103

        printk(KERN_ERR "Field registration failed!\n");

   104

        goto out_release_master;

   105

    }

   106

   107

    printk(KERN_INFO "Activating master...\n");

   108

    if (ecrt_master_activate(master)) {

   109

        printk(KERN_ERR "Failed to activate master!\n");

   110

        goto out_release_master;

   111

    }

   112

   113

#if 0

   114

    if (ecrt_master_fetch_sdo_lists(master)) {

   115

        printk(KERN_ERR "Failed to fetch SDO lists!\n");

   116

        goto out_deactivate;

   117

    }

   118

    ecrt_master_print(master, 2);

   119

#else

   120

    ecrt_master_print(master, 0);

   121

#endif

   122

   123

   124

#if 0

   125

    if (!(slave = ecrt_master_get_slave(master, "5"))) {

   126

        printk(KERN_ERR "Failed to get slave 5!\n");

   127

        goto out_deactivate;

   128

    }

   129

   130

    if (ecrt_slave_sdo_write_exp8(slave, 0x4061, 1,  0) ||

   131

        ecrt_slave_sdo_write_exp8(slave, 0x4061, 2,  1) ||

   132

        ecrt_slave_sdo_write_exp8(slave, 0x4061, 3,  1) ||

   133

        ecrt_slave_sdo_write_exp8(slave, 0x4066, 0,  0) ||

   134

        ecrt_slave_sdo_write_exp8(slave, 0x4067, 0,  4) ||

   135

        ecrt_slave_sdo_write_exp8(slave, 0x4068, 0,  0) ||

   136

        ecrt_slave_sdo_write_exp8(slave, 0x4069, 0, 25) ||

   137

        ecrt_slave_sdo_write_exp8(slave, 0x406A, 0, 25) ||

   138

        ecrt_slave_sdo_write_exp8(slave, 0x406B, 0, 50)) {

   139

        printk(KERN_ERR "Failed to configure SSI slave!\n");

   140

        goto out_deactivate;

   141

    }

   142

#endif

   143

   144

#if 0

   145

    printk(KERN_INFO "Writing alias...\n");

   146

    if (ecrt_slave_sdo_write_exp16(slave, 0xBEEF)) {

   147

        printk(KERN_ERR "Failed to write alias!\n");

   148

        goto out_deactivate;

   149

    }

   150

#endif

   151

   152

#ifdef ASYNC

   154

    ecrt_master_prepare_async_io(master);

   155

#endif

   156

   157

    printk("Starting cyclic sample thread.\n");

   158

    init_timer(&timer);

   159

    timer.function = run;

   161

    add_timer(&timer);

   162

   163

    printk(KERN_INFO "=== Minimal EtherCAT environment started. ===\n");

   164

    return 0;

   165

   166

#if 0

   167

 out_deactivate:

   168

    ecrt_master_deactivate(master);

   169

#endif

   170

 out_release_master:

   171

    ecrt_release_master(master);

   172

 out_return:

   173

    return -1;

   174

}

   175

   176

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

   177

   178

void __exit cleanup_mini_module(void)

   179

{

   180

    printk(KERN_INFO "=== Stopping Minimal EtherCAT environment... ===\n");

   181

   182

    if (master) {

   183

        del_timer_sync(&timer);

   184

        printk(KERN_INFO "Deactivating master...\n");

   185

        ecrt_master_deactivate(master);

   186

        ecrt_release_master(master);

   187

    }

   188

   189

    printk(KERN_INFO "=== Minimal EtherCAT environment stopped. ===\n");

   190

}

   191

   192

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

   193

   194

MODULE_LICENSE("GPL");

   195

MODULE_AUTHOR ("Florian Pose <fp@igh-essen.com>");

   196

MODULE_DESCRIPTION ("EtherCAT minimal test environment");

   197

   198

module_init(init_mini_module);

   199

module_exit(cleanup_mini_module);

   200

   201

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

   202