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
43 static int irlan_eth_open(struct net_device *dev);
44 static int irlan_eth_close(struct net_device *dev);
45 static netdev_tx_t irlan_eth_xmit(struct sk_buff *skb,
46 struct net_device *dev);
47 static void irlan_eth_set_multicast_list(struct net_device *dev);
48
49 static 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 */
irlan_eth_setup(struct net_device * dev)64 static 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 */
alloc_irlandev(const char * name)97 struct 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 */
irlan_eth_open(struct net_device * dev)109 static 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 */
irlan_eth_close(struct net_device * dev)134 static 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 */
irlan_eth_xmit(struct sk_buff * skb,struct net_device * dev)161 static 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 dev->trans_start = jiffies;
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 */
irlan_eth_receive(void * instance,void * sap,struct sk_buff * skb)220 int 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 */
irlan_eth_flow_indication(void * instance,void * sap,LOCAL_FLOW flow)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
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! */
irlan_eth_set_multicast_list(struct net_device * dev)305 static 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 }
341