ethernet.h

Go to the documentation of this file.

/* This file is part of rflpc. Copyright 2010-2011 Michael Hauspie
 *
 * rflpc 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 3 of the License, or
 * (at your option) any later version.
 *
 * rflpc 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 rflpc.  If not, see <http://www.gnu.org/licenses/>.
 */
#ifndef __RFLPC_ETHERNET_H__
#define __RFLPC_ETHERNET_H__



#ifdef RFLPC_CONFIG_ENABLE_ETHERNET

/*
  Author: Michael Hauspie <Michael.Hauspie@univ-lille1.fr>
  Created: Jun. 28 2011
  Time-stamp: <2014-02-14 17:09:46 (hauspie)>
*/
#include <stdint.h>
#include "../nxp/LPC17xx.h"
#include "../interrupt.h"
#include "eth_const.h"
extern int rflpc_eth_init();

extern int rflpc_eth_link_state();


#define RFLPC_ETH_LINK_MODE_SPEED_BIT   (1 << 0)

#define RFLPC_ETH_LINK_MODE_DUPLEX_BIT  (1 << 1)

#define RFLPC_ETH_LINK_MODE_100HD (RFLPC_ETH_LINK_MODE_SPEED_BIT)

#define RFLPC_ETH_LINK_MODE_10HD  (0)

#define RFLPC_ETH_LINK_MODE_100FD (RFLPC_ETH_LINK_MODE_SPEED_BIT | RFLPC_ETH_LINK_MODE_DUPLEX_BIT)

#define RFLPC_ETH_LINK_MODE_10FD  (RFLPC_ETH_LINK_MODE_DUPLEX_BIT)

extern void rflpc_eth_set_link_mode(int mode);

extern int rflpc_eth_link_auto_negociate(int max_desired_mode);

extern int rflpc_eth_get_link_mode();


typedef struct
{
    uint8_t *packet;        
    volatile uint32_t control;
} rflpc_eth_descriptor_t;

typedef struct
{
    volatile uint32_t status_info;
    volatile uint32_t status_hash_crc;
} rflpc_eth_rx_status_t;


typedef struct
{
   volatile uint32_t status_info;
} rflpc_eth_tx_status_t;


static inline uint32_t rflpc_eth_get_packet_size(uint32_t status_info)
{
    return (status_info & 0x7FF) + 1;
}

static inline void rflpc_eth_set_tx_control_word(uint32_t size_to_send, volatile uint32_t *control, int trigger_it, int last_fragment)
{
    *control = ((size_to_send-1) & 0x7FF) | ((last_fragment & 1) << 30) | ((trigger_it & 1) << 31) | 
    (1 << 26) | /* Override MAC defaults for pad, crc and last */
    (1 << 28) | /* Pads small frames to 64 bytes */
    (1 << 29); /* Appends a CRC to the frame */
}

extern void rflpc_eth_set_rx_base_addresses(rflpc_eth_descriptor_t *descriptors, rflpc_eth_rx_status_t *status, int count);

static inline int rflpc_eth_get_current_rx_packet_descriptor(rflpc_eth_descriptor_t **descriptor, rflpc_eth_rx_status_t **status)
{
    if (LPC_EMAC->RxConsumeIndex == LPC_EMAC->RxProduceIndex) /* empty queue */
    return 0;
    *descriptor = ((rflpc_eth_descriptor_t*)LPC_EMAC->RxDescriptor) + LPC_EMAC->RxConsumeIndex;
    *status = ((rflpc_eth_rx_status_t*)LPC_EMAC->RxStatus) + LPC_EMAC->RxConsumeIndex;
    return 1;
}

static inline int rflpc_eth_rx_available()
{
    if (LPC_EMAC->RxConsumeIndex == LPC_EMAC->RxProduceIndex) /* empty queue */
    return 0;
    return 1;
}


static inline void rflpc_eth_done_process_rx_packet()
{
    if (LPC_EMAC->RxConsumeIndex == LPC_EMAC->RxProduceIndex) /* Queue is empty */
    return;
    if (LPC_EMAC->RxConsumeIndex == LPC_EMAC->RxDescriptorNumber) /* Wrap around */
    LPC_EMAC->RxConsumeIndex = 0;
    else
    LPC_EMAC->RxConsumeIndex++;
}


