[mirror_ubuntu-bionic-kernel.git] / 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 <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 int  irlan_eth_xmit(struct sk_buff *skb, struct net_device *dev);
static void irlan_eth_set_multicast_list( struct net_device *dev);
static struct net_device_stats *irlan_eth_get_stats(struct net_device *dev);

/*
 * Function irlan_eth_setup (dev)
 *
 *    The network device initialization function.
 *
 */
static void irlan_eth_setup(struct net_device *dev)
{
	dev->open               = irlan_eth_open;
	dev->stop               = irlan_eth_close;
	dev->hard_start_xmit    = irlan_eth_xmit;
	dev->get_stats	        = irlan_eth_get_stats;
	dev->set_multicast_list = irlan_eth_set_multicast_list;
	dev->destructor		= free_netdev;

	ether_setup(dev);

	/*
	 * 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;
}

/*
 * 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,
			    irlan_eth_setup);
}

/*
 * 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);

	IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );

	/* 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);
}

/*
 * 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);

	IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );

	/* 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;
}

/*
 * Function irlan_eth_tx (skb)
 *
 *    Transmits ethernet frames over IrDA link.
 *
 */
static int irlan_eth_xmit(struct sk_buff *skb, struct net_device *dev)
{
	struct irlan_cb *self = netdev_priv(dev);
	int ret;

	/* 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 0;

		/* Use the new skb instead */
		skb = new_skb;
	}

	dev->trans_start = jiffies;

	/* 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 */
		self->stats.tx_dropped++;
	} else {
		self->stats.tx_packets++;
		self->stats.tx_bytes += skb->len;
	}

	return 0;
}

/*
 * 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;

	if (skb == NULL) {
		++self->stats.rx_dropped;
		return 0;
	}
	if (skb->len < ETH_HLEN) {
		IRDA_DEBUG(0, "%s() : IrLAN frame too short (%d)\n",
			   __FUNCTION__, skb->len);
		++self->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, self->dev); /* Remove eth header */

	self->stats.rx_packets++;
	self->stats.rx_bytes += skb->len;

	netif_rx(skb);   /* Eat it! */

	return 0;
}

/*
 * 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 = (struct irlan_cb *) instance;

	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);

	dev = self->dev;

	IRDA_ASSERT(dev != NULL, return;);

	IRDA_DEBUG(0, "%s() : flow %s ; running %d\n", __FUNCTION__,
		   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;
	}
}

/*
 * Function irlan_etc_send_gratuitous_arp (dev)
 *
 *    Send gratuitous ARP to announce that we have changed
 *    hardware address, so that all peers updates their ARP tables
 */
void irlan_eth_send_gratuitous_arp(struct net_device *dev)
{
	struct in_device *in_dev;

	/*
	 * When we get a new MAC address do a gratuitous ARP. This
	 * is useful if we have changed access points on the same
	 * subnet.
	 */
#ifdef CONFIG_INET
	IRDA_DEBUG(4, "IrLAN: Sending gratuitous ARP\n");
	rcu_read_lock();
	in_dev = __in_dev_get_rcu(dev);
	if (in_dev == NULL)
		goto out;
	if (in_dev->ifa_list)

	arp_send(ARPOP_REQUEST, ETH_P_ARP,
		 in_dev->ifa_list->ifa_address,
		 dev,
		 in_dev->ifa_list->ifa_address,
		 NULL, dev->dev_addr, NULL);
out:
	rcu_read_unlock();
#endif /* CONFIG_INET */
}

