datagram.c

Go to the documentation of this file.

/******************************************************************************
 *
 *  $Id$
 *
 *  Copyright (C) 2006-2008  Florian Pose, Ingenieurgemeinschaft IgH
 *
 *  This file is part of the IgH EtherCAT Master.
 *
 *  The IgH EtherCAT Master is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License version 2, as
 *  published by the Free Software Foundation.
 *
 *  The IgH EtherCAT Master is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
 *  Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with the IgH EtherCAT Master; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  ---
 *
 *  The license mentioned above concerns the source code only. Using the
 *  EtherCAT technology and brand is only permitted in compliance with the
 *  industrial property and similar rights of Beckhoff Automation GmbH.
 *
 *****************************************************************************/

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

#include <linux/slab.h>

#include "datagram.h"
#include "master.h"

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

#define EC_FUNC_HEADER \
    ret = ec_datagram_prealloc(datagram, data_size); \
    if (unlikely(ret)) \
        return ret; \
    datagram->index = 0; \
    datagram->working_counter = 0; \
    datagram->state = EC_DATAGRAM_INIT;

#define EC_FUNC_FOOTER \
    datagram->data_size = data_size; \
    return 0;

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

static const char *type_strings[] = {
    "?",
    "APRD",
    "APWR",
    "APRW",
    "FPRD",
    "FPWR",
    "FPRW",
    "BRD",
    "BWR",
    "BRW",
    "LRD",
    "LWR",
    "LRW",
    "ARMW",
    "FRMW"
};

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

void ec_datagram_init(ec_datagram_t *datagram )
{
    INIT_LIST_HEAD(&datagram->queue); // mark as unqueued
    datagram->device_index = EC_DEVICE_MAIN;
    datagram->type = EC_DATAGRAM_NONE;
    memset(datagram->address, 0x00, EC_ADDR_LEN);
    datagram->data = NULL;
    datagram->data_origin = EC_ORIG_INTERNAL;
    datagram->mem_size = 0;
    datagram->data_size = 0;
    datagram->index = 0x00;
    datagram->working_counter = 0x0000;
    datagram->state = EC_DATAGRAM_INIT;
#ifdef EC_HAVE_CYCLES
    datagram->cycles_sent = 0;
#endif
    datagram->jiffies_sent = 0;
    datagram->app_time_sent = 0;
#ifdef EC_HAVE_CYCLES
    datagram->cycles_received = 0;
#endif
    datagram->jiffies_received = 0;
    datagram->skip_count = 0;
    datagram->stats_output_jiffies = 0;
    memset(datagram->name, 0x00, EC_DATAGRAM_NAME_SIZE);
}

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

void ec_datagram_clear(ec_datagram_t *datagram )
{
    ec_datagram_unqueue(datagram);

    if (datagram->data_origin == EC_ORIG_INTERNAL && datagram->data) {
        kfree(datagram->data);
        datagram->data = NULL;
    }
}

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

void ec_datagram_unqueue(ec_datagram_t *datagram )
{
    if (!list_empty(&datagram->queue)) {
        list_del_init(&datagram->queue);
    }
}

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

int ec_datagram_prealloc(
        ec_datagram_t *datagram, 
        size_t size 
        )
{
    if (datagram->data_origin == EC_ORIG_EXTERNAL
            || size <= datagram->mem_size)
        return 0;

    if (datagram->data) {
        kfree(datagram->data);
        datagram->data = NULL;
        datagram->mem_size = 0;
    }

    if (!(datagram->data = kmalloc(size, GFP_KERNEL))) {
        EC_ERR("Failed to allocate %zu bytes of datagram memory!\n", size);
        return -ENOMEM;
    }

    datagram->mem_size = size;
    return 0;
}

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

void ec_datagram_zero(ec_datagram_t *datagram )
{
    memset(datagram->data, 0x00, datagram->data_size);
}

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

int ec_datagram_repeat(
        ec_datagram_t *datagram, 
        const ec_datagram_t *source )
{
    int ret;
    size_t data_size = source->data_size;
    EC_FUNC_HEADER;
    if (datagram != source) {
        datagram->type = source->type;
        memcpy(datagram->address, source->address, sizeof(datagram->address));
        memcpy(datagram->data, source->data, data_size);
    }
    EC_FUNC_FOOTER;
}

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

