[mirror_ubuntu-zesty-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 <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;
}

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

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

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

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

	dev->trans_start = jiffies;

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

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

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

/*
 * 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);
}
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>
d43c36dc	33	#include <linux/sched.h>
1da177e4 LT	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
	43	static int irlan_eth_open(struct net_device *dev);
	44	static int irlan_eth_close(struct net_device *dev);
6518bbb8 SH	45	static netdev_tx_t irlan_eth_xmit(struct sk_buff *skb,
6518bbb8 SH	46	struct net_device *dev);
b6a82dd2	47	static void irlan_eth_set_multicast_list(struct net_device *dev);
1da177e4	48
9cc8ba78	49	static const struct net_device_ops irlan_eth_netdev_ops = {
b6a82dd2 DF	50	.ndo_open = irlan_eth_open,
	51	.ndo_stop = irlan_eth_close,
	52	.ndo_start_xmit = irlan_eth_xmit,
afc4b13d	53	.ndo_set_rx_mode = irlan_eth_set_multicast_list,
9cc8ba78 SH	54	.ndo_change_mtu = eth_change_mtu,
	55	.ndo_validate_addr = eth_validate_addr,
	56	};
	57
1da177e4 LT	58	/*
	59	* Function irlan_eth_setup (dev)
	60	*
	61	* The network device initialization function.
	62	*
	63	*/
	64	static void irlan_eth_setup(struct net_device *dev)
	65	{
9cc8ba78 SH	66	ether_setup(dev);
	67
	68	dev->netdev_ops = &irlan_eth_netdev_ops;
1da177e4 LT	69	dev->destructor = free_netdev;
1da177e4 LT	70
6819bc2e YH	71
6819bc2e YH	72	/*
1da177e4 LT	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	*/
	97	struct net_device alloc_irlandev(const char name)
	98	{
c835a677	99	return alloc_netdev(sizeof(struct irlan_cb), name, NET_NAME_UNKNOWN,
1da177e4 LT	100	irlan_eth_setup);
	101	}
	102
	103	/*
	104	* Function irlan_eth_open (dev)
	105	*
	106	* Network device has been opened by user
	107	*
	108	*/
	109	static int irlan_eth_open(struct net_device *dev)
	110	{
	111	struct irlan_cb *self = netdev_priv(dev);
6819bc2e	112
1da177e4	113	/* Ready to play! */
6819bc2e	114	netif_stop_queue(dev); /* Wait until data link is ready */
1da177e4 LT	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
6819bc2e	120	/* Make sure we have a hardware address before we return,
1da177e4 LT	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
6819bc2e	130	* ifconfig down. We should now disconnect the link, We start the
1da177e4 LT	131	* close timer, so that the instance will be removed if we are unable
	132	* to discover the remote device after the disconnect.
	133	*/
	134	static int irlan_eth_close(struct net_device *dev)
	135	{
	136	struct irlan_cb *self = netdev_priv(dev);
6819bc2e	137
1da177e4 LT	138	/* Stop device */
1da177e4 LT	139	netif_stop_queue(dev);
6819bc2e	140
1da177e4 LT	141	irlan_close_data_channel(self);
	142	irlan_close_tsaps(self);
	143
	144	irlan_do_client_event(self, IRLAN_LMP_DISCONNECT, NULL);
6819bc2e YH	145	irlan_do_provider_event(self, IRLAN_LMP_DISCONNECT, NULL);
6819bc2e YH	146
1da177e4 LT	147	/* Remove frames queued on the control channel */
	148	skb_queue_purge(&self->client.txq);
	149
	150	self->client.tx_busy = 0;
6819bc2e	151
1da177e4 LT	152	return 0;
	153	}
	154
	155	/*
	156	* Function irlan_eth_tx (skb)
	157	*
	158	* Transmits ethernet frames over IrDA link.
	159	*
	160	*/
6518bbb8 SH	161	static netdev_tx_t irlan_eth_xmit(struct sk_buff *skb,
6518bbb8 SH	162	struct net_device *dev)
1da177e4 LT	163	{
	164	struct irlan_cb *self = netdev_priv(dev);
	165	int ret;
79c5f51c	166	unsigned int len;
1da177e4 LT	167
	168	/* skb headroom large enough to contain all IrDA-headers? */
	169	if ((skb_headroom(skb) < self->max_header_size) \|\| (skb_shared(skb))) {
6819bc2e	170	struct sk_buff *new_skb =
1da177e4 LT	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)
6ed10654	178	return NETDEV_TX_OK;
1da177e4 LT	179
	180	/* Use the new skb instead */
	181	skb = new_skb;
6819bc2e	182	}
1da177e4 LT	183
	184	dev->trans_start = jiffies;
	185
79c5f51c	186	len = skb->len;
1da177e4 LT	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) {
6819bc2e	194	/*
1da177e4 LT	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
6819bc2e	202	* tried :-) DB
1da177e4 LT	203	*/
1da177e4 LT	204	/* irttp_data_request already free the packet */
81ce790b	205	dev->stats.tx_dropped++;
1da177e4	206	} else {
81ce790b ED	207	dev->stats.tx_packets++;
81ce790b ED	208	dev->stats.tx_bytes += len;
1da177e4	209	}
6819bc2e	210
6ed10654	211	return NETDEV_TX_OK;
1da177e4 LT	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	*/
	220	int irlan_eth_receive(void instance, void sap, struct sk_buff *skb)
	221	{
	222	struct irlan_cb *self = instance;
81ce790b	223	struct net_device *dev = self->dev;
1da177e4 LT	224
1da177e4 LT	225	if (skb == NULL) {
81ce790b	226	dev->stats.rx_dropped++;
1da177e4 LT	227	return 0;
	228	}
	229	if (skb->len < ETH_HLEN) {
955a9d20 JP	230	pr_debug("%s() : IrLAN frame too short (%d)\n",
955a9d20 JP	231	__func__, skb->len);
81ce790b	232	dev->stats.rx_dropped++;
1da177e4 LT	233	dev_kfree_skb(skb);
	234	return 0;
	235	}
6819bc2e YH	236
	237	/*
	238	* Adopt this frame! Important to set all these fields since they
1da177e4	239	* might have been previously set by the low level IrDA network
6819bc2e	240	* device driver
1da177e4	241	*/
81ce790b	242	skb->protocol = eth_type_trans(skb, dev); /* Remove eth header */
6819bc2e	243
81ce790b ED	244	dev->stats.rx_packets++;
81ce790b ED	245	dev->stats.rx_bytes += skb->len;
1da177e4 LT	246
1da177e4 LT	247	netif_rx(skb); /* Eat it! */
6819bc2e	248
1da177e4 LT	249	return 0;
	250	}
	251
	252	/*
	253	* Function irlan_eth_flow (status)
	254	*
6819bc2e	255	* Do flow control between IP/Ethernet and IrLAN/IrTTP. This is done by
1da177e4 LT	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	*/
	266	void irlan_eth_flow_indication(void instance, void sap, LOCAL_FLOW flow)
	267	{
	268	struct irlan_cb *self;
	269	struct net_device *dev;
	270
ea110733	271	self = instance;
1da177e4 LT	272
	273	IRDA_ASSERT(self != NULL, return;);
	274	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
6819bc2e	275
1da177e4 LT	276	dev = self->dev;
	277
	278	IRDA_ASSERT(dev != NULL, return;);
6819bc2e	279
955a9d20 JP	280	pr_debug("%s() : flow %s ; running %d\n", __func__,
	281	flow == FLOW_STOP ? "FLOW_STOP" : "FLOW_START",
	282	netif_running(dev));
1da177e4 LT	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
1da177e4 LT	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! */
6819bc2e	305	static void irlan_eth_set_multicast_list(struct net_device *dev)
1da177e4	306	{
6819bc2e	307	struct irlan_cb *self = netdev_priv(dev);
1da177e4	308
1da177e4 LT	309	/* Check if data channel has been connected yet */
1da177e4 LT	310	if (self->client.state != IRLAN_DATA) {
955a9d20	311	pr_debug("%s(), delaying!\n", __func__);
1da177e4 LT	312	return;
	313	}
	314
	315	if (dev->flags & IFF_PROMISC) {
	316	/* Enable promiscuous mode */
6c91023d	317	net_warn_ratelimited("Promiscuous mode not implemented by IrLAN!\n");
b6a82dd2	318	} else if ((dev->flags & IFF_ALLMULTI) \|\|
4cd24eaf	319	netdev_mc_count(dev) > HW_MAX_ADDRS) {
1da177e4	320	/* Disable promiscuous mode, use normal mode. */
955a9d20	321	pr_debug("%s(), Setting multicast filter\n", __func__);
1da177e4 LT	322	/* hardware_set_filter(NULL); */
	323
	324	irlan_set_multicast_filter(self, TRUE);
b6a82dd2	325	} else if (!netdev_mc_empty(dev)) {
955a9d20	326	pr_debug("%s(), Setting multicast filter\n", __func__);
1da177e4 LT	327	/* Walk the address list, and load the filter */
	328	/* hardware_set_filter(dev->mc_list); */
	329
	330	irlan_set_multicast_filter(self, TRUE);
b6a82dd2	331	} else {
955a9d20	332	pr_debug("%s(), Clearing multicast filter\n", __func__);
1da177e4 LT	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	}