/*
 * 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);

	IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );

	/* Check if data channel has been connected yet */
	if (self->client.state != IRLAN_DATA) {
		IRDA_DEBUG(1, "%s(), delaying!\n", __FUNCTION__ );
		return;
	}

	if (dev->flags & IFF_PROMISC) {
		/* Enable promiscuous mode */
		IRDA_WARNING("Promiscous mode not implemented by IrLAN!\n");
	}
	else if ((dev->flags & IFF_ALLMULTI) || dev->mc_count > HW_MAX_ADDRS) {
		/* Disable promiscuous mode, use normal mode. */
		IRDA_DEBUG(4, "%s(), Setting multicast filter\n", __FUNCTION__ );
		/* hardware_set_filter(NULL); */

		irlan_set_multicast_filter(self, TRUE);
	}
	else if (dev->mc_count) {
		IRDA_DEBUG(4, "%s(), Setting multicast filter\n", __FUNCTION__ );
		/* Walk the address list, and load the filter */
		/* hardware_set_filter(dev->mc_list); */

		irlan_set_multicast_filter(self, TRUE);
	}
	else {
		IRDA_DEBUG(4, "%s(), Clearing multicast filter\n", __FUNCTION__ );
		irlan_set_multicast_filter(self, FALSE);
	}

	if (dev->flags & IFF_BROADCAST)
		irlan_set_broadcast_filter(self, TRUE);
	else
		irlan_set_broadcast_filter(self, FALSE);
}

/*
 * Function irlan_get_stats (dev)
 *
 *    Get the current statistics for this device
 *
 */
static struct net_device_stats *irlan_eth_get_stats(struct net_device *dev)
{
	struct irlan_cb *self = netdev_priv(dev);