int ec_datagram_aprd(
        ec_datagram_t *datagram, 
        uint16_t ring_position, 
        uint16_t mem_address, 
        size_t data_size 
        )
{
    int ret;
    EC_FUNC_HEADER;
    datagram->type = EC_DATAGRAM_APRD;
    EC_WRITE_S16(datagram->address, (int16_t) ring_position * (-1));
    EC_WRITE_U16(datagram->address + 2, mem_address);
    EC_FUNC_FOOTER;
}

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

int ec_datagram_apwr(
        ec_datagram_t *datagram, 
        uint16_t ring_position, 
        uint16_t mem_address, 
        size_t data_size 
        )
{
    int ret;
    EC_FUNC_HEADER;
    datagram->type = EC_DATAGRAM_APWR;
    EC_WRITE_S16(datagram->address, (int16_t) ring_position * (-1));
    EC_WRITE_U16(datagram->address + 2, mem_address);
    EC_FUNC_FOOTER;
}

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

int ec_datagram_aprw(
        ec_datagram_t *datagram, 
        uint16_t ring_position, 
        uint16_t mem_address, 
        size_t data_size 
        )
{
    int ret;
    EC_FUNC_HEADER;
    datagram->type = EC_DATAGRAM_APRW;
    EC_WRITE_S16(datagram->address, (int16_t) ring_position * (-1));
    EC_WRITE_U16(datagram->address + 2, mem_address);
    EC_FUNC_FOOTER;
}

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

int ec_datagram_armw(
        ec_datagram_t *datagram, 
        uint16_t ring_position, 
        uint16_t mem_address, 
        size_t data_size 
        )
{
    int ret;
    EC_FUNC_HEADER;
    datagram->type = EC_DATAGRAM_ARMW;
    EC_WRITE_S16(datagram->address, (int16_t) ring_position * (-1));
    EC_WRITE_U16(datagram->address + 2, mem_address);
    EC_FUNC_FOOTER;
}

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

int ec_datagram_fprd(
        ec_datagram_t *datagram, 
        uint16_t configured_address, 
        uint16_t mem_address, 
        size_t data_size 
        )
{
    int ret;

    if (unlikely(configured_address == 0x0000))
        EC_WARN("Using configured station address 0x0000!\n");

    EC_FUNC_HEADER;
    datagram->type = EC_DATAGRAM_FPRD;
    EC_WRITE_U16(datagram->address, configured_address);
    EC_WRITE_U16(datagram->address + 2, mem_address);
    EC_FUNC_FOOTER;
}

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

int ec_datagram_fpwr(
        ec_datagram_t *datagram, 
        uint16_t configured_address, 
        uint16_t mem_address, 
        size_t data_size 
        )
{
    int ret;

    if (unlikely(configured_address == 0x0000))
        EC_WARN("Using configured station address 0x0000!\n");

    EC_FUNC_HEADER;
    datagram->type = EC_DATAGRAM_FPWR;
    EC_WRITE_U16(datagram->address, configured_address);
    EC_WRITE_U16(datagram->address + 2, mem_address);
    EC_FUNC_FOOTER;
}

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

int ec_datagram_fprw(
        ec_datagram_t *datagram, 
        uint16_t configured_address, 
        uint16_t mem_address, 
        size_t data_size 
        )
{
    int ret;

    if (unlikely(configured_address == 0x0000))
        EC_WARN("Using configured station address 0x0000!\n");

    EC_FUNC_HEADER;
    datagram->type = EC_DATAGRAM_FPRW;
    EC_WRITE_U16(datagram->address, configured_address);
    EC_WRITE_U16(datagram->address + 2, mem_address);
    EC_FUNC_FOOTER;
}

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

int ec_datagram_frmw(
        ec_datagram_t *datagram, 
        uint16_t configured_address, 
        uint16_t mem_address, 
        size_t data_size 
        )
{
    int ret;

    if (unlikely(configured_address == 0x0000))
        EC_WARN("Using configured station address 0x0000!\n");

    EC_FUNC_HEADER;
    datagram->type = EC_DATAGRAM_FRMW;
    EC_WRITE_U16(datagram->address, configured_address);
    EC_WRITE_U16(datagram->address + 2, mem_address);
    EC_FUNC_FOOTER;
}

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

