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

   CANopen Sdo functions.

    37

*/

    38

    39

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

    40

    41

#include <linux/module.h>

    42

    43

#include "master.h"

    44

    45

#include "sdo.h"

    46

    47

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

    48

    49

ssize_t ec_show_sdo_attribute(struct kobject *, struct attribute *, char *);

    50

void ec_sdo_clear(struct kobject *);

    51

    52

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

    53

    54

/** \cond */

    55

    56

EC_SYSFS_READ_ATTR(info);

    57

    58

static struct attribute *sdo_def_attrs[] = {

    59

    &attr_info,

    60

    NULL,

    61

};

    62

    63

static struct sysfs_ops sdo_sysfs_ops = {

    64

    .show = &ec_show_sdo_attribute,

    65

    .store = NULL

    66

};

    67

    68

static struct kobj_type ktype_ec_sdo = {

    69

    .release = ec_sdo_clear,

    70

    .sysfs_ops = &sdo_sysfs_ops,

    71

    .default_attrs = sdo_def_attrs

    72

};

    73

    74

/** \endcond */

    75

    76

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

    77

    78

/** Sdo constructor.

    79

 *

    80

 * \todo Turn parameters.

    81

 */

    82

int ec_sdo_init(

    83

        ec_sdo_t *sdo, /**< Sdo. */

    84

        uint16_t index, /**< Sdo index. */

    85

        ec_slave_t *slave /**< Parent slave. */

    86

        )

    87

{

    88

    sdo->slave = slave;

    89

    sdo->index = index;

    90

    sdo->object_code = 0x00;

    91

    sdo->name = NULL;

    92

    sdo->max_subindex = 0;

    93

    INIT_LIST_HEAD(&sdo->entries);

    94

    95

    // Init kobject and add it to the hierarchy

    96

    memset(&sdo->kobj, 0x00, sizeof(struct kobject));

    97

    kobject_init(&sdo->kobj);

    98

    sdo->kobj.ktype = &ktype_ec_sdo;

    99

    sdo->kobj.parent = &slave->sdo_kobj;

   100

    if (kobject_set_name(&sdo->kobj, "%4X", sdo->index)) {

   101

        EC_ERR("Failed to set kobj name.\n");

   102

        kobject_put(&sdo->kobj);

   103

        return -1;

   104

    }

   105

    if (kobject_add(&sdo->kobj)) {

   106

        EC_ERR("Failed to add Sdo kobject.\n");

   107

        kobject_put(&sdo->kobj);

   108

        return -1;

   109

    }

   110

   111

    return 0;

   112

}

   113

   114

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

   115

   116

/** Sdo destructor.

   117

 *

   118

 * Clears and frees an Sdo object.

   119

 */

   120

void ec_sdo_destroy(

   121

        ec_sdo_t *sdo /**< Sdo. */

   122

        )

   123

{

   124

    ec_sdo_entry_t *entry, *next;

   125

   126

    // free all entries

   127

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

   128

        list_del(&entry->list);

   129

        ec_sdo_entry_destroy(entry);

   130

    }

   131

   132

    // destroy self

   133

    kobject_del(&sdo->kobj);

   134

    kobject_put(&sdo->kobj);

   135

}

   136

   137

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

   138

   139

/** Clear and free Sdo.

   140

 *

   141

 * This method is called by the kobject,

   142

 * once there are no more references to it.

   143

 */

   144

void ec_sdo_clear(

   145

        struct kobject *kobj /**< Sdo's kobject. */

   146

        )

   147

{

   148

    ec_sdo_t *sdo = container_of(kobj, ec_sdo_t, kobj);

   149

   150

    if (sdo->name) kfree(sdo->name);

   151

   152

    kfree(sdo);

   153

}

   154

   155

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

   156

   157

/** Get an Sdo entry from an Sdo via its subindex.

   158

 * 

   159

 * \retval >0 Pointer to the requested Sdo entry.

   160

 * \retval NULL Sdo entry not found.

   161

 */

   162

ec_sdo_entry_t *ec_sdo_get_entry(

   163

        ec_sdo_t *sdo, /**< Sdo. */

   164

        uint8_t subindex /**< Entry subindex. */

   165

        )

   166

{

   167

    ec_sdo_entry_t *entry;

   168

   169

    list_for_each_entry(entry, &sdo->entries, list) {

   170

        if (entry->subindex != subindex)

   171

            continue;

   172

        return entry;

   173

    }

   174

   175

    return NULL;

   176

}

   177

   178

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

   179

   180

/** Get an Sdo entry from an Sdo via its subindex.

   181

 *

   182

 * const version.

   183

 * 

   184

 * \retval >0 Pointer to the requested Sdo entry.

   185

 * \retval NULL Sdo entry not found.

   186

 */

   187

const ec_sdo_entry_t *ec_sdo_get_entry_const(

   188

        const ec_sdo_t *sdo, /**< Sdo. */

   189

        uint8_t subindex /**< Entry subindex. */

   190

        )

   191

{

   192

    const ec_sdo_entry_t *entry;

   193

   194

    list_for_each_entry(entry, &sdo->entries, list) {

   195

        if (entry->subindex != subindex)

   196

            continue;

   197

        return entry;

   198

    }

   199

   200

    return NULL;

   201

}

   202

   203

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

   204

   205

/** Print Sdo information to a buffer.

   206

 * 

   207

 * /return size of bytes written to buffer.

   208

 */ 

   209

ssize_t ec_sdo_info(

   210

        ec_sdo_t *sdo, /**< Sdo. */

   211

        char *buffer /**< Target buffer. */

   212

        )

   213

{

   214

    off_t off = 0;

   215

   216

    off += sprintf(buffer + off, "Index: 0x%04X\n", sdo->index);

   217

    off += sprintf(buffer + off, "Name: %s\n", sdo->name ? sdo->name : "");

   218

    off += sprintf(buffer + off, "Max subindex: %u\n", sdo->max_subindex);

   219

   220

    return off;

   221

}

   222

   223

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

   224

   225

/** Show a Sysfs attribute of an Sdo.

   226

 * 

   227

 * /return Number of bytes written to buffer.

   228

 */ 

   229

ssize_t ec_show_sdo_attribute(

   230

        struct kobject *kobj, /**< kobject */

   231

        struct attribute *attr, /**< Requested attribute. */

   232

        char *buffer /**< Buffer to write the data in. */

   233

        )

   234

{

   235

    ec_sdo_t *sdo = container_of(kobj, ec_sdo_t, kobj);

   236

   237

    if (attr == &attr_info) {

   238

        return ec_sdo_info(sdo, buffer);

   239

    }

   240

   241

    return 0;

   242

}

   243

   244

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