	return &self->stats;
}
Commit	Line	Data
1da177e4	1	/*********************************************************************
6819bc2e	2	*
1da177e4	3	* Filename: irlan_eth.c
6819bc2e YH	4	* Version:
6819bc2e YH	5	* Description:
1da177e4 LT	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>
6819bc2e	14	*
1da177e4	15	* Copyright (c) 1998-2000 Dag Brattli, All Rights Reserved.
6819bc2e YH	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
1da177e4	20	* the License, or (at your option) any later version.
6819bc2e	21	*
96de0e25	22	* Neither Dag Brattli nor University of Tromsø admit liability nor
6819bc2e	23	* provide warranty for any of this software. This material is
1da177e4	24	* provided "AS-IS" and at no charge.
6819bc2e	25	*
1da177e4 LT	26	********************************************************************/
1da177e4 LT	27
1da177e4 LT	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 <net/arp.h>
	34
	35	#include <net/irda/irda.h>
	36	#include <net/irda/irmod.h>
	37	#include <net/irda/irlan_common.h>
	38	#include <net/irda/irlan_client.h>
	39	#include <net/irda/irlan_event.h>
	40	#include <net/irda/irlan_eth.h>
	41
	42	static int irlan_eth_open(struct net_device *dev);
	43	static int irlan_eth_close(struct net_device *dev);
	44	static int irlan_eth_xmit(struct sk_buff skb, struct net_device dev);
	45	static void irlan_eth_set_multicast_list( struct net_device *dev);
	46	static struct net_device_stats irlan_eth_get_stats(struct net_device dev);
	47
	48	/*
	49	* Function irlan_eth_setup (dev)
	50	*
	51	* The network device initialization function.
	52	*
	53	*/
	54	static void irlan_eth_setup(struct net_device *dev)
	55	{
	56	dev->open = irlan_eth_open;
	57	dev->stop = irlan_eth_close;
6819bc2e	58	dev->hard_start_xmit = irlan_eth_xmit;
1da177e4 LT	59	dev->get_stats = irlan_eth_get_stats;
	60	dev->set_multicast_list = irlan_eth_set_multicast_list;
	61	dev->destructor = free_netdev;
	62
1da177e4	63	ether_setup(dev);
6819bc2e YH	64
6819bc2e YH	65	/*
1da177e4 LT	66	* Lets do all queueing in IrTTP instead of this device driver.
	67	* Queueing here as well can introduce some strange latency
	68	* problems, which we will avoid by setting the queue size to 0.
	69	*/
	70	/*
	71	* The bugs in IrTTP and IrLAN that created this latency issue
	72	* have now been fixed, and we can propagate flow control properly
	73	* to the network layer. However, this requires a minimal queue of
	74	* packets for the device.
	75	* Without flow control, the Tx Queue is 14 (ttp) + 0 (dev) = 14
	76	* With flow control, the Tx Queue is 7 (ttp) + 4 (dev) = 11
	77	* See irlan_eth_flow_indication()...
	78	* Note : this number was randomly selected and would need to
	79	* be adjusted.
	80	* Jean II */
	81	dev->tx_queue_len = 4;
	82	}
	83
	84	/*
	85	* Function alloc_irlandev
	86	*
	87	* Allocate network device and control block
	88	*
	89	*/
	90	struct net_device alloc_irlandev(const char name)
	91	{
	92	return alloc_netdev(sizeof(struct irlan_cb), name,
	93	irlan_eth_setup);
	94	}
	95
	96	/*
	97	* Function irlan_eth_open (dev)
	98	*
	99	* Network device has been opened by user
	100	*
	101	*/
	102	static int irlan_eth_open(struct net_device *dev)
	103	{
	104	struct irlan_cb *self = netdev_priv(dev);
6819bc2e	105
1da177e4 LT	106	IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
	107
	108	/* Ready to play! */
6819bc2e	109	netif_stop_queue(dev); /* Wait until data link is ready */
1da177e4 LT	110
	111	/* We are now open, so time to do some work */
	112	self->disconnect_reason = 0;
	113	irlan_client_wakeup(self, self->saddr, self->daddr);
	114
6819bc2e	115	/* Make sure we have a hardware address before we return,
1da177e4 LT	116	so DHCP clients gets happy */
	117	return wait_event_interruptible(self->open_wait,
	118	!self->tsap_data->connected);
	119	}
	120
	121	/*
	122	* Function irlan_eth_close (dev)
	123	*
	124	* Stop the ether network device, his function will usually be called by
6819bc2e	125	* ifconfig down. We should now disconnect the link, We start the
1da177e4 LT	126	* close timer, so that the instance will be removed if we are unable
	127	* to discover the remote device after the disconnect.
	128	*/
	129	static int irlan_eth_close(struct net_device *dev)
	130	{
	131	struct irlan_cb *self = netdev_priv(dev);
6819bc2e	132
1da177e4	133	IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
6819bc2e	134
1da177e4 LT	135	/* Stop device */
1da177e4 LT	136	netif_stop_queue(dev);
6819bc2e	137
1da177e4 LT	138	irlan_close_data_channel(self);
	139	irlan_close_tsaps(self);
	140
	141	irlan_do_client_event(self, IRLAN_LMP_DISCONNECT, NULL);
6819bc2e YH	142	irlan_do_provider_event(self, IRLAN_LMP_DISCONNECT, NULL);
6819bc2e YH	143
1da177e4 LT	144	/* Remove frames queued on the control channel */
	145	skb_queue_purge(&self->client.txq);
	146
	147	self->client.tx_busy = 0;
6819bc2e	148
1da177e4 LT	149	return 0;
	150	}
	151
	152	/*
	153	* Function irlan_eth_tx (skb)
	154	*
	155	* Transmits ethernet frames over IrDA link.
	156	*
	157	*/
	158	static int irlan_eth_xmit(struct sk_buff skb, struct net_device dev)
	159	{
	160	struct irlan_cb *self = netdev_priv(dev);
	161	int ret;
	162
	163	/* skb headroom large enough to contain all IrDA-headers? */
	164	if ((skb_headroom(skb) < self->max_header_size) \|\| (skb_shared(skb))) {
6819bc2e	165	struct sk_buff *new_skb =
1da177e4 LT	166	skb_realloc_headroom(skb, self->max_header_size);
	167
	168	/* We have to free the original skb anyway */
	169	dev_kfree_skb(skb);
	170
	171	/* Did the realloc succeed? */
	172	if (new_skb == NULL)
	173	return 0;
	174
	175	/* Use the new skb instead */
	176	skb = new_skb;
6819bc2e	177	}
1da177e4 LT	178
	179	dev->trans_start = jiffies;
	180
	181	/* Now queue the packet in the transport layer */
	182	if (self->use_udata)
	183	ret = irttp_udata_request(self->tsap_data, skb);
	184	else
	185	ret = irttp_data_request(self->tsap_data, skb);
	186
	187	if (ret < 0) {
6819bc2e	188	/*
1da177e4 LT	189	* IrTTPs tx queue is full, so we just have to
	190	* drop the frame! You might think that we should
	191	* just return -1 and don't deallocate the frame,
	192	* but that is dangerous since it's possible that
	193	* we have replaced the original skb with a new
	194	* one with larger headroom, and that would really
	195	* confuse do_dev_queue_xmit() in dev.c! I have
6819bc2e	196	* tried :-) DB
1da177e4 LT	197	*/
	198	/* irttp_data_request already free the packet */
	199	self->stats.tx_dropped++;
	200	} else {
	201	self->stats.tx_packets++;
6819bc2e	202	self->stats.tx_bytes += skb->len;
1da177e4	203	}
6819bc2e	204
1da177e4 LT	205	return 0;
	206	}
	207
	208	/*
	209	* Function irlan_eth_receive (handle, skb)
	210	*
	211	* This function gets the data that is received on the data channel
	212	*
	213	*/
	214	int irlan_eth_receive(void instance, void sap, struct sk_buff *skb)
	215	{
	216	struct irlan_cb *self = instance;
	217
	218	if (skb == NULL) {
6819bc2e	219	++self->stats.rx_dropped;
1da177e4 LT	220	return 0;
	221	}
	222	if (skb->len < ETH_HLEN) {
	223	IRDA_DEBUG(0, "%s() : IrLAN frame too short (%d)\n",
	224	__FUNCTION__, skb->len);
6819bc2e	225	++self->stats.rx_dropped;
1da177e4 LT	226	dev_kfree_skb(skb);
	227	return 0;
	228	}
6819bc2e YH	229
	230	/*
	231	* Adopt this frame! Important to set all these fields since they
1da177e4	232	* might have been previously set by the low level IrDA network
6819bc2e	233	* device driver
1da177e4	234	*/
4c13eb66	235	skb->protocol = eth_type_trans(skb, self->dev); /* Remove eth header */
6819bc2e	236
1da177e4	237	self->stats.rx_packets++;
6819bc2e	238	self->stats.rx_bytes += skb->len;
1da177e4 LT	239
1da177e4 LT	240	netif_rx(skb); /* Eat it! */
6819bc2e	241
1da177e4 LT	242	return 0;
	243	}
	244
	245	/*
	246	* Function irlan_eth_flow (status)
	247	*
6819bc2e	248	* Do flow control between IP/Ethernet and IrLAN/IrTTP. This is done by
1da177e4 LT	249	* controlling the queue stop/start.
	250	*
	251	* The IrDA link layer has the advantage to have flow control, and
	252	* IrTTP now properly handles that. Flow controlling the higher layers
	253	* prevent us to drop Tx packets in here (up to 15% for a TCP socket,
	254	* more for UDP socket).
	255	* Also, this allow us to reduce the overall transmit queue, which means
	256	* less latency in case of mixed traffic.
	257	* Jean II
	258	*/
	259	void irlan_eth_flow_indication(void instance, void sap, LOCAL_FLOW flow)
	260	{
	261	struct irlan_cb *self;
	262	struct net_device *dev;
	263
	264	self = (struct irlan_cb *) instance;
	265
	266	IRDA_ASSERT(self != NULL, return;);
	267	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
6819bc2e	268
1da177e4 LT	269	dev = self->dev;
	270
	271	IRDA_ASSERT(dev != NULL, return;);
6819bc2e	272
1da177e4 LT	273	IRDA_DEBUG(0, "%s() : flow %s ; running %d\n", __FUNCTION__,
	274	flow == FLOW_STOP ? "FLOW_STOP" : "FLOW_START",
	275	netif_running(dev));
	276
	277	switch (flow) {
	278	case FLOW_STOP:
	279	/* IrTTP is full, stop higher layers */
	280	netif_stop_queue(dev);
	281	break;
	282	case FLOW_START:
	283	default:
	284	/* Tell upper layers that its time to transmit frames again */
	285	/* Schedule network layer */
	286	netif_wake_queue(dev);
	287	break;
	288	}
	289	}
	290
	291	/*
	292	* Function irlan_etc_send_gratuitous_arp (dev)
	293	*
	294	* Send gratuitous ARP to announce that we have changed
	295	* hardware address, so that all peers updates their ARP tables
	296	*/
	297	void irlan_eth_send_gratuitous_arp(struct net_device *dev)
	298	{
	299	struct in_device *in_dev;
	300
6819bc2e	301	/*
1da177e4 LT	302	* When we get a new MAC address do a gratuitous ARP. This
1da177e4 LT	303	* is useful if we have changed access points on the same
6819bc2e	304	* subnet.
1da177e4 LT	305	*/
	306	#ifdef CONFIG_INET
	307	IRDA_DEBUG(4, "IrLAN: Sending gratuitous ARP\n");
	308	rcu_read_lock();
e5ed6399	309	in_dev = __in_dev_get_rcu(dev);
1da177e4 LT	310	if (in_dev == NULL)
	311	goto out;
	312	if (in_dev->ifa_list)
6819bc2e YH	313
6819bc2e YH	314	arp_send(ARPOP_REQUEST, ETH_P_ARP,
1da177e4	315	in_dev->ifa_list->ifa_address,
6819bc2e	316	dev,
1da177e4 LT	317	in_dev->ifa_list->ifa_address,
	318	NULL, dev->dev_addr, NULL);
	319	out:
	320	rcu_read_unlock();
	321	#endif /* CONFIG_INET */
	322	}
	323
	324	/*
	325	* Function set_multicast_list (dev)
	326	*
	327	* Configure the filtering of the device
	328	*
	329	*/
	330	#define HW_MAX_ADDRS 4 /* Must query to get it! */