int ec_datagram_brd(
        ec_datagram_t *datagram, 
        uint16_t mem_address, 
        size_t data_size 
        )
{
    int ret;
    EC_FUNC_HEADER;
    datagram->type = EC_DATAGRAM_BRD;
    EC_WRITE_U16(datagram->address, 0x0000);
    EC_WRITE_U16(datagram->address + 2, mem_address);
    EC_FUNC_FOOTER;
}

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

int ec_datagram_bwr(
        ec_datagram_t *datagram, 
        uint16_t mem_address, 
        size_t data_size 
        )
{
    int ret;
    EC_FUNC_HEADER;
    datagram->type = EC_DATAGRAM_BWR;
    EC_WRITE_U16(datagram->address, 0x0000);
    EC_WRITE_U16(datagram->address + 2, mem_address);
    EC_FUNC_FOOTER;
}

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

int ec_datagram_brw(
        ec_datagram_t *datagram, 
        uint16_t mem_address, 
        size_t data_size 
        )
{
    int ret;
    EC_FUNC_HEADER;
    datagram->type = EC_DATAGRAM_BRW;
    EC_WRITE_U16(datagram->address, 0x0000);
    EC_WRITE_U16(datagram->address + 2, mem_address);
    EC_FUNC_FOOTER;
}

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

int ec_datagram_lrd(
        ec_datagram_t *datagram, 
        uint32_t offset, 
        size_t data_size 
        )
{
    int ret;
    EC_FUNC_HEADER;
    datagram->type = EC_DATAGRAM_LRD;
    EC_WRITE_U32(datagram->address, offset);
    EC_FUNC_FOOTER;
}

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

int ec_datagram_lwr(
        ec_datagram_t *datagram, 
        uint32_t offset, 
        size_t data_size 
        )
{
    int ret;
    EC_FUNC_HEADER;
    datagram->type = EC_DATAGRAM_LWR;
    EC_WRITE_U32(datagram->address, offset);
    EC_FUNC_FOOTER;
}

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

int ec_datagram_lrw(
        ec_datagram_t *datagram, 
        uint32_t offset, 
        size_t data_size 
        )
{
    int ret;
    EC_FUNC_HEADER;
    datagram->type = EC_DATAGRAM_LRW;
    EC_WRITE_U32(datagram->address, offset);
    EC_FUNC_FOOTER;
}

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

int ec_datagram_lrd_ext(
        ec_datagram_t *datagram, 
        uint32_t offset, 
        size_t data_size, 
        uint8_t *external_memory 
        )
{
    int ret;
    datagram->data = external_memory;
    datagram->data_origin = EC_ORIG_EXTERNAL;
    EC_FUNC_HEADER;
    datagram->type = EC_DATAGRAM_LRD;
    EC_WRITE_U32(datagram->address, offset);
    EC_FUNC_FOOTER;
}

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

int ec_datagram_lwr_ext(
        ec_datagram_t *datagram, 
        uint32_t offset, 
        size_t data_size, 
        uint8_t *external_memory 
        )
{
    int ret;
    datagram->data = external_memory;
    datagram->data_origin = EC_ORIG_EXTERNAL;
    EC_FUNC_HEADER;
    datagram->type = EC_DATAGRAM_LWR;
    EC_WRITE_U32(datagram->address, offset);
    EC_FUNC_FOOTER;
}

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

int ec_datagram_lrw_ext(
        ec_datagram_t *datagram, 
        uint32_t offset, 
        size_t data_size, 
        uint8_t *external_memory 
        )
{
    int ret;
    datagram->data = external_memory;
    datagram->data_origin = EC_ORIG_EXTERNAL;
    EC_FUNC_HEADER;
    datagram->type = EC_DATAGRAM_LRW;
    EC_WRITE_U32(datagram->address, offset);
    EC_FUNC_FOOTER;
}

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

void ec_datagram_print_state(
        const ec_datagram_t *datagram 
        )
{
    printk(KERN_CONT "Datagram ");
    switch (datagram->state) {
        case EC_DATAGRAM_INIT:
            printk(KERN_CONT "initialized");
            break;
        case EC_DATAGRAM_QUEUED:
            printk(KERN_CONT "queued");
            break;
        case EC_DATAGRAM_SENT:
            printk(KERN_CONT "sent");
            break;
        case EC_DATAGRAM_RECEIVED:
            printk(KERN_CONT "received");
            break;
        case EC_DATAGRAM_TIMED_OUT:
            printk(KERN_CONT "timed out");
            break;
        case EC_DATAGRAM_ERROR:
            printk(KERN_CONT "error");
            break;
        case EC_DATAGRAM_INVALID:
            printk(KERN_CONT "invalid");
            break;
        default:
            printk(KERN_CONT "???");
    }

    printk(KERN_CONT ".\n");
}

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

