PageRenderTime 53ms CodeModel.GetById 12ms app.highlight 35ms RepoModel.GetById 1ms app.codeStats 1ms

/net/irda/irlan/irlan_eth.c

http://github.com/mirrors/linux
C | 340 lines | 156 code | 48 blank | 136 comment | 24 complexity | 14912ad1369d363cb9bc4b7c06690f69 MD5 | raw file
  1/*********************************************************************
  2 *
  3 * Filename:      irlan_eth.c
  4 * Version:
  5 * Description:
  6 * Status:        Experimental.
  7 * Author:        Dag Brattli <dagb@cs.uit.no>
  8 * Created at:    Thu Oct 15 08:37:58 1998
  9 * Modified at:   Tue Mar 21 09:06:41 2000
 10 * Modified by:   Dag Brattli <dagb@cs.uit.no>
 11 * Sources:       skeleton.c by Donald Becker <becker@CESDIS.gsfc.nasa.gov>
 12 *                slip.c by Laurence Culhane,   <loz@holmes.demon.co.uk>
 13 *                          Fred N. van Kempen, <waltje@uwalt.nl.mugnet.org>
 14 *
 15 *     Copyright (c) 1998-2000 Dag Brattli, All Rights Reserved.
 16 *
 17 *     This program is free software; you can redistribute it and/or
 18 *     modify it under the terms of the GNU General Public License as
 19 *     published by the Free Software Foundation; either version 2 of
 20 *     the License, or (at your option) any later version.
 21 *
 22 *     Neither Dag Brattli nor University of Tromsø admit liability nor
 23 *     provide warranty for any of this software. This material is
 24 *     provided "AS-IS" and at no charge.
 25 *
 26 ********************************************************************/
 27
 28#include <linux/netdevice.h>
 29#include <linux/etherdevice.h>
 30#include <linux/inetdevice.h>
 31#include <linux/if_arp.h>
 32#include <linux/module.h>
 33#include <linux/sched.h>
 34#include <net/arp.h>
 35
 36#include <net/irda/irda.h>
 37#include <net/irda/irmod.h>
 38#include <net/irda/irlan_common.h>
 39#include <net/irda/irlan_client.h>
 40#include <net/irda/irlan_event.h>
 41#include <net/irda/irlan_eth.h>
 42
 43static int  irlan_eth_open(struct net_device *dev);
 44static int  irlan_eth_close(struct net_device *dev);
 45static netdev_tx_t  irlan_eth_xmit(struct sk_buff *skb,
 46					 struct net_device *dev);
 47static void irlan_eth_set_multicast_list(struct net_device *dev);
 48
 49static const struct net_device_ops irlan_eth_netdev_ops = {
 50	.ndo_open		= irlan_eth_open,
 51	.ndo_stop		= irlan_eth_close,
 52	.ndo_start_xmit		= irlan_eth_xmit,
 53	.ndo_set_rx_mode	= irlan_eth_set_multicast_list,
 54	.ndo_change_mtu		= eth_change_mtu,
 55	.ndo_validate_addr	= eth_validate_addr,
 56};
 57
 58/*
 59 * Function irlan_eth_setup (dev)
 60 *
 61 *    The network device initialization function.
 62 *
 63 */
 64static void irlan_eth_setup(struct net_device *dev)
 65{
 66	ether_setup(dev);
 67
 68	dev->netdev_ops		= &irlan_eth_netdev_ops;
 69	dev->destructor		= free_netdev;
 70
 71
 72	/*
 73	 * Lets do all queueing in IrTTP instead of this device driver.
 74	 * Queueing here as well can introduce some strange latency
 75	 * problems, which we will avoid by setting the queue size to 0.
 76	 */
 77	/*
 78	 * The bugs in IrTTP and IrLAN that created this latency issue
 79	 * have now been fixed, and we can propagate flow control properly
 80	 * to the network layer. However, this requires a minimal queue of
 81	 * packets for the device.
 82	 * Without flow control, the Tx Queue is 14 (ttp) + 0 (dev) = 14
 83	 * With flow control, the Tx Queue is 7 (ttp) + 4 (dev) = 11
 84	 * See irlan_eth_flow_indication()...
 85	 * Note : this number was randomly selected and would need to
 86	 * be adjusted.
 87	 * Jean II */
 88	dev->tx_queue_len = 4;
 89}
 90
 91/*
 92 * Function alloc_irlandev
 93 *
 94 *    Allocate network device and control block
 95 *
 96 */
 97struct net_device *alloc_irlandev(const char *name)
 98{
 99	return alloc_netdev(sizeof(struct irlan_cb), name, NET_NAME_UNKNOWN,
100			    irlan_eth_setup);
101}
102
103/*
104 * Function irlan_eth_open (dev)
105 *
106 *    Network device has been opened by user
107 *
108 */
109static int irlan_eth_open(struct net_device *dev)
110{
111	struct irlan_cb *self = netdev_priv(dev);
112
113	/* Ready to play! */
114	netif_stop_queue(dev); /* Wait until data link is ready */
115
116	/* We are now open, so time to do some work */
117	self->disconnect_reason = 0;
118	irlan_client_wakeup(self, self->saddr, self->daddr);
119
120	/* Make sure we have a hardware address before we return,
121	   so DHCP clients gets happy */
122	return wait_event_interruptible(self->open_wait,
123					!self->tsap_data->connected);
124}
125
126/*
127 * Function irlan_eth_close (dev)
128 *
129 *    Stop the ether network device, his function will usually be called by
130 *    ifconfig down. We should now disconnect the link, We start the
131 *    close timer, so that the instance will be removed if we are unable
132 *    to discover the remote device after the disconnect.
133 */
134static int irlan_eth_close(struct net_device *dev)
135{
136	struct irlan_cb *self = netdev_priv(dev);
137
138	/* Stop device */
139	netif_stop_queue(dev);
140
141	irlan_close_data_channel(self);
142	irlan_close_tsaps(self);
143
144	irlan_do_client_event(self, IRLAN_LMP_DISCONNECT, NULL);
145	irlan_do_provider_event(self, IRLAN_LMP_DISCONNECT, NULL);
146
147	/* Remove frames queued on the control channel */
148	skb_queue_purge(&self->client.txq);
149
150	self->client.tx_busy = 0;
151
152	return 0;
153}
154
155/*
156 * Function irlan_eth_tx (skb)
157 *
158 *    Transmits ethernet frames over IrDA link.
159 *
160 */
161static netdev_tx_t irlan_eth_xmit(struct sk_buff *skb,
162					struct net_device *dev)
163{
164	struct irlan_cb *self = netdev_priv(dev);
165	int ret;
166	unsigned int len;
167
168	/* skb headroom large enough to contain all IrDA-headers? */
169	if ((skb_headroom(skb) < self->max_header_size) || (skb_shared(skb))) {
170		struct sk_buff *new_skb =
171			skb_realloc_headroom(skb, self->max_header_size);
172
173		/*  We have to free the original skb anyway */
174		dev_kfree_skb(skb);
175
176		/* Did the realloc succeed? */
177		if (new_skb == NULL)
178			return NETDEV_TX_OK;
179
180		/* Use the new skb instead */
181		skb = new_skb;
182	}
183
184	netif_trans_update(dev);
185
186	len = skb->len;
187	/* Now queue the packet in the transport layer */
188	if (self->use_udata)
189		ret = irttp_udata_request(self->tsap_data, skb);
190	else
191		ret = irttp_data_request(self->tsap_data, skb);
192
193	if (ret < 0) {
194		/*
195		 * IrTTPs tx queue is full, so we just have to
196		 * drop the frame! You might think that we should
197		 * just return -1 and don't deallocate the frame,
198		 * but that is dangerous since it's possible that
199		 * we have replaced the original skb with a new
200		 * one with larger headroom, and that would really
201		 * confuse do_dev_queue_xmit() in dev.c! I have
202		 * tried :-) DB
203		 */
204		/* irttp_data_request already free the packet */
205		dev->stats.tx_dropped++;
206	} else {
207		dev->stats.tx_packets++;
208		dev->stats.tx_bytes += len;
209	}
210
211	return NETDEV_TX_OK;
212}
213
214/*
215 * Function irlan_eth_receive (handle, skb)
216 *
217 *    This function gets the data that is received on the data channel
218 *
219 */
220int irlan_eth_receive(void *instance, void *sap, struct sk_buff *skb)
221{
222	struct irlan_cb *self = instance;
223	struct net_device *dev = self->dev;
224
225	if (skb == NULL) {
226		dev->stats.rx_dropped++;
227		return 0;
228	}
229	if (skb->len < ETH_HLEN) {
230		pr_debug("%s() : IrLAN frame too short (%d)\n",
231			 __func__, skb->len);
232		dev->stats.rx_dropped++;
233		dev_kfree_skb(skb);
234		return 0;
235	}
236
237	/*
238	 * Adopt this frame! Important to set all these fields since they
239	 * might have been previously set by the low level IrDA network
240	 * device driver
241	 */
242	skb->protocol = eth_type_trans(skb, dev); /* Remove eth header */
243
244	dev->stats.rx_packets++;
245	dev->stats.rx_bytes += skb->len;
246
247	netif_rx(skb);   /* Eat it! */
248
249	return 0;
250}
251
252/*
253 * Function irlan_eth_flow (status)
254 *
255 *    Do flow control between IP/Ethernet and IrLAN/IrTTP. This is done by
256 *    controlling the queue stop/start.
257 *
258 * The IrDA link layer has the advantage to have flow control, and
259 * IrTTP now properly handles that. Flow controlling the higher layers
260 * prevent us to drop Tx packets in here (up to 15% for a TCP socket,
261 * more for UDP socket).
262 * Also, this allow us to reduce the overall transmit queue, which means
263 * less latency in case of mixed traffic.
264 * Jean II
265 */
266void irlan_eth_flow_indication(void *instance, void *sap, LOCAL_FLOW flow)
267{
268	struct irlan_cb *self;
269	struct net_device *dev;
270
271	self = instance;
272
273	IRDA_ASSERT(self != NULL, return;);
274	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
275
276	dev = self->dev;
277
278	IRDA_ASSERT(dev != NULL, return;);
279
280	pr_debug("%s() : flow %s ; running %d\n", __func__,
281		 flow == FLOW_STOP ? "FLOW_STOP" : "FLOW_START",
282		 netif_running(dev));
283
284	switch (flow) {
285	case FLOW_STOP:
286		/* IrTTP is full, stop higher layers */
287		netif_stop_queue(dev);
288		break;
289	case FLOW_START:
290	default:
291		/* Tell upper layers that its time to transmit frames again */
292		/* Schedule network layer */
293		netif_wake_queue(dev);
294		break;
295	}
296}
297
298/*
299 * Function set_multicast_list (dev)
300 *
301 *    Configure the filtering of the device
302 *
303 */
304#define HW_MAX_ADDRS 4 /* Must query to get it! */
305static void irlan_eth_set_multicast_list(struct net_device *dev)
306{
307	struct irlan_cb *self = netdev_priv(dev);
308
309	/* Check if data channel has been connected yet */
310	if (self->client.state != IRLAN_DATA) {
311		pr_debug("%s(), delaying!\n", __func__);
312		return;
313	}
314
315	if (dev->flags & IFF_PROMISC) {
316		/* Enable promiscuous mode */
317		net_warn_ratelimited("Promiscuous mode not implemented by IrLAN!\n");
318	} else if ((dev->flags & IFF_ALLMULTI) ||
319		 netdev_mc_count(dev) > HW_MAX_ADDRS) {
320		/* Disable promiscuous mode, use normal mode. */
321		pr_debug("%s(), Setting multicast filter\n", __func__);
322		/* hardware_set_filter(NULL); */
323
324		irlan_set_multicast_filter(self, TRUE);
325	} else if (!netdev_mc_empty(dev)) {
326		pr_debug("%s(), Setting multicast filter\n", __func__);
327		/* Walk the address list, and load the filter */
328		/* hardware_set_filter(dev->mc_list); */
329
330		irlan_set_multicast_filter(self, TRUE);
331	} else {
332		pr_debug("%s(), Clearing multicast filter\n", __func__);
333		irlan_set_multicast_filter(self, FALSE);
334	}
335
336	if (dev->flags & IFF_BROADCAST)
337		irlan_set_broadcast_filter(self, TRUE);
338	else
339		irlan_set_broadcast_filter(self, FALSE);
340}