extern void rflpc_eth_set_tx_base_addresses(rflpc_eth_descriptor_t *descriptos, rflpc_eth_tx_status_t *status, int count);

#define TX_PRODUCE_INDEX_INC(inc) ((LPC_EMAC->TxProduceIndex + (inc))% (LPC_EMAC->TxDescriptorNumber+1))

static inline int rflpc_eth_get_current_tx_packet_descriptor(rflpc_eth_descriptor_t **descriptor, rflpc_eth_tx_status_t **status, int idx)
{
    /* queue full */
    if (TX_PRODUCE_INDEX_INC(idx) == LPC_EMAC->TxConsumeIndex - 1 ||
    ((TX_PRODUCE_INDEX_INC(idx) == LPC_EMAC->TxDescriptorNumber) && LPC_EMAC->TxConsumeIndex == 0))
    {
    return 0;
    }
    *descriptor = ((rflpc_eth_descriptor_t*)LPC_EMAC->TxDescriptor) + TX_PRODUCE_INDEX_INC(idx);
    *status = ((rflpc_eth_tx_status_t*)LPC_EMAC->TxStatus) + TX_PRODUCE_INDEX_INC(idx);
    return 1;
}

static inline int rflpc_eth_get_last_sent_packet_idx()
{
    int idx = LPC_EMAC->TxConsumeIndex - 1;
    if (idx < 0)
    return LPC_EMAC->TxDescriptorNumber;
    return idx;
}

static inline void rflpc_eth_done_process_tx_packet(int count)
{
    /* queue full */
    if (TX_PRODUCE_INDEX_INC(count-1) == LPC_EMAC->TxConsumeIndex - 1 ||
    ((TX_PRODUCE_INDEX_INC(count-1) == LPC_EMAC->TxDescriptorNumber) && LPC_EMAC->TxConsumeIndex == 0))
    {
    return;
    }
    LPC_EMAC->TxProduceIndex = TX_PRODUCE_INDEX_INC(count);
}

extern void rflpc_eth_get_mac_address(uint8_t *addr);

extern void rflpc_eth_set_mac_address(const uint8_t *addr);

static inline void rflpc_eth_set_irq_handler(rflpc_irq_handler_t c)
{
    rflpc_irq_disable(ENET_IRQn);
    rflpc_irq_set_handler(ENET_IRQn, c);
    rflpc_irq_enable(ENET_IRQn);
}

static inline void rflpc_eth_irq_enable(uint32_t irqs)
{
    LPC_EMAC->IntEnable |= irqs;
}

static inline void rflpc_eth_irq_disable(uint32_t irqs)
{
    LPC_EMAC->IntEnable &= ~irqs;
}

static inline void rflpc_eth_irq_enable_set(uint32_t irqs)
{
    LPC_EMAC->IntEnable = irqs;
}

static inline void rflpc_eth_irq_clear(uint32_t irqs)
{
    LPC_EMAC->IntClear = irqs;
}

static inline uint32_t rflpc_eth_irq_get_status()
{
    return LPC_EMAC->IntStatus;
}

static inline void rflpc_eth_irq_trigger(uint32_t irqs)
{
    LPC_EMAC->IntSet = irqs;
}

static inline void rflpc_eth_activate_rx_filter(int accept_unicast, int accept_multicast, int accept_broadcast)
{
    LPC_EMAC->RxFilterCtrl = 0;
    if (accept_unicast)
       LPC_EMAC->RxFilterCtrl |= RFLPC_ETH_RXFILTER_UNICAST_EN;
    if (accept_multicast)
    LPC_EMAC->RxFilterCtrl |= RFLPC_ETH_RXFILTER_MULTICAST_EN;
    if (accept_broadcast)
    LPC_EMAC->RxFilterCtrl |= RFLPC_ETH_RXFILTER_BROADCAST_EN;
    LPC_EMAC->RxFilterCtrl |= RFLPC_ETH_RXFILTER_PERFECT_EN;
    /* activate filter */
    LPC_EMAC->Command &= ~RFLPC_ETH_CMD_PASS_RX_FILTER;
}
static inline void rflpc_eth_deactivate_rx_filter()
{
    LPC_EMAC->Command |= RFLPC_ETH_CMD_PASS_RX_FILTER;
}

extern void rflpc_eth_dump_internals();


#endif /* ENABLE_ETHERNET */

#endif