void ec_datagram_print_wc_error(
        const ec_datagram_t *datagram 
        )
{
    if (datagram->working_counter == 0)
        printk(KERN_CONT "No response.");
    else if (datagram->working_counter > 1)
        printk(KERN_CONT "%u slaves responded!", datagram->working_counter);
    else
        printk(KERN_CONT "Success.");
    printk(KERN_CONT "\n");
}

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

void ec_datagram_output_stats(
        ec_datagram_t *datagram
        )
{
    if (jiffies - datagram->stats_output_jiffies > HZ) {
        datagram->stats_output_jiffies = jiffies;

        if (unlikely(datagram->skip_count)) {
            EC_WARN("Datagram %p (%s) was SKIPPED %u time%s.\n",
                    datagram, datagram->name,
                    datagram->skip_count,
                    datagram->skip_count == 1 ? "" : "s");
            datagram->skip_count = 0;
        }
    }
}

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

const char *ec_datagram_type_string(
        const ec_datagram_t *datagram 
        )
{
    return type_strings[datagram->type];
}

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

void ec_mbox_data_init(
        ec_mbox_data_t *mbox_data 
        )
{
    mbox_data->data = NULL;
    mbox_data->data_size = 0;
    mbox_data->payload_size = 0;
}


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

void ec_mbox_data_clear(
        ec_mbox_data_t *mbox_data 
        )
{
    if (mbox_data->data) {
        kfree(mbox_data->data);
        mbox_data->data = NULL;
        mbox_data->data_size = 0;
    }
}


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

int ec_mbox_data_prealloc(
        ec_mbox_data_t *mbox_data, 
        size_t size 
        )
{
    if (mbox_data->data) {
        kfree(mbox_data->data);
        mbox_data->data = NULL;
        mbox_data->data_size = 0;
    }

    if (!(mbox_data->data = kmalloc(size, GFP_KERNEL))) {
        EC_ERR("Failed to allocate %zu bytes of mailbox data memory!\n", size);
        return -ENOMEM;
    }
    mbox_data->data_size = size;
    return 0;
}


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

void ec_mbox_prot_data_prealloc(
        ec_slave_t *slave, 
        uint16_t protocols, 
        size_t size 
        )
{
    if ((size > 0) && (size <= EC_MAX_DATA_SIZE)) {
#ifdef EC_EOE
        if (protocols & EC_MBOX_EOE) {
            ec_mbox_data_prealloc(&slave->mbox_eoe_frag_data, size);
            ec_mbox_data_prealloc(&slave->mbox_eoe_init_data, size);
        } else {
            ec_mbox_data_clear(&slave->mbox_eoe_frag_data);
            ec_mbox_data_clear(&slave->mbox_eoe_init_data);
        }
#endif
        if (protocols & EC_MBOX_COE) {
            ec_mbox_data_prealloc(&slave->mbox_coe_data, size);
        } else {
            ec_mbox_data_clear(&slave->mbox_coe_data);
        }
        if (protocols & EC_MBOX_FOE) {
            ec_mbox_data_prealloc(&slave->mbox_foe_data, size);
        } else {
            ec_mbox_data_clear(&slave->mbox_foe_data);
        }
        if (protocols & EC_MBOX_SOE) {
            ec_mbox_data_prealloc(&slave->mbox_soe_data, size);
        } else {
            ec_mbox_data_clear(&slave->mbox_soe_data);
        }
        if (protocols & EC_MBOX_VOE) {
            ec_mbox_data_prealloc(&slave->mbox_voe_data, size);
        } else {
            ec_mbox_data_clear(&slave->mbox_voe_data);
        }
        
        // alloc mailbox gateway if slave supports any protocol
        if (protocols) {
            ec_mbox_data_prealloc(&slave->mbox_mbg_data, size);
        } else {
            ec_mbox_data_clear(&slave->mbox_mbg_data);
        }
    }
}

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