net/irda/irlan/irlan_eth.c

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