static int lo_txpoll(FAR struct net_driver_s *dev)
{
FAR struct lo_driver_s *priv = (FAR struct lo_driver_s *)dev->d_private;
/* Loop while there is data "sent", i.e., while d_len > 0. That should be
* the case upon entry here and while the processing of the IPv4/6 packet
* generates a new packet to be sent. Sending, of course, just means
* relaying back through the network for this driver.
*/
while (priv->lo_dev.d_len > 0)
{
NETDEV_TXPACKETS(&priv->lo_dev);
NETDEV_RXPACKETS(&priv->lo_dev);
#ifdef CONFIG_NET_PKT
/* When packet sockets are enabled, feed the frame into the packet tap */
pkt_input(&priv->lo_dev);
#endif
/* We only accept IP packets of the configured type and ARP packets */
#ifdef CONFIG_NET_IPv4
if ((IPv4BUF->vhl & IP_VERSION_MASK) == IPv4_VERSION)
{
nllvdbg("IPv4 frame\n");
NETDEV_RXIPV4(&priv->lo_dev);
ipv4_input(&priv->lo_dev);
}
else
#endif
#ifdef CONFIG_NET_IPv6
if ((IPv6BUF->vtc & IP_VERSION_MASK) == IPv6_VERSION)
{
nllvdbg("Iv6 frame\n");
NETDEV_RXIPV6(&priv->lo_dev);
ipv6_input(&priv->lo_dev);
}
else
#endif
{
ndbg("WARNING: Unrecognized packet type dropped: %02x\n", IPv4BUF->vhl);
NETDEV_RXDROPPED(&priv->lo_dev);
priv->lo_dev.d_len = 0;
}
priv->lo_txdone = true;
NETDEV_TXDONE(&priv->lo_dev);
}
return 0;
}
static int bcmf_transmit(FAR struct bcmf_dev_s *priv,
struct bcmf_frame_s *frame)
{
int ret;
frame->len = priv->bc_dev.d_len +
(unsigned int)(frame->data - frame->base);
ret = bcmf_bdc_transmit_frame(priv, frame);
if (ret)
{
wlerr("ERROR: Failed to transmit frame\n");
return -EIO;
}
NETDEV_TXPACKETS(priv->bc_dev);
return OK;
}
static int skel_transmit(FAR struct skel_driver_s *priv)
{
/* Verify that the hardware is ready to send another packet. If we get
* here, then we are committed to sending a packet; Higher level logic
* must have assured that there is no transmission in progress.
*/
/* Increment statistics */
NETDEV_TXPACKETS(priv->sk_dev);
/* Send the packet: address=priv->sk_dev.d_buf, length=priv->sk_dev.d_len */
/* Enable Tx interrupts */
/* Setup the TX timeout watchdog (perhaps restarting the timer) */
(void)wd_start(priv->sk_txtimeout, skeleton_TXTIMEOUT,
skel_txtimeout_expiry, 1, (wdparm_t)priv);
return OK;
}
static int slip_transmit(FAR struct slip_driver_s *priv)
{
uint8_t *src;
uint8_t *start;
uint8_t esc;
int remaining;
int len;
/* Increment statistics */
ninfo("Sending packet size %d\n", priv->dev.d_len);
NETDEV_TXPACKETS(&priv->dev);
/* Send an initial END character to flush out any data that may have
* accumulated in the receiver due to line noise
*/
slip_putc(priv, SLIP_END);
/* For each byte in the packet, send the appropriate character sequence */
src = priv->dev.d_buf;
remaining = priv->dev.d_len;
start = src;
len = 0;
while (remaining-- > 0)
{
switch (*src)
{
/* If it's the same code as an END character, we send a special two
* character code so as not to make the receiver think we sent an
* END
*/
case SLIP_END:
esc = SLIP_ESC_END;
goto escape;
/* If it's the same code as an ESC character, we send a special two
* character code so as not to make the receiver think we sent an
* ESC
*/
case SLIP_ESC:
esc = SLIP_ESC_ESC;
escape:
{
/* Flush any unsent data */
if (len > 0)
{
slip_write(priv, start, len);
}
/* Reset */
start = src + 1;
len = 0;
/* Then send the escape sequence */
slip_putc(priv, SLIP_ESC);
slip_putc(priv, esc);
}
break;
/* otherwise, just bump up the count */
default:
len++;
break;
}
/* Point to the next character in the packet */
src++;
}
/* We have looked at every character in the packet. Now flush any unsent
* data
*/
if (len > 0)
{
slip_write(priv, start, len);
}
/* And send the END token */
slip_putc(priv, SLIP_END);
NETDEV_TXDONE(&priv->dev);
priv->txnodelay = true;
return OK;
}
static int misoc_net_transmit(FAR struct misoc_net_driver_s *priv)
{
/* Verify that the hardware is ready to send another packet. If we get
* here, then we are committed to sending a packet; Higher level logic
* must have assured that there is no transmission in progress.
*/
/* Increment statistics */
NETDEV_TXPACKETS(priv->misoc_net_dev);
/* Send the packet: address=priv->misoc_net_dev.d_buf,
* length=priv->misoc_net_dev.d_len
*
* NOTE: This memcpy could be avoided by setting tx_buf
* to the d_buf pointer and setting d_buf to an alternate
* buffer. Some additional buffer management logic would
* be required.
*/
memcpy(priv->tx_buf, priv->misoc_net_dev.d_buf,
priv->misoc_net_dev.d_len);
/* Choose the slot on which we write */
ethmac_sram_reader_slot_write(priv->tx_slot);
/* Write the len */
if (priv->misoc_net_dev.d_len < 60)
{
ethmac_sram_reader_length_write(60);
}
else
{
ethmac_sram_reader_length_write(priv->misoc_net_dev.d_len);
}
/* Trigger the writing */
ethmac_sram_reader_start_write(1);
/* switch tx slot */
priv->tx_slot = (priv->tx_slot+1)%2;
if (priv->tx_slot)
{
priv->tx_buf = priv->tx1_buf;
}
else
{
priv->tx_buf = priv->tx0_buf;
}
/* Enable Tx interrupts */
ethmac_sram_reader_ev_enable_write(1);
/* Setup the TX timeout watchdog (perhaps restarting the timer) */
(void)wd_start(priv->misoc_net_txtimeout, MISOC_NET_TXTIMEOUT,
misoc_net_txtimeout_expiry, 1, (wdparm_t)priv);
return OK;
}