device.c

Go to the documentation of this file.

/******************************************************************************
 *
 *  $Id: device.c 426 2006-05-29 09:08:56Z fp $
 *
 *  Copyright (C) 2006  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
 *  as published by the Free Software Foundation; either version 2 of the
 *  License, or (at your option) any later version.
 *
 *  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 right to use EtherCAT Technology is granted and comes free of
 *  charge under condition of compatibility of product made by
 *  Licensee. People intending to distribute/sell products based on the
 *  code, have to sign an agreement to guarantee that products using
 *  software based on IgH EtherCAT master stay compatible with the actual
 *  EtherCAT specification (which are released themselves as an open
 *  standard) as the (only) precondition to have the right to use EtherCAT
 *  Technology, IP and trade marks.
 *
 *****************************************************************************/

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

#include <linux/module.h>
#include <linux/skbuff.h>
#include <linux/if_ether.h>
#include <linux/netdevice.h>
#include <linux/delay.h>

#include "device.h"
#include "master.h"

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

int ec_device_init(ec_device_t *device, 
                   ec_master_t *master, 
                   struct net_device *net_dev, 
                   ec_isr_t isr, 
                   struct module *module 
                   )
{
    struct ethhdr *eth;

    device->master = master;
    device->dev = net_dev;
    device->isr = isr;
    device->module = module;

    device->open = 0;
    device->link_state = 0; // down

    if (ec_debug_init(&device->dbg)) {
        EC_ERR("Failed to init debug device!\n");
        goto out_return;
    }

    if (!(device->tx_skb = dev_alloc_skb(ETH_FRAME_LEN))) {
        EC_ERR("Error allocating device socket buffer!\n");
        goto out_debug;
    }

    device->tx_skb->dev = net_dev;

    // add Ethernet-II-header
    skb_reserve(device->tx_skb, ETH_HLEN);
    eth = (struct ethhdr *) skb_push(device->tx_skb, ETH_HLEN);
    eth->h_proto = htons(0x88A4);
    memcpy(eth->h_source, net_dev->dev_addr, net_dev->addr_len);
    memset(eth->h_dest, 0xFF, net_dev->addr_len);

    return 0;

 out_debug:
    ec_debug_clear(&device->dbg);
 out_return:
    return -1;
}

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

void ec_device_clear(ec_device_t *device )
{
    if (device->open) ec_device_close(device);
    if (device->tx_skb) dev_kfree_skb(device->tx_skb);
    ec_debug_clear(&device->dbg);
}

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

int ec_device_open(ec_device_t *device )
{
    unsigned int i;

    if (!device->dev) {
        EC_ERR("No net_device to open!\n");
        return -1;
    }

    if (device->open) {
        EC_WARN("Device already opened!\n");
        return 0;
    }

    // device could have received frames before
    for (i = 0; i < 4; i++) ec_device_call_isr(device);

    device->link_state = 0;

    if (device->dev->open(device->dev) == 0) device->open = 1;

    return device->open ? 0 : -1;
}

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

int ec_device_close(ec_device_t *device )
{
    if (!device->dev) {
        EC_ERR("No device to close!\n");
        return -1;
    }

    if (!device->open) {
        EC_WARN("Device already closed!\n");
        return 0;
    }

    if (device->dev->stop(device->dev) == 0) device->open = 0;

    return !device->open ? 0 : -1;
}

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

uint8_t *ec_device_tx_data(ec_device_t *device )
{
    return device->tx_skb->data + ETH_HLEN;
}

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

void ec_device_send(ec_device_t *device, 
                    size_t size 
                    )
{
    if (unlikely(!device->link_state)) // Link down
        return;

    // set the right length for the data
    device->tx_skb->len = ETH_HLEN + size;

    if (unlikely(device->master->debug_level > 1)) {
        EC_DBG("sending frame:\n");
        ec_print_data(device->tx_skb->data + ETH_HLEN, size);
    }

    ec_debug_send(&device->dbg, device->tx_skb->data, ETH_HLEN + size);

    // start sending
    device->dev->hard_start_xmit(device->tx_skb, device->dev);
}

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

void ec_device_call_isr(ec_device_t *device )
{
    if (likely(device->isr)) device->isr(0, device->dev, NULL);
}

/******************************************************************************
 *  Device interface
 *****************************************************************************/

void ecdev_receive(ec_device_t *device, 
                   const void *data, 
                   size_t size 
                   )
{
    if (unlikely(device->master->debug_level > 1)) {
        EC_DBG("Received frame:\n");
        ec_print_data_diff(device->tx_skb->data + ETH_HLEN,
                           data + ETH_HLEN, size - ETH_HLEN);
    }

    ec_debug_send(&device->dbg, data, size);

    ec_master_receive(device->master, data + ETH_HLEN, size - ETH_HLEN);
}

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

void ecdev_link_state(ec_device_t *device, 
                      uint8_t state 
                      )
{
    if (unlikely(!device)) {
        EC_WARN("ecdev_link_state: no device!\n");
        return;
    }

    if (likely(state != device->link_state)) {
        device->link_state = state;
        EC_INFO("Link state changed to %s.\n", (state ? "UP" : "DOWN"));
    }
}

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

EXPORT_SYMBOL(ecdev_receive);
EXPORT_SYMBOL(ecdev_link_state);

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

---