ethernet.cpp

Go to the documentation of this file.

 
#include <drivers/ethernet/ethernet.h>
 
using namespace MaxOS;
using namespace MaxOS::common;
using namespace MaxOS::drivers;
using namespace MaxOS::drivers::ethernet;
 
 
EthernetDriverEventHandler::EthernetDriverEventHandler() = default;
 
EthernetDriverEventHandler::~EthernetDriverEventHandler() = default;
 
bool EthernetDriverEventHandler::data_received(uint8_t* buffer, uint32_t size) {
    return false;
}
 
void EthernetDriverEventHandler::before_send(uint8_t* buffer, uint32_t size) {
}
 
void EthernetDriverEventHandler::data_sent(uint8_t* buffer, uint32_t size) {
}
 
Event<EthernetDriverEvents>* EthernetDriverEventHandler::on_event(Event<EthernetDriverEvents>* event) {
 
    switch (event->type) {
 
        case EthernetDriverEvents::BEFORE_SEND:
            before_send(((BeforeSendEvent*) event)->buffer, ((BeforeSendEvent*) event)->size);
            break;
 
        case EthernetDriverEvents::DATA_SENT:
            data_sent(((DataSentEvent*) event)->buffer, ((DataSentEvent*) event)->size);
            break;
 
        case EthernetDriverEvents::DATA_RECEIVED:
            event->return_value.bool_value = data_received(((DataReceivedEvent*) event)->buffer,
                                                           ((DataReceivedEvent*) event)->size);
            break;
 
        default:
            break;
    }
 
    return event;
}
 
EthernetDriver::EthernetDriver() = default;
EthernetDriver::~EthernetDriver() = default;
 
MediaAccessControlAddress EthernetDriver::get_media_access_control_address() {
    return 0;
}
 
void EthernetDriver::send(uint8_t* buffer, uint32_t size) {
 
    // Raise the event
    raise_event(new BeforeSendEvent(buffer, size));
 
    do_send(buffer, size);
}
 
void EthernetDriver::do_send(uint8_t* buffer, uint32_t size) {
}
 
void EthernetDriver::fire_data_received(uint8_t* buffer, uint32_t size) {
 
    // Raise the event
    Vector<Event<EthernetDriverEvents>*> values =
            raise_event(new DataReceivedEvent(buffer, size));
 
    // Loop through the events
    for (auto &value : values) {
        switch (value->type) {
            case EthernetDriverEvents::DATA_RECEIVED:
                if (value->return_value.bool_value)
                    send(buffer, size);
                break;
 
            default:
                break;
        }
    }
}
 
void EthernetDriver::fire_data_sent(uint8_t* buffer, uint32_t size) {
    raise_event(new DataSentEvent(buffer, size));
}
 
// if your mac address is e.g. 1c:6f:65:07:ad:1a (see output of ifconfig)
// then you would call CreateMediaAccessControlAddress(0x1c, 0x6f, 0x65, 0x07, 0xad, 0x1a)
MediaAccessControlAddress EthernetDriver::create_media_access_control_address(uint8_t digit1, uint8_t digit2, uint8_t digit3, uint8_t digit4, uint8_t digit5, uint8_t digit6) {
    return // digit6 is the most significant byte
            (uint64_t) digit6 << 40
            | (uint64_t) digit5 << 32
            | (uint64_t) digit4 << 24
            | (uint64_t) digit3 << 16
            | (uint64_t) digit2 << 8
            | (uint64_t) digit1;
}
 
DataSentEvent::DataSentEvent(uint8_t* buffer, uint32_t size)
        : Event(EthernetDriverEvents::DATA_SENT) {
    this->buffer = buffer;
    this->size = size;
    this->size = size;
}
 
DataSentEvent::~DataSentEvent() = default;
 
DataReceivedEvent::DataReceivedEvent(uint8_t* buffer, uint32_t size)
        : Event(EthernetDriverEvents::DATA_RECEIVED) {
    this->buffer = buffer;
    this->size = size;
}
 
DataReceivedEvent::~DataReceivedEvent()
= default;
 
BeforeSendEvent::BeforeSendEvent(uint8_t* buffer, uint32_t size)
        : Event(EthernetDriverEvents::BEFORE_SEND) {
    this->buffer = buffer;
    this->size = size;
}
 
BeforeSendEvent::~BeforeSendEvent()
= default;