6819bc2e	331	static void irlan_eth_set_multicast_list(struct net_device *dev)
1da177e4	332	{
6819bc2e	333	struct irlan_cb *self = netdev_priv(dev);
1da177e4 LT	334
	335	IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
	336
	337	/* Check if data channel has been connected yet */
	338	if (self->client.state != IRLAN_DATA) {
	339	IRDA_DEBUG(1, "%s(), delaying!\n", __FUNCTION__ );
	340	return;
	341	}
	342
	343	if (dev->flags & IFF_PROMISC) {
	344	/* Enable promiscuous mode */
	345	IRDA_WARNING("Promiscous mode not implemented by IrLAN!\n");
6819bc2e	346	}
1da177e4 LT	347	else if ((dev->flags & IFF_ALLMULTI) \|\| dev->mc_count > HW_MAX_ADDRS) {
	348	/* Disable promiscuous mode, use normal mode. */
	349	IRDA_DEBUG(4, "%s(), Setting multicast filter\n", __FUNCTION__ );
	350	/* hardware_set_filter(NULL); */
	351
	352	irlan_set_multicast_filter(self, TRUE);
	353	}
	354	else if (dev->mc_count) {
	355	IRDA_DEBUG(4, "%s(), Setting multicast filter\n", __FUNCTION__ );
	356	/* Walk the address list, and load the filter */
	357	/* hardware_set_filter(dev->mc_list); */
	358
	359	irlan_set_multicast_filter(self, TRUE);
	360	}
	361	else {
	362	IRDA_DEBUG(4, "%s(), Clearing multicast filter\n", __FUNCTION__ );
	363	irlan_set_multicast_filter(self, FALSE);
	364	}
	365
	366	if (dev->flags & IFF_BROADCAST)
	367	irlan_set_broadcast_filter(self, TRUE);
	368	else
	369	irlan_set_broadcast_filter(self, FALSE);
	370	}
	371
	372	/*
	373	* Function irlan_get_stats (dev)
	374	*
	375	* Get the current statistics for this device
	376	*
	377	*/
6819bc2e	378	static struct net_device_stats irlan_eth_get_stats(struct net_device dev)
1da177e4 LT	379	{
	380	struct irlan_cb *self = netdev_priv(dev);
	381
	382	return &self->stats;
	383	}