Release 4.8 net/irda/irlan/irlan_eth.c
/*********************************************************************
*
* Filename: irlan_eth.c
* Version:
* Description:
* Status: Experimental.
* Author: Dag Brattli <dagb@cs.uit.no>
* Created at: Thu Oct 15 08:37:58 1998
* Modified at: Tue Mar 21 09:06:41 2000
* Modified by: Dag Brattli <dagb@cs.uit.no>
* Sources: skeleton.c by Donald Becker <becker@CESDIS.gsfc.nasa.gov>
* slip.c by Laurence Culhane, <loz@holmes.demon.co.uk>
* Fred N. van Kempen, <waltje@uwalt.nl.mugnet.org>
*
* Copyright (c) 1998-2000 Dag Brattli, All Rights Reserved.
*
* This program 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 2 of
* the License, or (at your option) any later version.
*
* Neither Dag Brattli nor University of Tromsø admit liability nor
* provide warranty for any of this software. This material is
* provided "AS-IS" and at no charge.
*
********************************************************************/
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/inetdevice.h>
#include <linux/if_arp.h>
#include <linux/module.h>
#include <linux/sched.h>
#include <net/arp.h>
#include <net/irda/irda.h>
#include <net/irda/irmod.h>
#include <net/irda/irlan_common.h>
#include <net/irda/irlan_client.h>
#include <net/irda/irlan_event.h>
#include <net/irda/irlan_eth.h>
static int irlan_eth_open(struct net_device *dev);
static int irlan_eth_close(struct net_device *dev);
static netdev_tx_t irlan_eth_xmit(struct sk_buff *skb,
struct net_device *dev);
static void irlan_eth_set_multicast_list(struct net_device *dev);
static const struct net_device_ops irlan_eth_netdev_ops = {
.ndo_open = irlan_eth_open,
.ndo_stop = irlan_eth_close,
.ndo_start_xmit = irlan_eth_xmit,
.ndo_set_rx_mode = irlan_eth_set_multicast_list,
.ndo_change_mtu = eth_change_mtu,
.ndo_validate_addr = eth_validate_addr,
};
/*
* Function irlan_eth_setup (dev)
*
* The network device initialization function.
*
*/
static void irlan_eth_setup(struct net_device *dev)
{
ether_setup(dev);
dev->netdev_ops = &irlan_eth_netdev_ops;
dev->destructor = free_netdev;
/*
* Lets do all queueing in IrTTP instead of this device driver.
* Queueing here as well can introduce some strange latency
* problems, which we will avoid by setting the queue size to 0.
*/
/*
* The bugs in IrTTP and IrLAN that created this latency issue
* have now been fixed, and we can propagate flow control properly
* to the network layer. However, this requires a minimal queue of
* packets for the device.
* Without flow control, the Tx Queue is 14 (ttp) + 0 (dev) = 14
* With flow control, the Tx Queue is 7 (ttp) + 4 (dev) = 11
* See irlan_eth_flow_indication()...
* Note : this number was randomly selected and would need to
* be adjusted.
* Jean II */
dev->tx_queue_len = 4;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
pre-git | pre-git | 18 | 48.65% | 2 | 28.57% |
stephen hemminger | stephen hemminger | 13 | 35.14% | 2 | 28.57% |
jean tourrilhes | jean tourrilhes | 4 | 10.81% | 1 | 14.29% |
hideaki yoshifuji | hideaki yoshifuji | 1 | 2.70% | 1 | 14.29% |
al viro | al viro | 1 | 2.70% | 1 | 14.29% |
| Total | 37 | 100.00% | 7 | 100.00% |
/*
* Function alloc_irlandev
*
* Allocate network device and control block
*
*/
struct net_device *alloc_irlandev(const char *name)
{
return alloc_netdev(sizeof(struct irlan_cb), name, NET_NAME_UNKNOWN,
irlan_eth_setup);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
jean tourrilhes | jean tourrilhes | 20 | 71.43% | 1 | 25.00% |
pre-git | pre-git | 6 | 21.43% | 2 | 50.00% |
tom gundersen | tom gundersen | 2 | 7.14% | 1 | 25.00% |
| Total | 28 | 100.00% | 4 | 100.00% |
/*
* Function irlan_eth_open (dev)
*
* Network device has been opened by user
*
*/
static int irlan_eth_open(struct net_device *dev)
{
struct irlan_cb *self = netdev_priv(dev);
/* Ready to play! */
netif_stop_queue(dev); /* Wait until data link is ready */
/* We are now open, so time to do some work */
self->disconnect_reason = 0;
irlan_client_wakeup(self, self->saddr, self->daddr);
/* Make sure we have a hardware address before we return,
so DHCP clients gets happy */
return wait_event_interruptible(self->open_wait,
!self->tsap_data->connected);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
pre-git | pre-git | 48 | 75.00% | 3 | 50.00% |
jean tourrilhes | jean tourrilhes | 15 | 23.44% | 2 | 33.33% |
hideaki yoshifuji | hideaki yoshifuji | 1 | 1.56% | 1 | 16.67% |
| Total | 64 | 100.00% | 6 | 100.00% |
/*
* Function irlan_eth_close (dev)
*
* Stop the ether network device, his function will usually be called by
* ifconfig down. We should now disconnect the link, We start the
* close timer, so that the instance will be removed if we are unable
* to discover the remote device after the disconnect.
*/
static int irlan_eth_close(struct net_device *dev)
{
struct irlan_cb *self = netdev_priv(dev);
/* Stop device */
netif_stop_queue(dev);
irlan_close_data_channel(self);
irlan_close_tsaps(self);
irlan_do_client_event(self, IRLAN_LMP_DISCONNECT, NULL);
irlan_do_provider_event(self, IRLAN_LMP_DISCONNECT, NULL);
/* Remove frames queued on the control channel */
skb_queue_purge(&self->client.txq);
self->client.tx_busy = 0;
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
pre-git | pre-git | 72 | 93.51% | 4 | 80.00% |
jean tourrilhes | jean tourrilhes | 5 | 6.49% | 1 | 20.00% |
| Total | 77 | 100.00% | 5 | 100.00% |
/*
* Function irlan_eth_tx (skb)
*
* Transmits ethernet frames over IrDA link.
*
*/
static netdev_tx_t irlan_eth_xmit(struct sk_buff *skb,
struct net_device *dev)
{
struct irlan_cb *self = netdev_priv(dev);
int ret;
unsigned int len;
/* skb headroom large enough to contain all IrDA-headers? */
if ((skb_headroom(skb) < self->max_header_size) || (skb_shared(skb))) {
struct sk_buff *new_skb =
skb_realloc_headroom(skb, self->max_header_size);
/* We have to free the original skb anyway */
dev_kfree_skb(skb);
/* Did the realloc succeed? */
if (new_skb == NULL)
return NETDEV_TX_OK;
/* Use the new skb instead */
skb = new_skb;
}
netif_trans_update(dev);
len = skb->len;
/* Now queue the packet in the transport layer */
if (self->use_udata)
ret = irttp_udata_request(self->tsap_data, skb);
else
ret = irttp_data_request(self->tsap_data, skb);
if (ret < 0) {
/*
* IrTTPs tx queue is full, so we just have to
* drop the frame! You might think that we should
* just return -1 and don't deallocate the frame,
* but that is dangerous since it's possible that
* we have replaced the original skb with a new
* one with larger headroom, and that would really
* confuse do_dev_queue_xmit() in dev.c! I have
* tried :-) DB
*/
/* irttp_data_request already free the packet */
dev->stats.tx_dropped++;
} else {
dev->stats.tx_packets++;
dev->stats.tx_bytes += len;
}
return NETDEV_TX_OK;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
pre-git | pre-git | 143 | 84.12% | 5 | 38.46% |
eric dumazet | eric dumazet | 13 | 7.65% | 2 | 15.38% |
jean tourrilhes | jean tourrilhes | 7 | 4.12% | 2 | 15.38% |
florian westphal | florian westphal | 3 | 1.76% | 1 | 7.69% |
patrick mchardy | patrick mchardy | 2 | 1.18% | 1 | 7.69% |
hideaki yoshifuji | hideaki yoshifuji | 1 | 0.59% | 1 | 7.69% |
stephen hemminger | stephen hemminger | 1 | 0.59% | 1 | 7.69% |
| Total | 170 | 100.00% | 13 | 100.00% |
/*
* Function irlan_eth_receive (handle, skb)
*
* This function gets the data that is received on the data channel
*
*/
int irlan_eth_receive(void *instance, void *sap, struct sk_buff *skb)
{
struct irlan_cb *self = instance;
struct net_device *dev = self->dev;
if (skb == NULL) {
dev->stats.rx_dropped++;
return 0;
}
if (skb->len < ETH_HLEN) {
pr_debug("%s() : IrLAN frame too short (%d)\n",
__func__, skb->len);
dev->stats.rx_dropped++;
dev_kfree_skb(skb);
return 0;
}
/*
* Adopt this frame! Important to set all these fields since they
* might have been previously set by the low level IrDA network
* device driver
*/
skb->protocol = eth_type_trans(skb, dev); /* Remove eth header */
dev->stats.rx_packets++;
dev->stats.rx_bytes += skb->len;
netif_rx(skb); /* Eat it! */
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
pre-git | pre-git | 77 | 60.63% | 4 | 40.00% |
jean tourrilhes | jean tourrilhes | 32 | 25.20% | 2 | 20.00% |
eric dumazet | eric dumazet | 15 | 11.81% | 1 | 10.00% |
hideaki yoshifuji | hideaki yoshifuji | 1 | 0.79% | 1 | 10.00% |
joe perches | joe perches | 1 | 0.79% | 1 | 10.00% |
harvey harrison | harvey harrison | 1 | 0.79% | 1 | 10.00% |
| Total | 127 | 100.00% | 10 | 100.00% |
/*
* Function irlan_eth_flow (status)
*
* Do flow control between IP/Ethernet and IrLAN/IrTTP. This is done by
* controlling the queue stop/start.
*
* The IrDA link layer has the advantage to have flow control, and
* IrTTP now properly handles that. Flow controlling the higher layers
* prevent us to drop Tx packets in here (up to 15% for a TCP socket,
* more for UDP socket).
* Also, this allow us to reduce the overall transmit queue, which means
* less latency in case of mixed traffic.
* Jean II
*/
void irlan_eth_flow_indication(void *instance, void *sap, LOCAL_FLOW flow)
{
struct irlan_cb *self;
struct net_device *dev;
self = instance;
IRDA_ASSERT(self != NULL, return;);
IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
dev = self->dev;
IRDA_ASSERT(dev != NULL, return;);
pr_debug("%s() : flow %s ; running %d\n", __func__,
flow == FLOW_STOP ? "FLOW_STOP" : "FLOW_START",
netif_running(dev));
switch (flow) {
case FLOW_STOP:
/* IrTTP is full, stop higher layers */
netif_stop_queue(dev);
break;
case FLOW_START:
default:
/* Tell upper layers that its time to transmit frames again */
/* Schedule network layer */
netif_wake_queue(dev);
break;
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
pre-git | pre-git | 80 | 76.19% | 4 | 50.00% |
jean tourrilhes | jean tourrilhes | 23 | 21.90% | 2 | 25.00% |
joe perches | joe perches | 1 | 0.95% | 1 | 12.50% |
harvey harrison | harvey harrison | 1 | 0.95% | 1 | 12.50% |
| Total | 105 | 100.00% | 8 | 100.00% |
/*
* Function set_multicast_list (dev)
*
* Configure the filtering of the device
*
*/
#define HW_MAX_ADDRS 4
/* Must query to get it! */
static void irlan_eth_set_multicast_list(struct net_device *dev)
{
struct irlan_cb *self = netdev_priv(dev);
/* Check if data channel has been connected yet */
if (self->client.state != IRLAN_DATA) {
pr_debug("%s(), delaying!\n", __func__);
return;
}
if (dev->flags & IFF_PROMISC) {
/* Enable promiscuous mode */
net_warn_ratelimited("Promiscuous mode not implemented by IrLAN!\n");
} else if ((dev->flags & IFF_ALLMULTI) ||
netdev_mc_count(dev) > HW_MAX_ADDRS) {
/* Disable promiscuous mode, use normal mode. */
pr_debug("%s(), Setting multicast filter\n", __func__);
/* hardware_set_filter(NULL); */
irlan_set_multicast_filter(self, TRUE);
} else if (!netdev_mc_empty(dev)) {
pr_debug("%s(), Setting multicast filter\n", __func__);
/* Walk the address list, and load the filter */
/* hardware_set_filter(dev->mc_list); */
irlan_set_multicast_filter(self, TRUE);
} else {
pr_debug("%s(), Clearing multicast filter\n", __func__);
irlan_set_multicast_filter(self, FALSE);
}
if (dev->flags & IFF_BROADCAST)
irlan_set_broadcast_filter(self, TRUE);
else
irlan_set_broadcast_filter(self, FALSE);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
pre-git | pre-git | 130 | 80.75% | 3 | 30.00% |
jean tourrilhes | jean tourrilhes | 14 | 8.70% | 2 | 20.00% |
jiri pirko | jiri pirko | 7 | 4.35% | 1 | 10.00% |
joe perches | joe perches | 6 | 3.73% | 3 | 30.00% |
harvey harrison | harvey harrison | 4 | 2.48% | 1 | 10.00% |
| Total | 161 | 100.00% | 10 | 100.00% |
Overall Contributors
| Person | Tokens | Prop | Commits | CommitProp |
pre-git | pre-git | 616 | 68.07% | 9 | 27.27% |
jean tourrilhes | jean tourrilhes | 166 | 18.34% | 5 | 15.15% |
stephen hemminger | stephen hemminger | 52 | 5.75% | 3 | 9.09% |
eric dumazet | eric dumazet | 28 | 3.09% | 2 | 6.06% |
joe perches | joe perches | 8 | 0.88% | 3 | 9.09% |
jiri pirko | jiri pirko | 8 | 0.88% | 2 | 6.06% |
harvey harrison | harvey harrison | 6 | 0.66% | 1 | 3.03% |
hideaki yoshifuji | hideaki yoshifuji | 6 | 0.66% | 1 | 3.03% |
florian westphal | florian westphal | 3 | 0.33% | 1 | 3.03% |
rusty russell | rusty russell | 3 | 0.33% | 1 | 3.03% |
alexey dobriyan | alexey dobriyan | 3 | 0.33% | 1 | 3.03% |
patrick mchardy | patrick mchardy | 2 | 0.22% | 1 | 3.03% |
tom gundersen | tom gundersen | 2 | 0.22% | 1 | 3.03% |
jan engelhardt | jan engelhardt | 1 | 0.11% | 1 | 3.03% |
al viro | al viro | 1 | 0.11% | 1 | 3.03% |
| Total | 905 | 100.00% | 33 | 100.00% |
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.