183 lines
4.0 KiB
C++
183 lines
4.0 KiB
C++
/*
|
|
* \brief Freescale ethernet driver component
|
|
* \author Stefan Kalkowski
|
|
* \date 2017-11-01
|
|
*/
|
|
|
|
/*
|
|
* Copyright (C) 2017 Genode Labs GmbH
|
|
*
|
|
* This file is distributed under the terms of the GNU General Public License
|
|
* version 2.
|
|
*/
|
|
|
|
#include <component.h>
|
|
#include <lx_emul.h>
|
|
|
|
extern "C" {
|
|
#include <lxc.h>
|
|
};
|
|
|
|
void Session_component::_run_rx_task(void * args)
|
|
{
|
|
Rx_data *data = static_cast<Rx_data*>(args);
|
|
|
|
while (1) {
|
|
Lx::scheduler().current()->block_and_schedule();
|
|
|
|
int ret = 0;
|
|
struct napi_struct * n = data->napi;
|
|
|
|
for (;;) {
|
|
|
|
/* This NAPI_STATE_SCHED test is for avoiding a race
|
|
* with netpoll's poll_napi(). Only the entity which
|
|
* obtains the lock and sees NAPI_STATE_SCHED set will
|
|
* actually make the ->poll() call. Therefore we avoid
|
|
* accidentally calling ->poll() when NAPI is not scheduled.
|
|
*/
|
|
if (!test_bit(NAPI_STATE_SCHED, &n->state)) break;
|
|
|
|
int weight = n->weight;
|
|
int work = n->poll(n, weight);
|
|
ret += work;
|
|
|
|
if (work < weight) break;
|
|
|
|
Genode::warning("Too much incoming traffic, we should schedule RX more intelligent");
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void Session_component::_run_tx_task(void * args)
|
|
{
|
|
Tx_data *data = static_cast<Tx_data*>(args);
|
|
|
|
while (1) {
|
|
Lx::scheduler().current()->block_and_schedule();
|
|
|
|
net_device * ndev = data->ndev;
|
|
struct sk_buff * skb = data->skb;
|
|
|
|
ndev->netdev_ops->ndo_start_xmit(skb, ndev);
|
|
}
|
|
}
|
|
|
|
|
|
bool Session_component::_send()
|
|
{
|
|
using namespace Genode;
|
|
|
|
/*
|
|
* We must not be called from another task, just from the
|
|
* packet stream dispatcher.
|
|
*/
|
|
if (Lx::scheduler().active()) {
|
|
warning("scheduler active");
|
|
return false;
|
|
}
|
|
|
|
if (!_tx.sink()->ready_to_ack()) { return false; }
|
|
if (!_tx.sink()->packet_avail()) { return false; }
|
|
|
|
Packet_descriptor packet = _tx.sink()->get_packet();
|
|
if (!packet.size()) {
|
|
warning("invalid tx packet");
|
|
return true;
|
|
}
|
|
|
|
enum { HEAD_ROOM = 8 };
|
|
|
|
struct sk_buff *skb = lxc_alloc_skb(packet.size() + HEAD_ROOM, HEAD_ROOM);
|
|
|
|
unsigned char *data = lxc_skb_put(skb, packet.size());
|
|
Genode::memcpy(data, _tx.sink()->packet_content(packet), packet.size());
|
|
|
|
_tx_data.ndev = _ndev;
|
|
_tx_data.skb = skb;
|
|
|
|
_tx_task.unblock();
|
|
Lx::scheduler().schedule();
|
|
|
|
_tx.sink()->acknowledge_packet(packet);
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
void Session_component::_handle_rx()
|
|
{
|
|
while (_rx.source()->ack_avail())
|
|
_rx.source()->release_packet(_rx.source()->get_acked_packet());
|
|
}
|
|
|
|
|
|
void Session_component::_handle_packet_stream()
|
|
{
|
|
_handle_rx();
|
|
|
|
while (_send()) continue;
|
|
}
|
|
|
|
|
|
void Session_component::unblock_rx_task(napi_struct * n)
|
|
{
|
|
_rx_data.napi = n;
|
|
_rx_task.unblock();
|
|
}
|
|
|
|
|
|
Nic::Mac_address Session_component::mac_address()
|
|
{
|
|
return _ndev ? Nic::Mac_address(_ndev->dev_addr) : Nic::Mac_address();
|
|
}
|
|
|
|
|
|
void Session_component::receive(struct sk_buff *skb)
|
|
{
|
|
_handle_rx();
|
|
|
|
if (!_rx.source()->ready_to_submit()) {
|
|
Genode::warning("not ready to receive packet");
|
|
return;
|
|
}
|
|
|
|
Skb s = skb_helper(skb);
|
|
|
|
try {
|
|
Nic::Packet_descriptor p = _rx.source()->alloc_packet(s.packet_size + s.frag_size);
|
|
void *buffer = _rx.source()->packet_content(p);
|
|
memcpy(buffer, s.packet, s.packet_size);
|
|
|
|
if (s.frag_size)
|
|
memcpy((char *)buffer + s.packet_size, s.frag, s.frag_size);
|
|
|
|
_rx.source()->submit_packet(p);
|
|
} catch (...) {
|
|
Genode::warning("failed to process received packet");
|
|
}
|
|
}
|
|
|
|
|
|
void Session_component::link_state(bool link)
|
|
{
|
|
if (link == _has_link) return;
|
|
|
|
_has_link = link;
|
|
_link_state_changed();
|
|
}
|
|
|
|
|
|
Session_component::Session_component(Genode::size_t const tx_buf_size,
|
|
Genode::size_t const rx_buf_size,
|
|
Genode::Allocator & rx_block_md_alloc,
|
|
Genode::Env & env,
|
|
Genode::Session_label label)
|
|
: Nic::Session_component(tx_buf_size, rx_buf_size, rx_block_md_alloc, env),
|
|
_ndev(_register_session_component(*this, label)),
|
|
_has_link(_ndev ? !(_ndev->state & (1UL << __LINK_STATE_NOCARRIER)) : false)
|
|
{
|
|
if (!_ndev) throw Genode::Service_denied();
|
|
}
|