1

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

     2

 *

     3

 *  $Id$

     4

 *

     5

 *  Copyright (C) 2006  Florian Pose, Ingenieurgemeinschaft IgH

     6

 *

     7

 *  This file is part of the IgH EtherCAT Master.

     8

 *

     9

 *  The IgH EtherCAT Master is free software; you can redistribute it

    10

 *  and/or modify it under the terms of the GNU General Public License

    11

 *  as published by the Free Software Foundation; either version 2 of the

    12

 *  License, or (at your option) any later version.

    13

 *

    14

 *  The IgH EtherCAT Master is distributed in the hope that it will be

    15

 *  useful, but WITHOUT ANY WARRANTY; without even the implied warranty of

    16

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    17

 *  GNU General Public License for more details.

    18

 *

    19

 *  You should have received a copy of the GNU General Public License

    20

 *  along with the IgH EtherCAT Master; if not, write to the Free Software

    21

 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    22

 *

    23

 *  The right to use EtherCAT Technology is granted and comes free of

    24

 *  charge under condition of compatibility of product made by

    25

 *  Licensee. People intending to distribute/sell products based on the

    26

 *  code, have to sign an agreement to guarantee that products using

    27

 *  software based on IgH EtherCAT master stay compatible with the actual

    28

 *  EtherCAT specification (which are released themselves as an open

    29

 *  standard) as the (only) precondition to have the right to use EtherCAT

    30

 *  Technology, IP and trade marks.

    31

 *

    32

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

    33

    34

/**

    35

   \file

    36

   EtherCAT process data object methods.

    37

*/

    38

    39

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

    40

    41

#include <linux/slab.h>

    42

    43

#include "pdo.h"

    44

    45

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

    46

    47

void ec_pdo_clear_entries(ec_pdo_t *);

    48

    49

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

    50

    51

/** PDO constructor.

    52

 */

    53

void ec_pdo_init(

    54

        ec_pdo_t *pdo /**< EtherCAT PDO */

    55

        )

    56

{

    57

    pdo->sync_index = -1; // not assigned 

    58

    pdo->name = NULL;

    59

    INIT_LIST_HEAD(&pdo->entries);

    60

}

    61

    62

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

    63

    64

/** Pdo copy constructor.

    65

 */

    66

int ec_pdo_init_copy(ec_pdo_t *pdo, const ec_pdo_t *other_pdo)

    67

{

    68

    pdo->dir = other_pdo->dir;

    69

    pdo->index = other_pdo->index;

    70

    pdo->sync_index = other_pdo->sync_index;

    71

    pdo->name = NULL;

    72

    INIT_LIST_HEAD(&pdo->entries);

    73

    74

    if (ec_pdo_set_name(pdo, other_pdo->name))

    75

        goto out_return;

    76

    77

    if (ec_pdo_copy_entries(pdo, other_pdo))

    78

        goto out_clear;

    79

    80

    return 0;

    81

    82

out_clear:

    83

    ec_pdo_clear(pdo);

    84

out_return:

    85

    return -1;

    86

}

    87

    88

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

    89

    90

/** PDO destructor.

    91

 */

    92

void ec_pdo_clear(ec_pdo_t *pdo /**< EtherCAT PDO */)

    93

{

    94

    if (pdo->name)

    95

        kfree(pdo->name);

    96

    97

    ec_pdo_clear_entries(pdo);

    98

}

    99

   100

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

   101

   102

/** Clear Pdo entry list.

   103

 */

   104

void ec_pdo_clear_entries(ec_pdo_t *pdo /**< EtherCAT PDO */)

   105

{

   106

    ec_pdo_entry_t *entry, *next;

   107

   108

    // free all PDO entries

   109

    list_for_each_entry_safe(entry, next, &pdo->entries, list) {

   110

        list_del(&entry->list);

   111

        ec_pdo_entry_clear(entry);

   112

        kfree(entry);

   113

    }

   114

}

   115

   116

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

   117

   118

