Net.cpp

//------------------------------------------------------------------------------
//This file is part of embKernel. 
//See license.txt for the full license governing this code.
//------------------------------------------------------------------------------

#include "Net.hpp"
#include "NetIp.hpp"
#include "NetArp.hpp"
#include "NetMacros.hpp"
#include "NetClientDhcp.hpp"
#include "NetTcp.hpp"

RtosSemaphore Net::sSemaEvent(255, 0);
RtosSemaphore Net::sSemaMemory(1, 1);
RtosTask* Net::sTask;
NetMac* Net::sMac;
LibDmem* Net::sMem;
NetDefs::MAC_ADDR Net::sMacAddr;
NetDefs::NET_CONFIG Net::sConfig;
Rtos::TICK Net::sTickTimerArp;
Rtos::TICK Net::sTickTimerTcp;
Rtos::TICK Net::sTickTimerClientDhcp;

void Net::init(Rtos::PRIORITY priority, size_t stackSize, NetMac* mac, LibDmem* mem) {
    sTask = new RtosTask(priority, "NET", stackSize, run);
    sMac = mac;
    sMem = mem;
}

void Net::run(RtosTask*) {
    loadMac(sMacAddr);
    loadConfig(sConfig);
    sMac->start(sMacAddr);

    sTickTimerTcp = Rtos::getTick();
    sTickTimerArp = sTickTimerTcp + Rtos::convertMsToTick(5);
    sTickTimerClientDhcp = sTickTimerArp + Rtos::convertMsToTick(500);

    while (true) {
        if (sSemaEvent.take(Rtos::convertMsToTick(5))) {
            //Clean up sent buffers
                sMac->freeSentFrames();
                //Get rx buffer if any
                NetDefs::FRAME* frame = sMac->getFrame();

                if (frame) {
                    switch (frame->types.mac.macHeader.type) {
                        case NetDefs::MAC_TYPE_ARP:
                        NetArp::processFrame(*frame, frame->types.arp.arpHeader);
                        break;
                        case NetDefs::MAC_TYPE_IP:
                        NetIp::processFrame(*frame, frame->types.ip.ipHeader);
                        break;
                        default:
                        freeFrame(*frame);
                        break;
                    }
                }
            }

            if (Rtos::isElapsed(sTickTimerTcp)) {
                sTickTimerTcp += Rtos::convertMsToTick(10);
                NetTcp::tick();
            }
            else if (Rtos::isElapsed(sTickTimerArp)) {
                sTickTimerArp += Rtos::convertMsToTick(100);
                NetArp::tick();
            }
#if NET_CFG_USE_DHCP_CLIENT
                else if (Rtos::isElapsed(sTickTimerClientDhcp)) {
                    sTickTimerClientDhcp += Rtos::convertMsToTick(1000);
                    NetClientDhcp::tick();
                }
#endif

            }
        }

NetDefs::FRAME* Net::allocFrame(size_t size) {
    sSemaMemory.take(Rtos::TICK_INFINITE);
    NetDefs::FRAME* frame = (NetDefs::FRAME*) sMem->alloc(size);
    sSemaMemory.give(Rtos::TICK_INFINITE);
    return frame;
}

void Net::freeFrame(NetDefs::FRAME& frame) {
    sSemaMemory.take(Rtos::TICK_INFINITE);
    sMem->free(&frame);
    sSemaMemory.give(Rtos::TICK_INFINITE);
}

void* Net::resizeFrame(NetDefs::FRAME& frame, size_t size) {
    sSemaMemory.take(Rtos::TICK_INFINITE);
    void* result = sMem->resize(&frame, size);
    sSemaMemory.give(Rtos::TICK_INFINITE);
    return result;
}

void* Net::resizeFrameLeft(NetDefs::FRAME& frame, size_t left) {
    sSemaMemory.take(Rtos::TICK_INFINITE);
    void* result = sMem->resizeLeft(&frame, left);
    sSemaMemory.give(Rtos::TICK_INFINITE);
    return result;
}

void Net::putHeader(NetDefs::FRAME& frame, const NetDefs::MAC_ADDR& dst, NetDefs::MAC_TYPE type) {
    sMac->putHeader(frame, dst, type);
}

void Net::flush(NetDefs::FRAME& frame, size_t len, bool discardable) {
    sMac->flush(frame, len, discardable);
}

NetDefs::NET_CONFIG& Net::getConfig() {
    return sConfig;
}

size_t Net::getTotalMemory() {
    return sMem->getTotalMemory();
}

size_t Net::getFreeMemory() {
    return sMem->getFreeMemory();
}

unsigned int Net::getBlockCount() {
    return sMem->getBlockCount();
}

bool Net::onMacEventInterrupt() {
    return sSemaEvent.giveFromInt();
}