/** Set Pdo name.

   119

 */

   120

int ec_pdo_set_name(

   121

        ec_pdo_t *pdo, /**< Pdo. */

   122

        const char *name /**< New name. */

   123

        )

   124

{

   125

    unsigned int len;

   126

   127

    if (pdo->name)

   128

        kfree(pdo->name);

   129

   130

    if (name && (len = strlen(name))) {

   131

        if (!(pdo->name = (char *) kmalloc(len + 1, GFP_KERNEL))) {

   132

            EC_ERR("Failed to allocate PDO name.\n");

   133

            return -1;

   134

        }

   135

        memcpy(pdo->name, name, len + 1);

   136

    } else {

   137

        pdo->name = NULL;

   138

    }

   139

   140

    return 0;

   141

}

   142

   143

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

   144

   145

/** Copy Pdo entries from another Pdo.

   146

 */

   147

int ec_pdo_copy_entries(ec_pdo_t *pdo, const ec_pdo_t *other)

   148

{

   149

    ec_pdo_entry_t *entry, *other_entry;

   150

   151

    ec_pdo_clear_entries(pdo);

   152

   153

    list_for_each_entry(other_entry, &other->entries, list) {

   154

        if (!(entry = (ec_pdo_entry_t *)

   155

                    kmalloc(sizeof(ec_pdo_entry_t), GFP_KERNEL))) {

   156

            EC_ERR("Failed to allocate memory for PDO entry copy.\n");

   157

            return -1;

   158

        }

   159

   160

        if (ec_pdo_entry_init_copy(entry, other_entry)) {

   161

            kfree(entry);

   162

            return -1;

   163

        }

   164

   165

        list_add_tail(&entry->list, &pdo->entries);

   166

    }

   167

   168

    return 0;

   169

}

   170

   171

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

   172

   173

/** Pdo entry constructor.

   174

 */

   175

void ec_pdo_entry_init(

   176

        ec_pdo_entry_t *entry /**< Pdo entry. */

   177

        )

   178

{

   179

    entry->name = NULL;

   180

}

   181

   182

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

   183

   184

/** Pdo entry copy constructor.

   185

 */

   186

int ec_pdo_entry_init_copy(

   187

        ec_pdo_entry_t *entry, /**< Pdo entry. */

   188

        const ec_pdo_entry_t *other /**< Pdo entry to copy from. */

   189

        )

   190

{

   191

    entry->index = other->index;

   192

    entry->subindex = other->subindex;

   193

    entry->name = NULL;

   194

    entry->bit_length = other->bit_length;

   195

   196

    if (ec_pdo_entry_set_name(entry, other->name))

   197

        return -1;

   198

   199

    return 0;

   200

}

   201

   202

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

   203

   204

/** Pdo entry destructor.

   205

 */

   206

void ec_pdo_entry_clear(ec_pdo_entry_t *entry /**< Pdo entry. */)

   207

{

   208

    if (entry->name)

   209

        kfree(entry->name);

   210

}

   211

   212

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

   213

   214

/** Set Pdo entry name.

   215

 */

   216

int ec_pdo_entry_set_name(

   217

        ec_pdo_entry_t *entry, /**< Pdo entry. */

   218

        const char *name /**< New name. */

   219

        )

   220

{

   221

    unsigned int len;

   222

   223

    if (entry->name)

   224

        kfree(entry->name);

   225

   226

    if (name && (len = strlen(name))) {

   227

        if (!(entry->name = (char *) kmalloc(len + 1, GFP_KERNEL))) {

   228

            EC_ERR("Failed to allocate PDO entry name.\n");

   229

            return -1;

   230

        }

   231

        memcpy(entry->name, name, len + 1);

   232

    } else {

   233

        entry->name = NULL;

   234

    }

   235

   236

    return 0;

   237

}

   238

   239

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