net/atm/lec.c

   1 /*
   2  * lec.c: Lan Emulation driver
   3  *
   4  * Marko Kiiskila <mkiiskila@yahoo.com>
   5  */
   6
   7 #include <linux/kernel.h>
   8 #include <linux/bitops.h>
   9 #include <linux/capability.h>
  10
  11 /* We are ethernet device */
  12 #include <linux/if_ether.h>
  13 #include <linux/netdevice.h>
  14 #include <linux/etherdevice.h>
  15 #include <net/sock.h>
  16 #include <linux/skbuff.h>
  17 #include <linux/ip.h>
  18 #include <asm/byteorder.h>
  19 #include <asm/uaccess.h>
  20 #include <net/arp.h>
  21 #include <net/dst.h>
  22 #include <linux/proc_fs.h>
  23 #include <linux/spinlock.h>
  24 #include <linux/seq_file.h>
  25
  26 /* TokenRing if needed */
  27 #ifdef CONFIG_TR
  28 #include <linux/trdevice.h>
  29 #endif
  30
  31 /* And atm device */
  32 #include <linux/atmdev.h>
  33 #include <linux/atmlec.h>
  34
  35 /* Proxy LEC knows about bridging */
  36 #if defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)
  37 #include <linux/if_bridge.h>
  38 #include "../bridge/br_private.h"
  39
  40 static unsigned char bridge_ula_lec[] = { 0x01, 0x80, 0xc2, 0x00, 0x00 };
  41 #endif
  42
  43 /* Modular too */
  44 #include <linux/module.h>
  45 #include <linux/init.h>
  46
  47 #include "lec.h"
  48 #include "lec_arpc.h"
  49 #include "resources.h"
  50
  51 #if 0
  52 #define DPRINTK printk
  53 #else
  54 #define DPRINTK(format,args...)
  55 #endif
  56
  57 #define DUMP_PACKETS 0          /*
  58                                  * 0 = None,
  59                                  * 1 = 30 first bytes
  60                                  * 2 = Whole packet
  61                                  */
  62
  63 #define LEC_UNRES_QUE_LEN 8     /*
  64                                  * number of tx packets to queue for a
  65                                  * single destination while waiting for SVC
  66                                  */
  67
  68 static int lec_open(struct net_device *dev);
  69 static int lec_start_xmit(struct sk_buff *skb, struct net_device *dev);
  70 static int lec_close(struct net_device *dev);
  71 static struct net_device_stats *lec_get_stats(struct net_device *dev);
  72 static void lec_init(struct net_device *dev);
  73 static struct lec_arp_table *lec_arp_find(struct lec_priv *priv,
  74                                           unsigned char *mac_addr);
  75 static int lec_arp_remove(struct lec_priv *priv,
  76                           struct lec_arp_table *to_remove);
  77 /* LANE2 functions */
  78 static void lane2_associate_ind(struct net_device *dev, u8 *mac_address,
  79                                 u8 *tlvs, u32 sizeoftlvs);
  80 static int lane2_resolve(struct net_device *dev, u8 *dst_mac, int force,
  81                          u8 **tlvs, u32 *sizeoftlvs);
  82 static int lane2_associate_req(struct net_device *dev, u8 *lan_dst,
  83                                u8 *tlvs, u32 sizeoftlvs);
  84
  85 static int lec_addr_delete(struct lec_priv *priv, unsigned char *atm_addr,
  86                            unsigned long permanent);
  87 static void lec_arp_check_empties(struct lec_priv *priv,
  88                                   struct atm_vcc *vcc, struct sk_buff *skb);
  89 static void lec_arp_destroy(struct lec_priv *priv);
  90 static void lec_arp_init(struct lec_priv *priv);
  91 static struct atm_vcc *lec_arp_resolve(struct lec_priv *priv,
  92                                        unsigned char *mac_to_find,
  93                                        int is_rdesc,
  94                                        struct lec_arp_table **ret_entry);
  95 static void lec_arp_update(struct lec_priv *priv, unsigned char *mac_addr,
  96                            unsigned char *atm_addr, unsigned long remoteflag,
  97                            unsigned int targetless_le_arp);
  98 static void lec_flush_complete(struct lec_priv *priv, unsigned long tran_id);
  99 static int lec_mcast_make(struct lec_priv *priv, struct atm_vcc *vcc);
 100 static void lec_set_flush_tran_id(struct lec_priv *priv,
 101                                   unsigned char *atm_addr,
 102                                   unsigned long tran_id);
 103 static void lec_vcc_added(struct lec_priv *priv, struct atmlec_ioc *ioc_data,
 104                           struct atm_vcc *vcc,
 105                           void (*old_push) (struct atm_vcc *vcc,
 106                                             struct sk_buff *skb));
 107 static void lec_vcc_close(struct lec_priv *priv, struct atm_vcc *vcc);
 108
 109 /* must be done under lec_arp_lock */
 110 static inline void lec_arp_hold(struct lec_arp_table *entry)
 111 {
 112         atomic_inc(&entry->usage);
 113 }
 114
 115 static inline void lec_arp_put(struct lec_arp_table *entry)
 116 {
 117         if (atomic_dec_and_test(&entry->usage))
 118                 kfree(entry);
 119 }
 120
 121
 122 static struct lane2_ops lane2_ops = {
 123         lane2_resolve,          /* resolve,             spec 3.1.3 */
 124         lane2_associate_req,    /* associate_req,       spec 3.1.4 */
 125         NULL                    /* associate indicator, spec 3.1.5 */
 126 };
 127
 128 static unsigned char bus_mac[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
 129
 130 /* Device structures */
 131 static struct net_device *dev_lec[MAX_LEC_ITF];
 132
 133 #if defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)
 134 static void lec_handle_bridge(struct sk_buff *skb, struct net_device *dev)
 135 {
 136         struct ethhdr *eth;
 137         char *buff;
 138         struct lec_priv *priv;
 139
 140         /*
 141          * Check if this is a BPDU. If so, ask zeppelin to send
 142          * LE_TOPOLOGY_REQUEST with the same value of Topology Change bit
 143          * as the Config BPDU has
 144          */
 145         eth = (struct ethhdr *)skb->data;
 146         buff = skb->data + skb->dev->hard_header_len;
 147         if (*buff++ == 0x42 && *buff++ == 0x42 && *buff++ == 0x03) {
 148                 struct sock *sk;
 149                 struct sk_buff *skb2;
 150                 struct atmlec_msg *mesg;
 151
 152                 skb2 = alloc_skb(sizeof(struct atmlec_msg), GFP_ATOMIC);
 153                 if (skb2 == NULL)
 154                         return;
 155                 skb2->len = sizeof(struct atmlec_msg);
 156                 mesg = (struct atmlec_msg *)skb2->data;
 157                 mesg->type = l_topology_change;
 158                 buff += 4;
 159                 mesg->content.normal.flag = *buff & 0x01;       /* 0x01 is topology change */
 160
 161                 priv = (struct lec_priv *)dev->priv;
 162                 atm_force_charge(priv->lecd, skb2->truesize);
 163                 sk = sk_atm(priv->lecd);
 164                 skb_queue_tail(&sk->sk_receive_queue, skb2);
 165                 sk->sk_data_ready(sk, skb2->len);
 166         }
 167
 168         return;
 169 }
 170 #endif /* defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE) */
 171
 172 /*
 173  * Modelled after tr_type_trans
 174  * All multicast and ARE or STE frames go to BUS.
 175  * Non source routed frames go by destination address.
 176  * Last hop source routed frames go by destination address.
 177  * Not last hop source routed frames go by _next_ route descriptor.
 178  * Returns pointer to destination MAC address or fills in rdesc
 179  * and returns NULL.
 180  */
 181 #ifdef CONFIG_TR
 182 static unsigned char *get_tr_dst(unsigned char *packet, unsigned char *rdesc)
 183 {
 184         struct trh_hdr *trh;
 185         int riflen, num_rdsc;
 186
 187         trh = (struct trh_hdr *)packet;
 188         if (trh->daddr[0] & (uint8_t) 0x80)
 189                 return bus_mac; /* multicast */
 190
 191         if (trh->saddr[0] & TR_RII) {
 192                 riflen = (ntohs(trh->rcf) & TR_RCF_LEN_MASK) >> 8;
 193                 if ((ntohs(trh->rcf) >> 13) != 0)
 194                         return bus_mac; /* ARE or STE */
 195         } else
 196                 return trh->daddr;      /* not source routed */
 197
 198         if (riflen < 6)
 199                 return trh->daddr;      /* last hop, source routed */
 200
 201         /* riflen is 6 or more, packet has more than one route descriptor */
 202         num_rdsc = (riflen / 2) - 1;
 203         memset(rdesc, 0, ETH_ALEN);
 204         /* offset 4 comes from LAN destination field in LE control frames */
 205         if (trh->rcf & htons((uint16_t) TR_RCF_DIR_BIT))
 206                 memcpy(&rdesc[4], &trh->rseg[num_rdsc - 2], sizeof(__be16));
 207         else {
 208                 memcpy(&rdesc[4], &trh->rseg[1], sizeof(__be16));
 209                 rdesc[5] = ((ntohs(trh->rseg[0]) & 0x000f) | (rdesc[5] & 0xf0));
 210         }
 211
 212         return NULL;
 213 }
 214 #endif /* CONFIG_TR */
 215
 216 /*
 217  * Open/initialize the netdevice. This is called (in the current kernel)
 218  * sometime after booting when the 'ifconfig' program is run.
 219  *
 220  * This routine should set everything up anew at each open, even
 221  * registers that "should" only need to be set once at boot, so that
 222  * there is non-reboot way to recover if something goes wrong.
 223  */
 224
 225 static int lec_open(struct net_device *dev)
 226 {
 227         struct lec_priv *priv = (struct lec_priv *)dev->priv;
 228
 229         netif_start_queue(dev);
 230         memset(&priv->stats, 0, sizeof(struct net_device_stats));
 231
 232         return 0;
 233 }
 234
 235 static __inline__ void
 236 lec_send(struct atm_vcc *vcc, struct sk_buff *skb, struct lec_priv *priv)
 237 {
 238         ATM_SKB(skb)->vcc = vcc;
 239         ATM_SKB(skb)->atm_options = vcc->atm_options;
 240
 241         atomic_add(skb->truesize, &sk_atm(vcc)->sk_wmem_alloc);
 242         if (vcc->send(vcc, skb) < 0) {
 243                 priv->stats.tx_dropped++;
 244                 return;
 245         }
 246
 247         priv->stats.tx_packets++;
 248         priv->stats.tx_bytes += skb->len;
 249 }
 250
 251 static void lec_tx_timeout(struct net_device *dev)
 252 {
 253         printk(KERN_INFO "%s: tx timeout\n", dev->name);
 254         dev->trans_start = jiffies;
 255         netif_wake_queue(dev);
 256 }
 257
 258 static int lec_start_xmit(struct sk_buff *skb, struct net_device *dev)
 259 {
 260         struct sk_buff *skb2;
 261         struct lec_priv *priv = (struct lec_priv *)dev->priv;
 262         struct lecdatahdr_8023 *lec_h;
 263         struct atm_vcc *vcc;
 264         struct lec_arp_table *entry;
 265         unsigned char *dst;
 266         int min_frame_size;
 267 #ifdef CONFIG_TR
 268         unsigned char rdesc[ETH_ALEN];  /* Token Ring route descriptor */
 269 #endif
 270         int is_rdesc;
 271 #if DUMP_PACKETS > 0
 272         char buf[300];
 273         int i = 0;
 274 #endif /* DUMP_PACKETS >0 */
 275
 276         DPRINTK("lec_start_xmit called\n");
 277         if (!priv->lecd) {
 278                 printk("%s:No lecd attached\n", dev->name);
 279                 priv->stats.tx_errors++;
 280                 netif_stop_queue(dev);
 281                 return -EUNATCH;
 282         }
 283
 284         DPRINTK("skbuff head:%lx data:%lx tail:%lx end:%lx\n",
 285                 (long)skb->head, (long)skb->data, (long)skb_tail_pointer(skb),
 286                 (long)skb_end_pointer(skb));
 287 #if defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)
 288         if (memcmp(skb->data, bridge_ula_lec, sizeof(bridge_ula_lec)) == 0)
 289                 lec_handle_bridge(skb, dev);
 290 #endif
 291
 292         /* Make sure we have room for lec_id */
 293         if (skb_headroom(skb) < 2) {
 294
 295                 DPRINTK("lec_start_xmit: reallocating skb\n");
 296                 skb2 = skb_realloc_headroom(skb, LEC_HEADER_LEN);
 297                 kfree_skb(skb);
 298                 if (skb2 == NULL)
 299                         return 0;
 300                 skb = skb2;
 301         }
 302         skb_push(skb, 2);
 303
 304         /* Put le header to place, works for TokenRing too */
 305         lec_h = (struct lecdatahdr_8023 *)skb->data;
 306         lec_h->le_header = htons(priv->lecid);
 307
 308 #ifdef CONFIG_TR
 309         /*
 310          * Ugly. Use this to realign Token Ring packets for
 311          * e.g. PCA-200E driver.
 312          */
 313         if (priv->is_trdev) {
 314                 skb2 = skb_realloc_headroom(skb, LEC_HEADER_LEN);
 315                 kfree_skb(skb);
 316                 if (skb2 == NULL)
 317                         return 0;
 318                 skb = skb2;
 319         }
 320 #endif
 321
 322 #if DUMP_PACKETS > 0
 323         printk("%s: send datalen:%ld lecid:%4.4x\n", dev->name,
 324                skb->len, priv->lecid);
 325 #if DUMP_PACKETS >= 2
 326         for (i = 0; i < skb->len && i < 99; i++) {
 327                 sprintf(buf + i * 3, "%2.2x ", 0xff & skb->data[i]);
 328         }
 329 #elif DUMP_PACKETS >= 1
 330         for (i = 0; i < skb->len && i < 30; i++) {
 331                 sprintf(buf + i * 3, "%2.2x ", 0xff & skb->data[i]);
 332         }
 333 #endif /* DUMP_PACKETS >= 1 */
 334         if (i == skb->len)
 335                 printk("%s\n", buf);
 336         else
 337                 printk("%s...\n", buf);
 338 #endif /* DUMP_PACKETS > 0 */
 339
 340         /* Minimum ethernet-frame size */
 341 #ifdef CONFIG_TR
 342         if (priv->is_trdev)
 343                 min_frame_size = LEC_MINIMUM_8025_SIZE;
 344         else
 345 #endif
 346                 min_frame_size = LEC_MINIMUM_8023_SIZE;
 347         if (skb->len < min_frame_size) {
 348                 if ((skb->len + skb_tailroom(skb)) < min_frame_size) {
 349                         skb2 = skb_copy_expand(skb, 0,
 350                                                min_frame_size - skb->truesize,
 351                                                GFP_ATOMIC);
 352                         dev_kfree_skb(skb);
 353                         if (skb2 == NULL) {
 354                                 priv->stats.tx_dropped++;
 355                                 return 0;
 356                         }
 357                         skb = skb2;
 358                 }
 359                 skb_put(skb, min_frame_size - skb->len);
 360         }
 361
 362         /* Send to right vcc */
 363         is_rdesc = 0;
 364         dst = lec_h->h_dest;
 365 #ifdef CONFIG_TR
 366         if (priv->is_trdev) {
 367                 dst = get_tr_dst(skb->data + 2, rdesc);
 368                 if (dst == NULL) {
 369                         dst = rdesc;
 370                         is_rdesc = 1;
 371                 }
 372         }
 373 #endif
 374         entry = NULL;
 375         vcc = lec_arp_resolve(priv, dst, is_rdesc, &entry);
 376         DPRINTK("%s:vcc:%p vcc_flags:%x, entry:%p\n", dev->name,
 377                 vcc, vcc ? vcc->flags : 0, entry);
 378         if (!vcc || !test_bit(ATM_VF_READY, &vcc->flags)) {
 379                 if (entry && (entry->tx_wait.qlen < LEC_UNRES_QUE_LEN)) {
 380                         DPRINTK("%s:lec_start_xmit: queuing packet, ",
 381                                 dev->name);
 382                         DPRINTK("MAC address 0x%02x:%02x:%02x:%02x:%02x:%02x\n",
 383                                 lec_h->h_dest[0], lec_h->h_dest[1],
 384                                 lec_h->h_dest[2], lec_h->h_dest[3],
 385                                 lec_h->h_dest[4], lec_h->h_dest[5]);
 386                         skb_queue_tail(&entry->tx_wait, skb);
 387                 } else {
 388                         DPRINTK
 389                             ("%s:lec_start_xmit: tx queue full or no arp entry, dropping, ",
 390                              dev->name);
 391                         DPRINTK("MAC address 0x%02x:%02x:%02x:%02x:%02x:%02x\n",
 392                                 lec_h->h_dest[0], lec_h->h_dest[1],
 393                                 lec_h->h_dest[2], lec_h->h_dest[3],
 394                                 lec_h->h_dest[4], lec_h->h_dest[5]);
 395                         priv->stats.tx_dropped++;
 396                         dev_kfree_skb(skb);
 397                 }
 398                 goto out;
 399         }
 400 #if DUMP_PACKETS > 0
 401         printk("%s:sending to vpi:%d vci:%d\n", dev->name, vcc->vpi, vcc->vci);
 402 #endif /* DUMP_PACKETS > 0 */
 403
 404         while (entry && (skb2 = skb_dequeue(&entry->tx_wait))) {
 405                 DPRINTK("lec.c: emptying tx queue, ");
 406                 DPRINTK("MAC address 0x%02x:%02x:%02x:%02x:%02x:%02x\n",
 407                         lec_h->h_dest[0], lec_h->h_dest[1], lec_h->h_dest[2],
 408                         lec_h->h_dest[3], lec_h->h_dest[4], lec_h->h_dest[5]);
 409                 lec_send(vcc, skb2, priv);
 410         }
 411
 412         lec_send(vcc, skb, priv);
 413
 414         if (!atm_may_send(vcc, 0)) {
 415                 struct lec_vcc_priv *vpriv = LEC_VCC_PRIV(vcc);
 416
 417                 vpriv->xoff = 1;
 418                 netif_stop_queue(dev);
 419
 420                 /*
 421                  * vcc->pop() might have occurred in between, making
 422                  * the vcc usuable again.  Since xmit is serialized,
 423                  * this is the only situation we have to re-test.
 424                  */
 425
 426                 if (atm_may_send(vcc, 0))
 427                         netif_wake_queue(dev);
 428         }
 429
 430 out:
 431         if (entry)
 432                 lec_arp_put(entry);
 433         dev->trans_start = jiffies;
 434         return 0;
 435 }
 436
 437 /* The inverse routine to net_open(). */
 438 static int lec_close(struct net_device *dev)
 439 {
 440         netif_stop_queue(dev);
 441         return 0;
 442 }
 443
 444 /*
 445  * Get the current statistics.
 446  * This may be called with the card open or closed.
 447  */
 448 static struct net_device_stats *lec_get_stats(struct net_device *dev)
 449 {
 450         return &((struct lec_priv *)dev->priv)->stats;
 451 }
 452
 453 static int lec_atm_send(struct atm_vcc *vcc, struct sk_buff *skb)
 454 {
 455         unsigned long flags;
 456         struct net_device *dev = (struct net_device *)vcc->proto_data;
 457         struct lec_priv *priv = (struct lec_priv *)dev->priv;
 458         struct atmlec_msg *mesg;
 459         struct lec_arp_table *entry;
 460         int i;
 461         char *tmp;              /* FIXME */
 462
 463         atomic_sub(skb->truesize, &sk_atm(vcc)->sk_wmem_alloc);
 464         mesg = (struct atmlec_msg *)skb->data;
 465         tmp = skb->data;
 466         tmp += sizeof(struct atmlec_msg);
 467         DPRINTK("%s: msg from zeppelin:%d\n", dev->name, mesg->type);
 468         switch (mesg->type) {
 469         case l_set_mac_addr:
 470                 for (i = 0; i < 6; i++) {
 471                         dev->dev_addr[i] = mesg->content.normal.mac_addr[i];
 472                 }
 473                 break;
 474         case l_del_mac_addr:
 475                 for (i = 0; i < 6; i++) {
 476                         dev->dev_addr[i] = 0;
 477                 }
 478                 break;
 479         case l_addr_delete:
 480                 lec_addr_delete(priv, mesg->content.normal.atm_addr,
 481                                 mesg->content.normal.flag);
 482                 break;
 483         case l_topology_change:
 484                 priv->topology_change = mesg->content.normal.flag;
 485                 break;
 486         case l_flush_complete:
 487                 lec_flush_complete(priv, mesg->content.normal.flag);
 488                 break;
 489         case l_narp_req:        /* LANE2: see 7.1.35 in the lane2 spec */
 490                 spin_lock_irqsave(&priv->lec_arp_lock, flags);
 491                 entry = lec_arp_find(priv, mesg->content.normal.mac_addr);
 492                 lec_arp_remove(priv, entry);
 493                 spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
 494
 495                 if (mesg->content.normal.no_source_le_narp)
 496                         break;
 497                 /* FALL THROUGH */
 498         case l_arp_update:
 499                 lec_arp_update(priv, mesg->content.normal.mac_addr,
 500                                mesg->content.normal.atm_addr,
 501                                mesg->content.normal.flag,
 502                                mesg->content.normal.targetless_le_arp);
 503                 DPRINTK("lec: in l_arp_update\n");
 504                 if (mesg->sizeoftlvs != 0) {    /* LANE2 3.1.5 */
 505                         DPRINTK("lec: LANE2 3.1.5, got tlvs, size %d\n",
 506                                 mesg->sizeoftlvs);
 507                         lane2_associate_ind(dev, mesg->content.normal.mac_addr,
 508                                             tmp, mesg->sizeoftlvs);
 509                 }
 510                 break;
 511         case l_config:
 512                 priv->maximum_unknown_frame_count =
 513                     mesg->content.config.maximum_unknown_frame_count;
 514                 priv->max_unknown_frame_time =
 515                     (mesg->content.config.max_unknown_frame_time * HZ);
 516                 priv->max_retry_count = mesg->content.config.max_retry_count;
 517                 priv->aging_time = (mesg->content.config.aging_time * HZ);
 518                 priv->forward_delay_time =
 519                     (mesg->content.config.forward_delay_time * HZ);
 520                 priv->arp_response_time =
 521                     (mesg->content.config.arp_response_time * HZ);
 522                 priv->flush_timeout = (mesg->content.config.flush_timeout * HZ);
 523                 priv->path_switching_delay =
 524                     (mesg->content.config.path_switching_delay * HZ);
 525                 priv->lane_version = mesg->content.config.lane_version; /* LANE2 */
 526                 priv->lane2_ops = NULL;
 527                 if (priv->lane_version > 1)
 528                         priv->lane2_ops = &lane2_ops;
 529                 if (dev->change_mtu(dev, mesg->content.config.mtu))
 530                         printk("%s: change_mtu to %d failed\n", dev->name,
 531                                mesg->content.config.mtu);
 532                 priv->is_proxy = mesg->content.config.is_proxy;
 533                 break;
 534         case l_flush_tran_id:
 535                 lec_set_flush_tran_id(priv, mesg->content.normal.atm_addr,
 536                                       mesg->content.normal.flag);
 537                 break;
 538         case l_set_lecid:
 539                 priv->lecid =
 540                     (unsigned short)(0xffff & mesg->content.normal.flag);
 541                 break;
 542         case l_should_bridge:
 543 #if defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)
 544                 {
 545                         struct net_bridge_fdb_entry *f;
 546
 547                         DPRINTK
 548                             ("%s: bridge zeppelin asks about 0x%02x:%02x:%02x:%02x:%02x:%02x\n",
 549                              dev->name, mesg->content.proxy.mac_addr[0],
 550                              mesg->content.proxy.mac_addr[1],
 551                              mesg->content.proxy.mac_addr[2],
 552                              mesg->content.proxy.mac_addr[3],
 553                              mesg->content.proxy.mac_addr[4],
 554                              mesg->content.proxy.mac_addr[5]);
 555
 556                         if (br_fdb_get_hook == NULL || dev->br_port == NULL)
 557                                 break;
 558
 559                         f = br_fdb_get_hook(dev->br_port->br,
 560                                             mesg->content.proxy.mac_addr);
 561                         if (f != NULL && f->dst->dev != dev
 562                             && f->dst->state == BR_STATE_FORWARDING) {
 563                                 /* hit from bridge table, send LE_ARP_RESPONSE */
 564                                 struct sk_buff *skb2;
 565                                 struct sock *sk;
 566
 567                                 DPRINTK
 568                                     ("%s: entry found, responding to zeppelin\n",
 569                                      dev->name);
 570                                 skb2 =
 571                                     alloc_skb(sizeof(struct atmlec_msg),
 572                                               GFP_ATOMIC);
 573                                 if (skb2 == NULL) {
 574                                         br_fdb_put_hook(f);
 575                                         break;
 576                                 }
 577                                 skb2->len = sizeof(struct atmlec_msg);
 578                                 skb_copy_to_linear_data(skb2, mesg,
 579                                                         sizeof(*mesg));
 580                                 atm_force_charge(priv->lecd, skb2->truesize);
 581                                 sk = sk_atm(priv->lecd);
 582                                 skb_queue_tail(&sk->sk_receive_queue, skb2);
 583                                 sk->sk_data_ready(sk, skb2->len);
 584                         }
 585                         if (f != NULL)
 586                                 br_fdb_put_hook(f);
 587                 }
 588 #endif /* defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE) */
 589                 break;
 590         default:
 591                 printk("%s: Unknown message type %d\n", dev->name, mesg->type);
 592                 dev_kfree_skb(skb);
 593                 return -EINVAL;
 594         }
 595         dev_kfree_skb(skb);
 596         return 0;
 597 }
 598
 599 static void lec_atm_close(struct atm_vcc *vcc)
 600 {
 601         struct sk_buff *skb;
 602         struct net_device *dev = (struct net_device *)vcc->proto_data;
 603         struct lec_priv *priv = (struct lec_priv *)dev->priv;
 604
 605         priv->lecd = NULL;
 606         /* Do something needful? */
 607
 608         netif_stop_queue(dev);
 609         lec_arp_destroy(priv);
 610
 611         if (skb_peek(&sk_atm(vcc)->sk_receive_queue))
 612                 printk("%s lec_atm_close: closing with messages pending\n",
 613                        dev->name);
 614         while ((skb = skb_dequeue(&sk_atm(vcc)->sk_receive_queue)) != NULL) {
 615                 atm_return(vcc, skb->truesize);
 616                 dev_kfree_skb(skb);
 617         }
 618
 619         printk("%s: Shut down!\n", dev->name);
 620         module_put(THIS_MODULE);
 621 }
 622
 623 static struct atmdev_ops lecdev_ops = {
 624         .close = lec_atm_close,
 625         .send = lec_atm_send
 626 };
 627
 628 static struct atm_dev lecatm_dev = {
 629         .ops = &lecdev_ops,
 630         .type = "lec",
 631         .number = 999,          /* dummy device number */
 632         .lock = __SPIN_LOCK_UNLOCKED(lecatm_dev.lock)
 633 };
 634
 635 /*
 636  * LANE2: new argument struct sk_buff *data contains
 637  * the LE_ARP based TLVs introduced in the LANE2 spec
 638  */
 639 static int
 640 send_to_lecd(struct lec_priv *priv, atmlec_msg_type type,
 641              unsigned char *mac_addr, unsigned char *atm_addr,
 642              struct sk_buff *data)
 643 {
 644         struct sock *sk;
 645         struct sk_buff *skb;
 646         struct atmlec_msg *mesg;
 647
 648         if (!priv || !priv->lecd) {
 649                 return -1;
 650         }
 651         skb = alloc_skb(sizeof(struct atmlec_msg), GFP_ATOMIC);
 652         if (!skb)
 653                 return -1;
 654         skb->len = sizeof(struct atmlec_msg);
 655         mesg = (struct atmlec_msg *)skb->data;
 656         memset(mesg, 0, sizeof(struct atmlec_msg));
 657         mesg->type = type;
 658         if (data != NULL)
 659                 mesg->sizeoftlvs = data->len;
 660         if (mac_addr)
 661                 memcpy(&mesg->content.normal.mac_addr, mac_addr, ETH_ALEN);
 662         else
 663                 mesg->content.normal.targetless_le_arp = 1;
 664         if (atm_addr)
 665                 memcpy(&mesg->content.normal.atm_addr, atm_addr, ATM_ESA_LEN);
 666
 667         atm_force_charge(priv->lecd, skb->truesize);
 668         sk = sk_atm(priv->lecd);
 669         skb_queue_tail(&sk->sk_receive_queue, skb);
 670         sk->sk_data_ready(sk, skb->len);
 671
 672         if (data != NULL) {
 673                 DPRINTK("lec: about to send %d bytes of data\n", data->len);
 674                 atm_force_charge(priv->lecd, data->truesize);
 675                 skb_queue_tail(&sk->sk_receive_queue, data);
 676                 sk->sk_data_ready(sk, skb->len);
 677         }
 678
 679         return 0;
 680 }
 681
 682 /* shamelessly stolen from drivers/net/net_init.c */
 683 static int lec_change_mtu(struct net_device *dev, int new_mtu)
 684 {
 685         if ((new_mtu < 68) || (new_mtu > 18190))
 686                 return -EINVAL;
 687         dev->mtu = new_mtu;
 688         return 0;
 689 }
 690
 691 static void lec_set_multicast_list(struct net_device *dev)
 692 {
 693         /*
 694          * by default, all multicast frames arrive over the bus.
 695          * eventually support selective multicast service
 696          */
 697         return;
 698 }
 699
 700 static void lec_init(struct net_device *dev)
 701 {
 702         dev->change_mtu = lec_change_mtu;
 703         dev->open = lec_open;
 704         dev->stop = lec_close;
 705         dev->hard_start_xmit = lec_start_xmit;
 706         dev->tx_timeout = lec_tx_timeout;
 707
 708         dev->get_stats = lec_get_stats;
 709         dev->set_multicast_list = lec_set_multicast_list;
 710         dev->do_ioctl = NULL;
 711         printk("%s: Initialized!\n", dev->name);
 712         return;
 713 }
 714
 715 static unsigned char lec_ctrl_magic[] = {
 716         0xff,
 717         0x00,
 718         0x01,
 719         0x01
 720 };
 721
 722 #define LEC_DATA_DIRECT_8023  2
 723 #define LEC_DATA_DIRECT_8025  3
 724
 725 static int lec_is_data_direct(struct atm_vcc *vcc)
 726 {
 727         return ((vcc->sap.blli[0].l3.tr9577.snap[4] == LEC_DATA_DIRECT_8023) ||
 728                 (vcc->sap.blli[0].l3.tr9577.snap[4] == LEC_DATA_DIRECT_8025));
 729 }
 730
 731 static void lec_push(struct atm_vcc *vcc, struct sk_buff *skb)
 732 {
 733         unsigned long flags;
 734         struct net_device *dev = (struct net_device *)vcc->proto_data;
 735         struct lec_priv *priv = (struct lec_priv *)dev->priv;
 736
 737 #if DUMP_PACKETS >0
 738         int i = 0;
 739         char buf[300];
 740
 741         printk("%s: lec_push vcc vpi:%d vci:%d\n", dev->name,
 742                vcc->vpi, vcc->vci);
 743 #endif
 744         if (!skb) {
 745                 DPRINTK("%s: null skb\n", dev->name);
 746                 lec_vcc_close(priv, vcc);
 747                 return;
 748         }
 749 #if DUMP_PACKETS > 0
 750         printk("%s: rcv datalen:%ld lecid:%4.4x\n", dev->name,
 751                skb->len, priv->lecid);
 752 #if DUMP_PACKETS >= 2
 753         for (i = 0; i < skb->len && i < 99; i++) {
 754                 sprintf(buf + i * 3, "%2.2x ", 0xff & skb->data[i]);
 755         }
 756 #elif DUMP_PACKETS >= 1
 757         for (i = 0; i < skb->len && i < 30; i++) {
 758                 sprintf(buf + i * 3, "%2.2x ", 0xff & skb->data[i]);
 759         }
 760 #endif /* DUMP_PACKETS >= 1 */
 761         if (i == skb->len)
 762                 printk("%s\n", buf);
 763         else
 764                 printk("%s...\n", buf);
 765 #endif /* DUMP_PACKETS > 0 */
 766         if (memcmp(skb->data, lec_ctrl_magic, 4) == 0) {        /* Control frame, to daemon */
 767                 struct sock *sk = sk_atm(vcc);
 768
 769                 DPRINTK("%s: To daemon\n", dev->name);
 770                 skb_queue_tail(&sk->sk_receive_queue, skb);
 771                 sk->sk_data_ready(sk, skb->len);
 772         } else {                /* Data frame, queue to protocol handlers */
 773                 struct lec_arp_table *entry;
 774                 unsigned char *src, *dst;
 775
 776                 atm_return(vcc, skb->truesize);
 777                 if (*(__be16 *) skb->data == htons(priv->lecid) ||
 778                     !priv->lecd || !(dev->flags & IFF_UP)) {
 779                         /*
 780                          * Probably looping back, or if lecd is missing,
 781                          * lecd has gone down
 782                          */
 783                         DPRINTK("Ignoring frame...\n");
 784                         dev_kfree_skb(skb);
 785                         return;
 786                 }
 787 #ifdef CONFIG_TR
 788                 if (priv->is_trdev)
 789                         dst = ((struct lecdatahdr_8025 *)skb->data)->h_dest;
 790                 else
 791 #endif
 792                         dst = ((struct lecdatahdr_8023 *)skb->data)->h_dest;
 793
 794                 /*
 795                  * If this is a Data Direct VCC, and the VCC does not match
 796                  * the LE_ARP cache entry, delete the LE_ARP cache entry.
 797                  */
 798                 spin_lock_irqsave(&priv->lec_arp_lock, flags);
 799                 if (lec_is_data_direct(vcc)) {
 800 #ifdef CONFIG_TR
 801                         if (priv->is_trdev)
 802                                 src =
 803                                     ((struct lecdatahdr_8025 *)skb->data)->
 804                                     h_source;
 805                         else
 806 #endif
 807                                 src =
 808                                     ((struct lecdatahdr_8023 *)skb->data)->
 809                                     h_source;
 810                         entry = lec_arp_find(priv, src);
 811                         if (entry && entry->vcc != vcc) {
 812                                 lec_arp_remove(priv, entry);
 813                                 lec_arp_put(entry);
 814                         }
 815                 }
 816                 spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
 817
 818                 if (!(dst[0] & 0x01) && /* Never filter Multi/Broadcast */
 819                     !priv->is_proxy &&  /* Proxy wants all the packets */
 820                     memcmp(dst, dev->dev_addr, dev->addr_len)) {
 821                         dev_kfree_skb(skb);
 822                         return;
 823                 }
 824                 if (!hlist_empty(&priv->lec_arp_empty_ones)) {
 825                         lec_arp_check_empties(priv, vcc, skb);
 826                 }
 827                 skb_pull(skb, 2);       /* skip lec_id */
 828 #ifdef CONFIG_TR
 829                 if (priv->is_trdev)
 830                         skb->protocol = tr_type_trans(skb, dev);
 831                 else
 832 #endif
 833                         skb->protocol = eth_type_trans(skb, dev);
 834                 priv->stats.rx_packets++;
 835                 priv->stats.rx_bytes += skb->len;
 836                 memset(ATM_SKB(skb), 0, sizeof(struct atm_skb_data));
 837                 netif_rx(skb);
 838         }
 839 }
 840
 841 static void lec_pop(struct atm_vcc *vcc, struct sk_buff *skb)
 842 {
 843         struct lec_vcc_priv *vpriv = LEC_VCC_PRIV(vcc);
 844         struct net_device *dev = skb->dev;
 845
 846         if (vpriv == NULL) {
 847                 printk("lec_pop(): vpriv = NULL!?!?!?\n");
 848                 return;
 849         }
 850
 851         vpriv->old_pop(vcc, skb);
 852
 853         if (vpriv->xoff && atm_may_send(vcc, 0)) {
 854                 vpriv->xoff = 0;
 855                 if (netif_running(dev) && netif_queue_stopped(dev))
 856                         netif_wake_queue(dev);
 857         }
 858 }
 859
 860 static int lec_vcc_attach(struct atm_vcc *vcc, void __user *arg)
 861 {
 862         struct lec_vcc_priv *vpriv;
 863         int bytes_left;
 864         struct atmlec_ioc ioc_data;
 865
 866         /* Lecd must be up in this case */
 867         bytes_left = copy_from_user(&ioc_data, arg, sizeof(struct atmlec_ioc));
 868         if (bytes_left != 0) {
 869                 printk
 870                     ("lec: lec_vcc_attach, copy from user failed for %d bytes\n",
 871                      bytes_left);
 872         }
 873         if (ioc_data.dev_num < 0 || ioc_data.dev_num >= MAX_LEC_ITF ||
 874             !dev_lec[ioc_data.dev_num])
 875                 return -EINVAL;
 876         if (!(vpriv = kmalloc(sizeof(struct lec_vcc_priv), GFP_KERNEL)))
 877                 return -ENOMEM;
 878         vpriv->xoff = 0;
 879         vpriv->old_pop = vcc->pop;
 880         vcc->user_back = vpriv;
 881         vcc->pop = lec_pop;
 882         lec_vcc_added(dev_lec[ioc_data.dev_num]->priv,
 883                       &ioc_data, vcc, vcc->push);
 884         vcc->proto_data = dev_lec[ioc_data.dev_num];
 885         vcc->push = lec_push;
 886         return 0;
 887 }
 888
 889 static int lec_mcast_attach(struct atm_vcc *vcc, int arg)
 890 {
 891         if (arg < 0 || arg >= MAX_LEC_ITF || !dev_lec[arg])
 892                 return -EINVAL;
 893         vcc->proto_data = dev_lec[arg];
 894         return (lec_mcast_make((struct lec_priv *)dev_lec[arg]->priv, vcc));
 895 }
 896
 897 /* Initialize device. */
 898 static int lecd_attach(struct atm_vcc *vcc, int arg)
 899 {
 900         int i;
 901         struct lec_priv *priv;
 902
 903         if (arg < 0)
 904                 i = 0;
 905         else
 906                 i = arg;
 907 #ifdef CONFIG_TR
 908         if (arg >= MAX_LEC_ITF)
 909                 return -EINVAL;
 910 #else                           /* Reserve the top NUM_TR_DEVS for TR */
 911         if (arg >= (MAX_LEC_ITF - NUM_TR_DEVS))
 912                 return -EINVAL;
 913 #endif
 914         if (!dev_lec[i]) {
 915                 int is_trdev, size;
 916
 917                 is_trdev = 0;
 918                 if (i >= (MAX_LEC_ITF - NUM_TR_DEVS))
 919                         is_trdev = 1;
 920
 921                 size = sizeof(struct lec_priv);
 922 #ifdef CONFIG_TR
 923                 if (is_trdev)
 924                         dev_lec[i] = alloc_trdev(size);
 925                 else
 926 #endif
 927                         dev_lec[i] = alloc_etherdev(size);
 928                 if (!dev_lec[i])
 929                         return -ENOMEM;
 930                 snprintf(dev_lec[i]->name, IFNAMSIZ, "lec%d", i);
 931                 if (register_netdev(dev_lec[i])) {
 932                         free_netdev(dev_lec[i]);
 933                         return -EINVAL;
 934                 }
 935
 936                 priv = dev_lec[i]->priv;
 937                 priv->is_trdev = is_trdev;
 938                 lec_init(dev_lec[i]);
 939         } else {
 940                 priv = dev_lec[i]->priv;
 941                 if (priv->lecd)
 942                         return -EADDRINUSE;
 943         }
 944         lec_arp_init(priv);
 945         priv->itfnum = i;       /* LANE2 addition */
 946         priv->lecd = vcc;
 947         vcc->dev = &lecatm_dev;
 948         vcc_insert_socket(sk_atm(vcc));
 949
 950         vcc->proto_data = dev_lec[i];
 951         set_bit(ATM_VF_META, &vcc->flags);
 952         set_bit(ATM_VF_READY, &vcc->flags);
 953
 954         /* Set default values to these variables */
 955         priv->maximum_unknown_frame_count = 1;
 956         priv->max_unknown_frame_time = (1 * HZ);
 957         priv->vcc_timeout_period = (1200 * HZ);
 958         priv->max_retry_count = 1;
 959         priv->aging_time = (300 * HZ);
 960         priv->forward_delay_time = (15 * HZ);
 961         priv->topology_change = 0;
 962         priv->arp_response_time = (1 * HZ);
 963         priv->flush_timeout = (4 * HZ);
 964         priv->path_switching_delay = (6 * HZ);
 965
 966         if (dev_lec[i]->flags & IFF_UP) {
 967                 netif_start_queue(dev_lec[i]);
 968         }
 969         __module_get(THIS_MODULE);
 970         return i;
 971 }
 972
 973 #ifdef CONFIG_PROC_FS
 974 static char *lec_arp_get_status_string(unsigned char status)
 975 {
 976         static char *lec_arp_status_string[] = {
 977                 "ESI_UNKNOWN       ",
 978                 "ESI_ARP_PENDING   ",
 979                 "ESI_VC_PENDING    ",
 980                 "<Undefined>       ",
 981                 "ESI_FLUSH_PENDING ",
 982                 "ESI_FORWARD_DIRECT"
 983         };
 984
 985         if (status > ESI_FORWARD_DIRECT)
 986                 status = 3;     /* ESI_UNDEFINED */
 987         return lec_arp_status_string[status];
 988 }
 989
 990 static void lec_info(struct seq_file *seq, struct lec_arp_table *entry)
 991 {
 992         int i;
 993
 994         for (i = 0; i < ETH_ALEN; i++)
 995                 seq_printf(seq, "%2.2x", entry->mac_addr[i] & 0xff);
 996         seq_printf(seq, " ");
 997         for (i = 0; i < ATM_ESA_LEN; i++)
 998                 seq_printf(seq, "%2.2x", entry->atm_addr[i] & 0xff);
 999         seq_printf(seq, " %s %4.4x", lec_arp_get_status_string(entry->status),
1000                    entry->flags & 0xffff);
1001         if (entry->vcc)
1002                 seq_printf(seq, "%3d %3d ", entry->vcc->vpi, entry->vcc->vci);
1003         else
1004                 seq_printf(seq, "        ");
1005         if (entry->recv_vcc) {
1006                 seq_printf(seq, "     %3d %3d", entry->recv_vcc->vpi,
1007                            entry->recv_vcc->vci);
1008         }
1009         seq_putc(seq, '\n');
1010 }
1011
1012 struct lec_state {
1013         unsigned long flags;
1014         struct lec_priv *locked;
1015         struct hlist_node *node;
1016         struct net_device *dev;
1017         int itf;
1018         int arp_table;
1019         int misc_table;
1020 };
1021
1022 static void *lec_tbl_walk(struct lec_state *state, struct hlist_head *tbl,
1023                           loff_t *l)
1024 {
1025         struct hlist_node *e = state->node;
1026         struct lec_arp_table *tmp;
1027
1028         if (!e)
1029                 e = tbl->first;
1030         if (e == (void *)1) {
1031                 e = tbl->first;
1032                 --*l;
1033         }
1034
1035         hlist_for_each_entry_from(tmp, e, next) {
1036                 if (--*l < 0)
1037                         break;
1038         }
1039         state->node = e;
1040
1041         return (*l < 0) ? state : NULL;
1042 }
1043
1044 static void *lec_arp_walk(struct lec_state *state, loff_t *l,
1045                           struct lec_priv *priv)
1046 {
1047         void *v = NULL;
1048         int p;
1049
1050         for (p = state->arp_table; p < LEC_ARP_TABLE_SIZE; p++) {
1051                 v = lec_tbl_walk(state, &priv->lec_arp_tables[p], l);
1052                 if (v)
1053                         break;
1054         }
1055         state->arp_table = p;
1056         return v;
1057 }
1058
1059 static void *lec_misc_walk(struct lec_state *state, loff_t *l,
1060                            struct lec_priv *priv)
1061 {
1062         struct hlist_head *lec_misc_tables[] = {
1063                 &priv->lec_arp_empty_ones,
1064                 &priv->lec_no_forward,
1065                 &priv->mcast_fwds
1066         };
1067         void *v = NULL;
1068         int q;
1069
1070         for (q = state->misc_table; q < ARRAY_SIZE(lec_misc_tables); q++) {
1071                 v = lec_tbl_walk(state, lec_misc_tables[q], l);
1072                 if (v)
1073                         break;
1074         }
1075         state->misc_table = q;
1076         return v;
1077 }
1078
1079 static void *lec_priv_walk(struct lec_state *state, loff_t *l,
1080                            struct lec_priv *priv)
1081 {
1082         if (!state->locked) {
1083                 state->locked = priv;
1084                 spin_lock_irqsave(&priv->lec_arp_lock, state->flags);
1085         }
1086         if (!lec_arp_walk(state, l, priv) && !lec_misc_walk(state, l, priv)) {
1087                 spin_unlock_irqrestore(&priv->lec_arp_lock, state->flags);
1088                 state->locked = NULL;
1089                 /* Partial state reset for the next time we get called */
1090                 state->arp_table = state->misc_table = 0;
1091         }
1092         return state->locked;
1093 }
1094
1095 static void *lec_itf_walk(struct lec_state *state, loff_t *l)
1096 {
1097         struct net_device *dev;
1098         void *v;
1099
1100         dev = state->dev ? state->dev : dev_lec[state->itf];
1101         v = (dev && dev->priv) ? lec_priv_walk(state, l, dev->priv) : NULL;
1102         if (!v && dev) {
1103                 dev_put(dev);
1104                 /* Partial state reset for the next time we get called */
1105                 dev = NULL;
1106         }
1107         state->dev = dev;
1108         return v;
1109 }
1110
1111 static void *lec_get_idx(struct lec_state *state, loff_t l)
1112 {
1113         void *v = NULL;
1114
1115         for (; state->itf < MAX_LEC_ITF; state->itf++) {
1116                 v = lec_itf_walk(state, &l);
1117                 if (v)
1118                         break;
1119         }
1120         return v;
1121 }
1122
1123 static void *lec_seq_start(struct seq_file *seq, loff_t *pos)
1124 {
1125         struct lec_state *state = seq->private;
1126
1127         state->itf = 0;
1128         state->dev = NULL;
1129         state->locked = NULL;
1130         state->arp_table = 0;
1131         state->misc_table = 0;
1132         state->node = (void *)1;
1133
1134         return *pos ? lec_get_idx(state, *pos) : (void *)1;
1135 }
1136
1137 static void lec_seq_stop(struct seq_file *seq, void *v)
1138 {
1139         struct lec_state *state = seq->private;
1140
1141         if (state->dev) {
1142                 spin_unlock_irqrestore(&state->locked->lec_arp_lock,
1143                                        state->flags);
1144                 dev_put(state->dev);
1145         }
1146 }
1147
1148 static void *lec_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1149 {
1150         struct lec_state *state = seq->private;
1151
1152         v = lec_get_idx(state, 1);
1153         *pos += !!PTR_ERR(v);
1154         return v;
1155 }
1156
1157 static int lec_seq_show(struct seq_file *seq, void *v)
1158 {
1159         static char lec_banner[] = "Itf  MAC          ATM destination"
1160             "                          Status            Flags "
1161             "VPI/VCI Recv VPI/VCI\n";
1162
1163         if (v == (void *)1)
1164                 seq_puts(seq, lec_banner);
1165         else {
1166                 struct lec_state *state = seq->private;
1167                 struct net_device *dev = state->dev;
1168                 struct lec_arp_table *entry = hlist_entry(state->node, struct lec_arp_table, next);
1169
1170                 seq_printf(seq, "%s ", dev->name);
1171                 lec_info(seq, entry);
1172         }
1173         return 0;
1174 }
1175
1176 static const struct seq_operations lec_seq_ops = {
1177         .start = lec_seq_start,
1178         .next = lec_seq_next,
1179         .stop = lec_seq_stop,
1180         .show = lec_seq_show,
1181 };
1182
1183 static int lec_seq_open(struct inode *inode, struct file *file)
1184 {
1185         struct lec_state *state;
1186         struct seq_file *seq;
1187         int rc = -EAGAIN;
1188
1189         state = kmalloc(sizeof(*state), GFP_KERNEL);
1190         if (!state) {
1191                 rc = -ENOMEM;
1192                 goto out;
1193         }
1194
1195         rc = seq_open(file, &lec_seq_ops);
1196         if (rc)
1197                 goto out_kfree;
1198         seq = file->private_data;
1199         seq->private = state;
1200 out:
1201         return rc;
1202
1203 out_kfree:
1204         kfree(state);
1205         goto out;
1206 }
1207
1208 static int lec_seq_release(struct inode *inode, struct file *file)
1209 {
1210         return seq_release_private(inode, file);
1211 }
1212
1213 static const struct file_operations lec_seq_fops = {
1214         .owner = THIS_MODULE,
1215         .open = lec_seq_open,
1216         .read = seq_read,
1217         .llseek = seq_lseek,
1218         .release = lec_seq_release,
1219 };
1220 #endif
1221
1222 static int lane_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1223 {
1224         struct atm_vcc *vcc = ATM_SD(sock);
1225         int err = 0;
1226
1227         switch (cmd) {
1228         case ATMLEC_CTRL:
1229         case ATMLEC_MCAST:
1230         case ATMLEC_DATA:
1231                 if (!capable(CAP_NET_ADMIN))
1232                         return -EPERM;
1233                 break;
1234         default:
1235                 return -ENOIOCTLCMD;
1236         }
1237
1238         switch (cmd) {
1239         case ATMLEC_CTRL:
1240                 err = lecd_attach(vcc, (int)arg);
1241                 if (err >= 0)
1242                         sock->state = SS_CONNECTED;
1243                 break;
1244         case ATMLEC_MCAST:
1245                 err = lec_mcast_attach(vcc, (int)arg);
1246                 break;
1247         case ATMLEC_DATA:
1248                 err = lec_vcc_attach(vcc, (void __user *)arg);
1249                 break;
1250         }
1251
1252         return err;
1253 }
1254
1255 static struct atm_ioctl lane_ioctl_ops = {
1256         .owner = THIS_MODULE,
1257         .ioctl = lane_ioctl,
1258 };
1259
1260 static int __init lane_module_init(void)
1261 {
1262 #ifdef CONFIG_PROC_FS
1263         struct proc_dir_entry *p;
1264
1265         p = create_proc_entry("lec", S_IRUGO, atm_proc_root);
1266         if (p)
1267                 p->proc_fops = &lec_seq_fops;
1268 #endif
1269
1270         register_atm_ioctl(&lane_ioctl_ops);
1271         printk("lec.c: " __DATE__ " " __TIME__ " initialized\n");
1272         return 0;
1273 }
1274
1275 static void __exit lane_module_cleanup(void)
1276 {
1277         int i;
1278         struct lec_priv *priv;
1279
1280         remove_proc_entry("lec", atm_proc_root);
1281
1282         deregister_atm_ioctl(&lane_ioctl_ops);
1283
1284         for (i = 0; i < MAX_LEC_ITF; i++) {
1285                 if (dev_lec[i] != NULL) {
1286                         priv = (struct lec_priv *)dev_lec[i]->priv;
1287                         unregister_netdev(dev_lec[i]);
1288                         free_netdev(dev_lec[i]);
1289                         dev_lec[i] = NULL;
1290                 }
1291         }
1292
1293         return;
1294 }
1295
1296 module_init(lane_module_init);
1297 module_exit(lane_module_cleanup);
1298
1299 /*
1300  * LANE2: 3.1.3, LE_RESOLVE.request
1301  * Non force allocates memory and fills in *tlvs, fills in *sizeoftlvs.
1302  * If sizeoftlvs == NULL the default TLVs associated with with this
1303  * lec will be used.
1304  * If dst_mac == NULL, targetless LE_ARP will be sent
1305  */
1306 static int lane2_resolve(struct net_device *dev, u8 *dst_mac, int force,
1307                          u8 **tlvs, u32 *sizeoftlvs)
1308 {
1309         unsigned long flags;
1310         struct lec_priv *priv = (struct lec_priv *)dev->priv;
1311         struct lec_arp_table *table;
1312         struct sk_buff *skb;
1313         int retval;
1314
1315         if (force == 0) {
1316                 spin_lock_irqsave(&priv->lec_arp_lock, flags);
1317                 table = lec_arp_find(priv, dst_mac);
1318                 spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
1319                 if (table == NULL)
1320                         return -1;
1321
1322                 *tlvs = kmemdup(table->tlvs, table->sizeoftlvs, GFP_ATOMIC);
1323                 if (*tlvs == NULL)
1324                         return -1;
1325
1326                 *sizeoftlvs = table->sizeoftlvs;
1327
1328                 return 0;
1329         }
1330
1331         if (sizeoftlvs == NULL)
1332                 retval = send_to_lecd(priv, l_arp_xmt, dst_mac, NULL, NULL);
1333
1334         else {
1335                 skb = alloc_skb(*sizeoftlvs, GFP_ATOMIC);
1336                 if (skb == NULL)
1337                         return -1;
1338                 skb->len = *sizeoftlvs;
1339                 skb_copy_to_linear_data(skb, *tlvs, *sizeoftlvs);
1340                 retval = send_to_lecd(priv, l_arp_xmt, dst_mac, NULL, skb);
1341         }
1342         return retval;
1343 }
1344
1345 /*
1346  * LANE2: 3.1.4, LE_ASSOCIATE.request
1347  * Associate the *tlvs with the *lan_dst address.
1348  * Will overwrite any previous association
1349  * Returns 1 for success, 0 for failure (out of memory)
1350  *
1351  */
1352 static int lane2_associate_req(struct net_device *dev, u8 *lan_dst,
1353                                u8 *tlvs, u32 sizeoftlvs)
1354 {
1355         int retval;
1356         struct sk_buff *skb;
1357         struct lec_priv *priv = (struct lec_priv *)dev->priv;
1358
1359         if (compare_ether_addr(lan_dst, dev->dev_addr))
1360                 return (0);     /* not our mac address */
1361
1362         kfree(priv->tlvs);      /* NULL if there was no previous association */
1363
1364         priv->tlvs = kmemdup(tlvs, sizeoftlvs, GFP_KERNEL);
1365         if (priv->tlvs == NULL)
1366                 return (0);
1367         priv->sizeoftlvs = sizeoftlvs;
1368
1369         skb = alloc_skb(sizeoftlvs, GFP_ATOMIC);
1370         if (skb == NULL)
1371                 return 0;
1372         skb->len = sizeoftlvs;
1373         skb_copy_to_linear_data(skb, tlvs, sizeoftlvs);
1374         retval = send_to_lecd(priv, l_associate_req, NULL, NULL, skb);
1375         if (retval != 0)
1376                 printk("lec.c: lane2_associate_req() failed\n");
1377         /*
1378          * If the previous association has changed we must
1379          * somehow notify other LANE entities about the change
1380          */
1381         return (1);
1382 }
1383
1384 /*
1385  * LANE2: 3.1.5, LE_ASSOCIATE.indication
1386  *
1387  */
1388 static void lane2_associate_ind(struct net_device *dev, u8 *mac_addr,
1389                                 u8 *tlvs, u32 sizeoftlvs)
1390 {
1391 #if 0
1392         int i = 0;
1393 #endif
1394         struct lec_priv *priv = (struct lec_priv *)dev->priv;
1395 #if 0                           /*
1396                                  * Why have the TLVs in LE_ARP entries
1397                                  * since we do not use them? When you
1398                                  * uncomment this code, make sure the
1399                                  * TLVs get freed when entry is killed
1400                                  */
1401         struct lec_arp_table *entry = lec_arp_find(priv, mac_addr);
1402
1403         if (entry == NULL)
1404                 return;         /* should not happen */
1405
1406         kfree(entry->tlvs);
1407
1408         entry->tlvs = kmemdup(tlvs, sizeoftlvs, GFP_KERNEL);
1409         if (entry->tlvs == NULL)
1410                 return;
1411         entry->sizeoftlvs = sizeoftlvs;
1412 #endif
1413 #if 0
1414         printk("lec.c: lane2_associate_ind()\n");
1415         printk("dump of tlvs, sizeoftlvs=%d\n", sizeoftlvs);
1416         while (i < sizeoftlvs)
1417                 printk("%02x ", tlvs[i++]);
1418
1419         printk("\n");
1420 #endif
1421
1422         /* tell MPOA about the TLVs we saw */
1423         if (priv->lane2_ops && priv->lane2_ops->associate_indicator) {
1424                 priv->lane2_ops->associate_indicator(dev, mac_addr,
1425                                                      tlvs, sizeoftlvs);
1426         }
1427         return;
1428 }
1429
1430 /*
1431  * Here starts what used to lec_arpc.c
1432  *
1433  * lec_arpc.c was added here when making
1434  * lane client modular. October 1997
1435  */
1436
1437 #include <linux/types.h>
1438 #include <linux/timer.h>
1439 #include <asm/param.h>
1440 #include <asm/atomic.h>
1441 #include <linux/inetdevice.h>
1442 #include <net/route.h>
1443
1444 #if 0
1445 #define DPRINTK(format,args...)
1446 /*
1447 #define DPRINTK printk
1448 */
1449 #endif
1450 #define DEBUG_ARP_TABLE 0
1451
1452 #define LEC_ARP_REFRESH_INTERVAL (3*HZ)
1453
1454 static void lec_arp_check_expire(struct work_struct *work);
1455 static void lec_arp_expire_arp(unsigned long data);
1456
1457 /*
1458  * Arp table funcs
1459  */
1460
1461 #define HASH(ch) (ch & (LEC_ARP_TABLE_SIZE -1))
1462
1463 /*
1464  * Initialization of arp-cache
1465  */
1466 static void lec_arp_init(struct lec_priv *priv)
1467 {
1468         unsigned short i;
1469
1470         for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) {
1471                 INIT_HLIST_HEAD(&priv->lec_arp_tables[i]);
1472         }
1473         INIT_HLIST_HEAD(&priv->lec_arp_empty_ones);
1474         INIT_HLIST_HEAD(&priv->lec_no_forward);
1475         INIT_HLIST_HEAD(&priv->mcast_fwds);
1476         spin_lock_init(&priv->lec_arp_lock);
1477         INIT_DELAYED_WORK(&priv->lec_arp_work, lec_arp_check_expire);
1478         schedule_delayed_work(&priv->lec_arp_work, LEC_ARP_REFRESH_INTERVAL);
1479 }
1480
1481 static void lec_arp_clear_vccs(struct lec_arp_table *entry)
1482 {
1483         if (entry->vcc) {
1484                 struct atm_vcc *vcc = entry->vcc;
1485                 struct lec_vcc_priv *vpriv = LEC_VCC_PRIV(vcc);
1486                 struct net_device *dev = (struct net_device *)vcc->proto_data;
1487
1488                 vcc->pop = vpriv->old_pop;
1489                 if (vpriv->xoff)
1490                         netif_wake_queue(dev);
1491                 kfree(vpriv);
1492                 vcc->user_back = NULL;
1493                 vcc->push = entry->old_push;
1494                 vcc_release_async(vcc, -EPIPE);
1495                 entry->vcc = NULL;
1496         }
1497         if (entry->recv_vcc) {
1498                 entry->recv_vcc->push = entry->old_recv_push;
1499                 vcc_release_async(entry->recv_vcc, -EPIPE);
1500                 entry->recv_vcc = NULL;
1501         }
1502 }
1503
1504 /*
1505  * Insert entry to lec_arp_table
1506  * LANE2: Add to the end of the list to satisfy 8.1.13
1507  */
1508 static inline void
1509 lec_arp_add(struct lec_priv *priv, struct lec_arp_table *entry)
1510 {
1511         struct hlist_head *tmp;
1512
1513         tmp = &priv->lec_arp_tables[HASH(entry->mac_addr[ETH_ALEN - 1])];
1514         hlist_add_head(&entry->next, tmp);
1515
1516         DPRINTK("LEC_ARP: Added entry:%2.2x %2.2x %2.2x %2.2x %2.2x %2.2x\n",
1517                 0xff & entry->mac_addr[0], 0xff & entry->mac_addr[1],
1518                 0xff & entry->mac_addr[2], 0xff & entry->mac_addr[3],
1519                 0xff & entry->mac_addr[4], 0xff & entry->mac_addr[5]);
1520 }
1521
1522 /*
1523  * Remove entry from lec_arp_table
1524  */
1525 static int
1526 lec_arp_remove(struct lec_priv *priv, struct lec_arp_table *to_remove)
1527 {
1528         struct hlist_node *node;
1529         struct lec_arp_table *entry;
1530         int i, remove_vcc = 1;
1531
1532         if (!to_remove) {
1533                 return -1;
1534         }
1535
1536         hlist_del(&to_remove->next);
1537         del_timer(&to_remove->timer);
1538
1539         /* If this is the only MAC connected to this VCC, also tear down the VCC */
1540         if (to_remove->status >= ESI_FLUSH_PENDING) {
1541                 /*
1542                  * ESI_FLUSH_PENDING, ESI_FORWARD_DIRECT
1543                  */
1544                 for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) {
1545                         hlist_for_each_entry(entry, node, &priv->lec_arp_tables[i], next) {
1546                                 if (memcmp(to_remove->atm_addr,
1547                                            entry->atm_addr, ATM_ESA_LEN) == 0) {
1548                                         remove_vcc = 0;
1549                                         break;
1550                                 }
1551                         }
1552                 }
1553                 if (remove_vcc)
1554                         lec_arp_clear_vccs(to_remove);
1555         }
1556         skb_queue_purge(&to_remove->tx_wait);   /* FIXME: good place for this? */
1557
1558         DPRINTK("LEC_ARP: Removed entry:%2.2x %2.2x %2.2x %2.2x %2.2x %2.2x\n",
1559                 0xff & to_remove->mac_addr[0], 0xff & to_remove->mac_addr[1],
1560                 0xff & to_remove->mac_addr[2], 0xff & to_remove->mac_addr[3],
1561                 0xff & to_remove->mac_addr[4], 0xff & to_remove->mac_addr[5]);
1562         return 0;
1563 }
1564
1565 #if DEBUG_ARP_TABLE
1566 static char *get_status_string(unsigned char st)
1567 {
1568         switch (st) {
1569         case ESI_UNKNOWN:
1570                 return "ESI_UNKNOWN";
1571         case ESI_ARP_PENDING:
1572                 return "ESI_ARP_PENDING";
1573         case ESI_VC_PENDING:
1574                 return "ESI_VC_PENDING";
1575         case ESI_FLUSH_PENDING:
1576                 return "ESI_FLUSH_PENDING";
1577         case ESI_FORWARD_DIRECT:
1578                 return "ESI_FORWARD_DIRECT";
1579         default:
1580                 return "<UNKNOWN>";
1581         }
1582 }
1583
1584 static void dump_arp_table(struct lec_priv *priv)
1585 {
1586         struct hlist_node *node;
1587         struct lec_arp_table *rulla;
1588         char buf[256];
1589         int i, j, offset;
1590
1591         printk("Dump %p:\n", priv);
1592         for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) {
1593                 hlist_for_each_entry(rulla, node, &priv->lec_arp_tables[i], next) {
1594                         offset = 0;
1595                         offset += sprintf(buf, "%d: %p\n", i, rulla);
1596                         offset += sprintf(buf + offset, "Mac:");
1597                         for (j = 0; j < ETH_ALEN; j++) {
1598                                 offset += sprintf(buf + offset,
1599                                                   "%2.2x ",
1600                                                   rulla->mac_addr[j] & 0xff);
1601                         }
1602                         offset += sprintf(buf + offset, "Atm:");
1603                         for (j = 0; j < ATM_ESA_LEN; j++) {
1604                                 offset += sprintf(buf + offset,
1605                                                   "%2.2x ",
1606                                                   rulla->atm_addr[j] & 0xff);
1607                         }
1608                         offset += sprintf(buf + offset,
1609                                           "Vcc vpi:%d vci:%d, Recv_vcc vpi:%d vci:%d Last_used:%lx, Timestamp:%lx, No_tries:%d ",
1610                                           rulla->vcc ? rulla->vcc->vpi : 0,
1611                                           rulla->vcc ? rulla->vcc->vci : 0,
1612                                           rulla->recv_vcc ? rulla->recv_vcc->
1613                                           vpi : 0,
1614                                           rulla->recv_vcc ? rulla->recv_vcc->
1615                                           vci : 0, rulla->last_used,
1616                                           rulla->timestamp, rulla->no_tries);
1617                         offset +=
1618                             sprintf(buf + offset,
1619                                     "Flags:%x, Packets_flooded:%x, Status: %s ",
1620                                     rulla->flags, rulla->packets_flooded,
1621                                     get_status_string(rulla->status));
1622                         printk("%s\n", buf);
1623                 }
1624         }
1625
1626         if (!hlist_empty(&priv->lec_no_forward))
1627                 printk("No forward\n");
1628         hlist_for_each_entry(rulla, node, &priv->lec_no_forward, next) {
1629                 offset = 0;
1630                 offset += sprintf(buf + offset, "Mac:");
1631                 for (j = 0; j < ETH_ALEN; j++) {
1632                         offset += sprintf(buf + offset, "%2.2x ",
1633                                           rulla->mac_addr[j] & 0xff);
1634                 }
1635                 offset += sprintf(buf + offset, "Atm:");
1636                 for (j = 0; j < ATM_ESA_LEN; j++) {
1637                         offset += sprintf(buf + offset, "%2.2x ",
1638                                           rulla->atm_addr[j] & 0xff);
1639                 }
1640                 offset += sprintf(buf + offset,
1641                                   "Vcc vpi:%d vci:%d, Recv_vcc vpi:%d vci:%d Last_used:%lx, Timestamp:%lx, No_tries:%d ",
1642                                   rulla->vcc ? rulla->vcc->vpi : 0,
1643                                   rulla->vcc ? rulla->vcc->vci : 0,
1644                                   rulla->recv_vcc ? rulla->recv_vcc->vpi : 0,
1645                                   rulla->recv_vcc ? rulla->recv_vcc->vci : 0,
1646                                   rulla->last_used,
1647                                   rulla->timestamp, rulla->no_tries);
1648                 offset += sprintf(buf + offset,
1649                                   "Flags:%x, Packets_flooded:%x, Status: %s ",
1650                                   rulla->flags, rulla->packets_flooded,
1651                                   get_status_string(rulla->status));
1652                 printk("%s\n", buf);
1653         }
1654
1655         if (!hlist_empty(&priv->lec_arp_empty_ones))
1656                 printk("Empty ones\n");
1657         hlist_for_each_entry(rulla, node, &priv->lec_arp_empty_ones, next) {
1658                 offset = 0;
1659                 offset += sprintf(buf + offset, "Mac:");
1660                 for (j = 0; j < ETH_ALEN; j++) {
1661                         offset += sprintf(buf + offset, "%2.2x ",
1662                                           rulla->mac_addr[j] & 0xff);
1663                 }
1664                 offset += sprintf(buf + offset, "Atm:");
1665                 for (j = 0; j < ATM_ESA_LEN; j++) {
1666                         offset += sprintf(buf + offset, "%2.2x ",
1667                                           rulla->atm_addr[j] & 0xff);
1668                 }
1669                 offset += sprintf(buf + offset,
1670                                   "Vcc vpi:%d vci:%d, Recv_vcc vpi:%d vci:%d Last_used:%lx, Timestamp:%lx, No_tries:%d ",
1671                                   rulla->vcc ? rulla->vcc->vpi : 0,
1672                                   rulla->vcc ? rulla->vcc->vci : 0,
1673                                   rulla->recv_vcc ? rulla->recv_vcc->vpi : 0,
1674                                   rulla->recv_vcc ? rulla->recv_vcc->vci : 0,
1675                                   rulla->last_used,
1676                                   rulla->timestamp, rulla->no_tries);
1677                 offset += sprintf(buf + offset,
1678                                   "Flags:%x, Packets_flooded:%x, Status: %s ",
1679                                   rulla->flags, rulla->packets_flooded,
1680                                   get_status_string(rulla->status));
1681                 printk("%s", buf);
1682         }
1683
1684         if (!hlist_empty(&priv->mcast_fwds))
1685                 printk("Multicast Forward VCCs\n");
1686         hlist_for_each_entry(rulla, node, &priv->mcast_fwds, next) {
1687                 offset = 0;
1688                 offset += sprintf(buf + offset, "Mac:");
1689                 for (j = 0; j < ETH_ALEN; j++) {
1690                         offset += sprintf(buf + offset, "%2.2x ",
1691                                           rulla->mac_addr[j] & 0xff);
1692                 }
1693                 offset += sprintf(buf + offset, "Atm:");
1694                 for (j = 0; j < ATM_ESA_LEN; j++) {
1695                         offset += sprintf(buf + offset, "%2.2x ",
1696                                           rulla->atm_addr[j] & 0xff);
1697                 }
1698                 offset += sprintf(buf + offset,
1699                                   "Vcc vpi:%d vci:%d, Recv_vcc vpi:%d vci:%d Last_used:%lx, Timestamp:%lx, No_tries:%d ",
1700                                   rulla->vcc ? rulla->vcc->vpi : 0,
1701                                   rulla->vcc ? rulla->vcc->vci : 0,
1702                                   rulla->recv_vcc ? rulla->recv_vcc->vpi : 0,
1703                                   rulla->recv_vcc ? rulla->recv_vcc->vci : 0,
1704                                   rulla->last_used,
1705                                   rulla->timestamp, rulla->no_tries);
1706                 offset += sprintf(buf + offset,
1707                                   "Flags:%x, Packets_flooded:%x, Status: %s ",
1708                                   rulla->flags, rulla->packets_flooded,
1709                                   get_status_string(rulla->status));
1710                 printk("%s\n", buf);
1711         }
1712
1713 }
1714 #else
1715 #define dump_arp_table(priv) do { } while (0)
1716 #endif
1717
1718 /*
1719  * Destruction of arp-cache
1720  */
1721 static void lec_arp_destroy(struct lec_priv *priv)
1722 {
1723         unsigned long flags;
1724         struct hlist_node *node, *next;
1725         struct lec_arp_table *entry;
1726         int i;
1727
1728         cancel_rearming_delayed_work(&priv->lec_arp_work);
1729
1730         /*
1731          * Remove all entries
1732          */
1733
1734         spin_lock_irqsave(&priv->lec_arp_lock, flags);
1735         for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) {
1736                 hlist_for_each_entry_safe(entry, node, next, &priv->lec_arp_tables[i], next) {
1737                         lec_arp_remove(priv, entry);
1738                         lec_arp_put(entry);
1739                 }
1740                 INIT_HLIST_HEAD(&priv->lec_arp_tables[i]);
1741         }
1742
1743         hlist_for_each_entry_safe(entry, node, next, &priv->lec_arp_empty_ones, next) {
1744                 del_timer_sync(&entry->timer);
1745                 lec_arp_clear_vccs(entry);
1746                 hlist_del(&entry->next);
1747                 lec_arp_put(entry);
1748         }
1749         INIT_HLIST_HEAD(&priv->lec_arp_empty_ones);
1750
1751         hlist_for_each_entry_safe(entry, node, next, &priv->lec_no_forward, next) {
1752                 del_timer_sync(&entry->timer);
1753                 lec_arp_clear_vccs(entry);
1754                 hlist_del(&entry->next);
1755                 lec_arp_put(entry);
1756         }
1757         INIT_HLIST_HEAD(&priv->lec_no_forward);
1758
1759         hlist_for_each_entry_safe(entry, node, next, &priv->mcast_fwds, next) {
1760                 /* No timer, LANEv2 7.1.20 and 2.3.5.3 */
1761                 lec_arp_clear_vccs(entry);
1762                 hlist_del(&entry->next);
1763                 lec_arp_put(entry);
1764         }
1765         INIT_HLIST_HEAD(&priv->mcast_fwds);
1766         priv->mcast_vcc = NULL;
1767         spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
1768 }
1769
1770 /*
1771  * Find entry by mac_address
1772  */
1773 static struct lec_arp_table *lec_arp_find(struct lec_priv *priv,
1774                                           unsigned char *mac_addr)
1775 {
1776         struct hlist_node *node;
1777         struct hlist_head *head;
1778         struct lec_arp_table *entry;
1779
1780         DPRINTK("LEC_ARP: lec_arp_find :%2.2x %2.2x %2.2x %2.2x %2.2x %2.2x\n",
1781                 mac_addr[0] & 0xff, mac_addr[1] & 0xff, mac_addr[2] & 0xff,
1782                 mac_addr[3] & 0xff, mac_addr[4] & 0xff, mac_addr[5] & 0xff);
1783
1784         head = &priv->lec_arp_tables[HASH(mac_addr[ETH_ALEN - 1])];
1785         hlist_for_each_entry(entry, node, head, next) {
1786                 if (!compare_ether_addr(mac_addr, entry->mac_addr)) {
1787                         return entry;
1788                 }
1789         }
1790         return NULL;
1791 }
1792
1793 static struct lec_arp_table *make_entry(struct lec_priv *priv,
1794                                         unsigned char *mac_addr)
1795 {
1796         struct lec_arp_table *to_return;
1797
1798         to_return = kzalloc(sizeof(struct lec_arp_table), GFP_ATOMIC);
1799         if (!to_return) {
1800                 printk("LEC: Arp entry kmalloc failed\n");
1801                 return NULL;
1802         }
1803         memcpy(to_return->mac_addr, mac_addr, ETH_ALEN);
1804         INIT_HLIST_NODE(&to_return->next);
1805         init_timer(&to_return->timer);
1806         to_return->timer.function = lec_arp_expire_arp;
1807         to_return->timer.data = (unsigned long)to_return;
1808         to_return->last_used = jiffies;
1809         to_return->priv = priv;
1810         skb_queue_head_init(&to_return->tx_wait);
1811         atomic_set(&to_return->usage, 1);
1812         return to_return;
1813 }
1814
1815 /* Arp sent timer expired */
1816 static void lec_arp_expire_arp(unsigned long data)
1817 {
1818         struct lec_arp_table *entry;
1819
1820         entry = (struct lec_arp_table *)data;
1821
1822         DPRINTK("lec_arp_expire_arp\n");
1823         if (entry->status == ESI_ARP_PENDING) {
1824                 if (entry->no_tries <= entry->priv->max_retry_count) {
1825                         if (entry->is_rdesc)
1826                                 send_to_lecd(entry->priv, l_rdesc_arp_xmt,
1827                                              entry->mac_addr, NULL, NULL);
1828                         else
1829                                 send_to_lecd(entry->priv, l_arp_xmt,
1830                                              entry->mac_addr, NULL, NULL);
1831                         entry->no_tries++;
1832                 }
1833                 mod_timer(&entry->timer, jiffies + (1 * HZ));
1834         }
1835 }
1836
1837 /* Unknown/unused vcc expire, remove associated entry */
1838 static void lec_arp_expire_vcc(unsigned long data)
1839 {
1840         unsigned long flags;
1841         struct lec_arp_table *to_remove = (struct lec_arp_table *)data;
1842         struct lec_priv *priv = (struct lec_priv *)to_remove->priv;
1843
1844         del_timer(&to_remove->timer);
1845
1846         DPRINTK("LEC_ARP %p %p: lec_arp_expire_vcc vpi:%d vci:%d\n",
1847                 to_remove, priv,
1848                 to_remove->vcc ? to_remove->recv_vcc->vpi : 0,
1849                 to_remove->vcc ? to_remove->recv_vcc->vci : 0);
1850
1851         spin_lock_irqsave(&priv->lec_arp_lock, flags);
1852         hlist_del(&to_remove->next);
1853         spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
1854
1855         lec_arp_clear_vccs(to_remove);
1856         lec_arp_put(to_remove);
1857 }
1858
1859 /*
1860  * Expire entries.
1861  * 1. Re-set timer
1862  * 2. For each entry, delete entries that have aged past the age limit.
1863  * 3. For each entry, depending on the status of the entry, perform
1864  *    the following maintenance.
1865  *    a. If status is ESI_VC_PENDING or ESI_ARP_PENDING then if the
1866  *       tick_count is above the max_unknown_frame_time, clear
1867  *       the tick_count to zero and clear the packets_flooded counter
1868  *       to zero. This supports the packet rate limit per address
1869  *       while flooding unknowns.
1870  *    b. If the status is ESI_FLUSH_PENDING and the tick_count is greater
1871  *       than or equal to the path_switching_delay, change the status
1872  *       to ESI_FORWARD_DIRECT. This causes the flush period to end
1873  *       regardless of the progress of the flush protocol.
1874  */
1875 static void lec_arp_check_expire(struct work_struct *work)
1876 {
1877         unsigned long flags;
1878         struct lec_priv *priv =
1879                 container_of(work, struct lec_priv, lec_arp_work.work);
1880         struct hlist_node *node, *next;
1881         struct lec_arp_table *entry;
1882         unsigned long now;
1883         unsigned long time_to_check;
1884         int i;
1885
1886         DPRINTK("lec_arp_check_expire %p\n", priv);
1887         now = jiffies;
1888 restart:
1889         spin_lock_irqsave(&priv->lec_arp_lock, flags);
1890         for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) {
1891                 hlist_for_each_entry_safe(entry, node, next, &priv->lec_arp_tables[i], next) {
1892                         if ((entry->flags) & LEC_REMOTE_FLAG &&
1893                             priv->topology_change)
1894                                 time_to_check = priv->forward_delay_time;
1895                         else
1896                                 time_to_check = priv->aging_time;
1897
1898                         DPRINTK("About to expire: %lx - %lx > %lx\n",
1899                                 now, entry->last_used, time_to_check);
1900                         if (time_after(now, entry->last_used + time_to_check)
1901                             && !(entry->flags & LEC_PERMANENT_FLAG)
1902                             && !(entry->mac_addr[0] & 0x01)) {  /* LANE2: 7.1.20 */
1903                                 /* Remove entry */
1904                                 DPRINTK("LEC:Entry timed out\n");
1905                                 lec_arp_remove(priv, entry);
1906                                 lec_arp_put(entry);
1907                         } else {
1908                                 /* Something else */
1909                                 if ((entry->status == ESI_VC_PENDING ||
1910                                      entry->status == ESI_ARP_PENDING)
1911                                     && time_after_eq(now,
1912                                                      entry->timestamp +
1913                                                      priv->
1914                                                      max_unknown_frame_time)) {
1915                                         entry->timestamp = jiffies;
1916                                         entry->packets_flooded = 0;
1917                                         if (entry->status == ESI_VC_PENDING)
1918                                                 send_to_lecd(priv, l_svc_setup,
1919                                                              entry->mac_addr,
1920                                                              entry->atm_addr,
1921                                                              NULL);
1922                                 }
1923                                 if (entry->status == ESI_FLUSH_PENDING
1924                                     &&
1925                                     time_after_eq(now, entry->timestamp +
1926                                                   priv->path_switching_delay)) {
1927                                         struct sk_buff *skb;
1928                                         struct atm_vcc *vcc = entry->vcc;
1929
1930                                         lec_arp_hold(entry);
1931                                         spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
1932                                         while ((skb = skb_dequeue(&entry->tx_wait)) != NULL)
1933                                                 lec_send(vcc, skb, entry->priv);
1934                                         entry->last_used = jiffies;
1935                                         entry->status = ESI_FORWARD_DIRECT;
1936                                         lec_arp_put(entry);
1937                                         goto restart;
1938                                 }
1939                         }
1940                 }
1941         }
1942         spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
1943
1944         schedule_delayed_work(&priv->lec_arp_work, LEC_ARP_REFRESH_INTERVAL);
1945 }
1946
1947 /*
1948  * Try to find vcc where mac_address is attached.
1949  *
1950  */
1951 static struct atm_vcc *lec_arp_resolve(struct lec_priv *priv,
1952                                        unsigned char *mac_to_find, int is_rdesc,
1953                                        struct lec_arp_table **ret_entry)
1954 {
1955         unsigned long flags;
1956         struct lec_arp_table *entry;
1957         struct atm_vcc *found;
1958
1959         if (mac_to_find[0] & 0x01) {
1960                 switch (priv->lane_version) {
1961                 case 1:
1962                         return priv->mcast_vcc;
1963                         break;
1964                 case 2: /* LANE2 wants arp for multicast addresses */
1965                         if (!compare_ether_addr(mac_to_find, bus_mac))
1966                                 return priv->mcast_vcc;
1967                         break;
1968                 default:
1969                         break;
1970                 }
1971         }
1972
1973         spin_lock_irqsave(&priv->lec_arp_lock, flags);
1974         entry = lec_arp_find(priv, mac_to_find);
1975
1976         if (entry) {
1977                 if (entry->status == ESI_FORWARD_DIRECT) {
1978                         /* Connection Ok */
1979                         entry->last_used = jiffies;
1980                         lec_arp_hold(entry);
1981                         *ret_entry = entry;
1982                         found = entry->vcc;
1983                         goto out;
1984                 }
1985                 /*
1986                  * If the LE_ARP cache entry is still pending, reset count to 0
1987                  * so another LE_ARP request can be made for this frame.
1988                  */
1989                 if (entry->status == ESI_ARP_PENDING) {
1990                         entry->no_tries = 0;
1991                 }
1992                 /*
1993                  * Data direct VC not yet set up, check to see if the unknown
1994                  * frame count is greater than the limit. If the limit has
1995                  * not been reached, allow the caller to send packet to
1996                  * BUS.
1997                  */
1998                 if (entry->status != ESI_FLUSH_PENDING &&
1999                     entry->packets_flooded <
2000                     priv->maximum_unknown_frame_count) {
2001                         entry->packets_flooded++;
2002                         DPRINTK("LEC_ARP: Flooding..\n");
2003                         found = priv->mcast_vcc;
2004                         goto out;
2005                 }
2006                 /*
2007                  * We got here because entry->status == ESI_FLUSH_PENDING
2008                  * or BUS flood limit was reached for an entry which is
2009                  * in ESI_ARP_PENDING or ESI_VC_PENDING state.
2010                  */
2011                 lec_arp_hold(entry);
2012                 *ret_entry = entry;
2013                 DPRINTK("lec: entry->status %d entry->vcc %p\n", entry->status,
2014                         entry->vcc);
2015                 found = NULL;
2016         } else {
2017                 /* No matching entry was found */
2018                 entry = make_entry(priv, mac_to_find);
2019                 DPRINTK("LEC_ARP: Making entry\n");
2020                 if (!entry) {
2021                         found = priv->mcast_vcc;
2022                         goto out;
2023                 }
2024                 lec_arp_add(priv, entry);
2025                 /* We want arp-request(s) to be sent */
2026                 entry->packets_flooded = 1;
2027                 entry->status = ESI_ARP_PENDING;
2028                 entry->no_tries = 1;
2029                 entry->last_used = entry->timestamp = jiffies;
2030                 entry->is_rdesc = is_rdesc;
2031                 if (entry->is_rdesc)
2032                         send_to_lecd(priv, l_rdesc_arp_xmt, mac_to_find, NULL,
2033                                      NULL);
2034                 else
2035                         send_to_lecd(priv, l_arp_xmt, mac_to_find, NULL, NULL);
2036                 entry->timer.expires = jiffies + (1 * HZ);
2037                 entry->timer.function = lec_arp_expire_arp;
2038                 add_timer(&entry->timer);
2039                 found = priv->mcast_vcc;
2040         }
2041
2042 out:
2043         spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
2044         return found;
2045 }
2046
2047 static int
2048 lec_addr_delete(struct lec_priv *priv, unsigned char *atm_addr,
2049                 unsigned long permanent)
2050 {
2051         unsigned long flags;
2052         struct hlist_node *node, *next;
2053         struct lec_arp_table *entry;
2054         int i;
2055
2056         DPRINTK("lec_addr_delete\n");
2057         spin_lock_irqsave(&priv->lec_arp_lock, flags);
2058         for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) {
2059                 hlist_for_each_entry_safe(entry, node, next, &priv->lec_arp_tables[i], next) {
2060                         if (!memcmp(atm_addr, entry->atm_addr, ATM_ESA_LEN)
2061                             && (permanent ||
2062                                 !(entry->flags & LEC_PERMANENT_FLAG))) {
2063                                 lec_arp_remove(priv, entry);
2064                                 lec_arp_put(entry);
2065                         }
2066                         spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
2067                         return 0;
2068                 }
2069         }
2070         spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
2071         return -1;
2072 }
2073
2074 /*
2075  * Notifies:  Response to arp_request (atm_addr != NULL)
2076  */
2077 static void
2078 lec_arp_update(struct lec_priv *priv, unsigned char *mac_addr,
2079                unsigned char *atm_addr, unsigned long remoteflag,
2080                unsigned int targetless_le_arp)
2081 {
2082         unsigned long flags;
2083         struct hlist_node *node, *next;
2084         struct lec_arp_table *entry, *tmp;
2085         int i;
2086
2087         DPRINTK("lec:%s", (targetless_le_arp) ? "targetless " : " ");
2088         DPRINTK("lec_arp_update mac:%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x\n",
2089                 mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3],
2090                 mac_addr[4], mac_addr[5]);
2091
2092         spin_lock_irqsave(&priv->lec_arp_lock, flags);
2093         entry = lec_arp_find(priv, mac_addr);
2094         if (entry == NULL && targetless_le_arp)
2095                 goto out;       /*
2096                                  * LANE2: ignore targetless LE_ARPs for which
2097                                  * we have no entry in the cache. 7.1.30
2098                                  */
2099         if (!hlist_empty(&priv->lec_arp_empty_ones)) {
2100                 hlist_for_each_entry_safe(entry, node, next, &priv->lec_arp_empty_ones, next) {
2101                         if (memcmp(entry->atm_addr, atm_addr, ATM_ESA_LEN) == 0) {
2102                                 hlist_del(&entry->next);
2103                                 del_timer(&entry->timer);
2104                                 tmp = lec_arp_find(priv, mac_addr);
2105                                 if (tmp) {
2106                                         del_timer(&tmp->timer);
2107                                         tmp->status = ESI_FORWARD_DIRECT;
2108                                         memcpy(tmp->atm_addr, atm_addr, ATM_ESA_LEN);
2109                                         tmp->vcc = entry->vcc;
2110                                         tmp->old_push = entry->old_push;
2111                                         tmp->last_used = jiffies;
2112                                         del_timer(&entry->timer);
2113                                         lec_arp_put(entry);
2114                                         entry = tmp;
2115                                 } else {
2116                                         entry->status = ESI_FORWARD_DIRECT;
2117                                         memcpy(entry->mac_addr, mac_addr, ETH_ALEN);
2118                                         entry->last_used = jiffies;
2119                                         lec_arp_add(priv, entry);
2120                                 }
2121                                 if (remoteflag)
2122                                         entry->flags |= LEC_REMOTE_FLAG;
2123                                 else
2124                                         entry->flags &= ~LEC_REMOTE_FLAG;
2125                                 DPRINTK("After update\n");
2126                                 dump_arp_table(priv);
2127                                 goto out;
2128                         }
2129                 }
2130         }
2131
2132         entry = lec_arp_find(priv, mac_addr);
2133         if (!entry) {
2134                 entry = make_entry(priv, mac_addr);
2135                 if (!entry)
2136                         goto out;
2137                 entry->status = ESI_UNKNOWN;
2138                 lec_arp_add(priv, entry);
2139                 /* Temporary, changes before end of function */
2140         }
2141         memcpy(entry->atm_addr, atm_addr, ATM_ESA_LEN);
2142         del_timer(&entry->timer);
2143         for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) {
2144                 hlist_for_each_entry(tmp, node, &priv->lec_arp_tables[i], next) {
2145                         if (entry != tmp &&
2146                             !memcmp(tmp->atm_addr, atm_addr, ATM_ESA_LEN)) {
2147                                 /* Vcc to this host exists */
2148                                 if (tmp->status > ESI_VC_PENDING) {
2149                                         /*
2150                                          * ESI_FLUSH_PENDING,
2151                                          * ESI_FORWARD_DIRECT
2152                                          */
2153                                         entry->vcc = tmp->vcc;
2154                                         entry->old_push = tmp->old_push;
2155                                 }
2156                                 entry->status = tmp->status;
2157                                 break;
2158                         }
2159                 }
2160         }
2161         if (remoteflag)
2162                 entry->flags |= LEC_REMOTE_FLAG;
2163         else
2164                 entry->flags &= ~LEC_REMOTE_FLAG;
2165         if (entry->status == ESI_ARP_PENDING || entry->status == ESI_UNKNOWN) {
2166                 entry->status = ESI_VC_PENDING;
2167                 send_to_lecd(priv, l_svc_setup, entry->mac_addr, atm_addr, NULL);
2168         }
2169         DPRINTK("After update2\n");
2170         dump_arp_table(priv);
2171 out:
2172         spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
2173 }
2174
2175 /*
2176  * Notifies: Vcc setup ready
2177  */
2178 static void
2179 lec_vcc_added(struct lec_priv *priv, struct atmlec_ioc *ioc_data,
2180               struct atm_vcc *vcc,
2181               void (*old_push) (struct atm_vcc *vcc, struct sk_buff *skb))
2182 {
2183         unsigned long flags;
2184         struct hlist_node *node;
2185         struct lec_arp_table *entry;
2186         int i, found_entry = 0;
2187
2188         spin_lock_irqsave(&priv->lec_arp_lock, flags);
2189         if (ioc_data->receive == 2) {
2190                 /* Vcc for Multicast Forward. No timer, LANEv2 7.1.20 and 2.3.5.3 */
2191
2192                 DPRINTK("LEC_ARP: Attaching mcast forward\n");
2193 #if 0
2194                 entry = lec_arp_find(priv, bus_mac);
2195                 if (!entry) {
2196                         printk("LEC_ARP: Multicast entry not found!\n");
2197                         goto out;
2198                 }
2199                 memcpy(entry->atm_addr, ioc_data->atm_addr, ATM_ESA_LEN);
2200                 entry->recv_vcc = vcc;
2201                 entry->old_recv_push = old_push;
2202 #endif
2203                 entry = make_entry(priv, bus_mac);
2204                 if (entry == NULL)
2205                         goto out;
2206                 del_timer(&entry->timer);
2207                 memcpy(entry->atm_addr, ioc_data->atm_addr, ATM_ESA_LEN);
2208                 entry->recv_vcc = vcc;
2209                 entry->old_recv_push = old_push;
2210                 hlist_add_head(&entry->next, &priv->mcast_fwds);
2211                 goto out;
2212         } else if (ioc_data->receive == 1) {
2213                 /*
2214                  * Vcc which we don't want to make default vcc,
2215                  * attach it anyway.
2216                  */
2217                 DPRINTK
2218                     ("LEC_ARP:Attaching data direct, not default: "
2219                      "%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x\n",
2220                      ioc_data->atm_addr[0], ioc_data->atm_addr[1],
2221                      ioc_data->atm_addr[2], ioc_data->atm_addr[3],
2222                      ioc_data->atm_addr[4], ioc_data->atm_addr[5],
2223                      ioc_data->atm_addr[6], ioc_data->atm_addr[7],
2224                      ioc_data->atm_addr[8], ioc_data->atm_addr[9],
2225                      ioc_data->atm_addr[10], ioc_data->atm_addr[11],
2226                      ioc_data->atm_addr[12], ioc_data->atm_addr[13],
2227                      ioc_data->atm_addr[14], ioc_data->atm_addr[15],
2228                      ioc_data->atm_addr[16], ioc_data->atm_addr[17],
2229                      ioc_data->atm_addr[18], ioc_data->atm_addr[19]);
2230                 entry = make_entry(priv, bus_mac);
2231                 if (entry == NULL)
2232                         goto out;
2233                 memcpy(entry->atm_addr, ioc_data->atm_addr, ATM_ESA_LEN);
2234                 memset(entry->mac_addr, 0, ETH_ALEN);
2235                 entry->recv_vcc = vcc;
2236                 entry->old_recv_push = old_push;
2237                 entry->status = ESI_UNKNOWN;
2238                 entry->timer.expires = jiffies + priv->vcc_timeout_period;
2239                 entry->timer.function = lec_arp_expire_vcc;
2240                 hlist_add_head(&entry->next, &priv->lec_no_forward);
2241                 add_timer(&entry->timer);
2242                 dump_arp_table(priv);
2243                 goto out;
2244         }
2245         DPRINTK
2246             ("LEC_ARP:Attaching data direct, default: "
2247              "%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x\n",
2248              ioc_data->atm_addr[0], ioc_data->atm_addr[1],
2249              ioc_data->atm_addr[2], ioc_data->atm_addr[3],
2250              ioc_data->atm_addr[4], ioc_data->atm_addr[5],
2251              ioc_data->atm_addr[6], ioc_data->atm_addr[7],
2252              ioc_data->atm_addr[8], ioc_data->atm_addr[9],
2253              ioc_data->atm_addr[10], ioc_data->atm_addr[11],
2254              ioc_data->atm_addr[12], ioc_data->atm_addr[13],
2255              ioc_data->atm_addr[14], ioc_data->atm_addr[15],
2256              ioc_data->atm_addr[16], ioc_data->atm_addr[17],
2257              ioc_data->atm_addr[18], ioc_data->atm_addr[19]);
2258         for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) {
2259                 hlist_for_each_entry(entry, node, &priv->lec_arp_tables[i], next) {
2260                         if (memcmp
2261                             (ioc_data->atm_addr, entry->atm_addr,
2262                              ATM_ESA_LEN) == 0) {
2263                                 DPRINTK("LEC_ARP: Attaching data direct\n");
2264                                 DPRINTK("Currently -> Vcc: %d, Rvcc:%d\n",
2265                                         entry->vcc ? entry->vcc->vci : 0,
2266                                         entry->recv_vcc ? entry->recv_vcc->
2267                                         vci : 0);
2268                                 found_entry = 1;
2269                                 del_timer(&entry->timer);
2270                                 entry->vcc = vcc;
2271                                 entry->old_push = old_push;
2272                                 if (entry->status == ESI_VC_PENDING) {
2273                                         if (priv->maximum_unknown_frame_count
2274                                             == 0)
2275                                                 entry->status =
2276                                                     ESI_FORWARD_DIRECT;
2277                                         else {
2278                                                 entry->timestamp = jiffies;
2279                                                 entry->status =
2280                                                     ESI_FLUSH_PENDING;
2281 #if 0
2282                                                 send_to_lecd(priv, l_flush_xmt,
2283                                                              NULL,
2284                                                              entry->atm_addr,
2285                                                              NULL);
2286 #endif
2287                                         }
2288                                 } else {
2289                                         /*
2290                                          * They were forming a connection
2291                                          * to us, and we to them. Our
2292                                          * ATM address is numerically lower
2293                                          * than theirs, so we make connection
2294                                          * we formed into default VCC (8.1.11).
2295                                          * Connection they made gets torn
2296                                          * down. This might confuse some
2297                                          * clients. Can be changed if
2298                                          * someone reports trouble...
2299                                          */
2300                                         ;
2301                                 }
2302                         }
2303                 }
2304         }
2305         if (found_entry) {
2306                 DPRINTK("After vcc was added\n");
2307                 dump_arp_table(priv);
2308                 goto out;
2309         }
2310         /*
2311          * Not found, snatch address from first data packet that arrives
2312          * from this vcc
2313          */
2314         entry = make_entry(priv, bus_mac);
2315         if (!entry)
2316                 goto out;
2317         entry->vcc = vcc;
2318         entry->old_push = old_push;
2319         memcpy(entry->atm_addr, ioc_data->atm_addr, ATM_ESA_LEN);
2320         memset(entry->mac_addr, 0, ETH_ALEN);
2321         entry->status = ESI_UNKNOWN;
2322         hlist_add_head(&entry->next, &priv->lec_arp_empty_ones);
2323         entry->timer.expires = jiffies + priv->vcc_timeout_period;
2324         entry->timer.function = lec_arp_expire_vcc;
2325         add_timer(&entry->timer);
2326         DPRINTK("After vcc was added\n");
2327         dump_arp_table(priv);
2328 out:
2329         spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
2330 }
2331
2332 static void lec_flush_complete(struct lec_priv *priv, unsigned long tran_id)
2333 {
2334         unsigned long flags;
2335         struct hlist_node *node;
2336         struct lec_arp_table *entry;
2337         int i;
2338
2339         DPRINTK("LEC:lec_flush_complete %lx\n", tran_id);
2340 restart:
2341         spin_lock_irqsave(&priv->lec_arp_lock, flags);
2342         for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) {
2343                 hlist_for_each_entry(entry, node, &priv->lec_arp_tables[i], next) {
2344                         if (entry->flush_tran_id == tran_id
2345                             && entry->status == ESI_FLUSH_PENDING) {
2346                                 struct sk_buff *skb;
2347                                 struct atm_vcc *vcc = entry->vcc;
2348
2349                                 lec_arp_hold(entry);
2350                                 spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
2351                                 while ((skb = skb_dequeue(&entry->tx_wait)) != NULL)
2352                                         lec_send(vcc, skb, entry->priv);
2353                                 entry->last_used = jiffies;
2354                                 entry->status = ESI_FORWARD_DIRECT;
2355                                 lec_arp_put(entry);
2356                                 DPRINTK("LEC_ARP: Flushed\n");
2357                                 goto restart;
2358                         }
2359                 }
2360         }
2361         spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
2362         dump_arp_table(priv);
2363 }
2364
2365 static void
2366 lec_set_flush_tran_id(struct lec_priv *priv,
2367                       unsigned char *atm_addr, unsigned long tran_id)
2368 {
2369         unsigned long flags;
2370         struct hlist_node *node;
2371         struct lec_arp_table *entry;
2372         int i;
2373
2374         spin_lock_irqsave(&priv->lec_arp_lock, flags);
2375         for (i = 0; i < LEC_ARP_TABLE_SIZE; i++)
2376                 hlist_for_each_entry(entry, node, &priv->lec_arp_tables[i], next) {
2377                         if (!memcmp(atm_addr, entry->atm_addr, ATM_ESA_LEN)) {
2378                                 entry->flush_tran_id = tran_id;
2379                                 DPRINTK("Set flush transaction id to %lx for %p\n",
2380                                         tran_id, entry);
2381                         }
2382                 }
2383         spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
2384 }
2385
2386 static int lec_mcast_make(struct lec_priv *priv, struct atm_vcc *vcc)
2387 {
2388         unsigned long flags;
2389         unsigned char mac_addr[] = {
2390                 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
2391         };
2392         struct lec_arp_table *to_add;
2393         struct lec_vcc_priv *vpriv;
2394         int err = 0;
2395
2396         if (!(vpriv = kmalloc(sizeof(struct lec_vcc_priv), GFP_KERNEL)))
2397                 return -ENOMEM;
2398         vpriv->xoff = 0;
2399         vpriv->old_pop = vcc->pop;
2400         vcc->user_back = vpriv;
2401         vcc->pop = lec_pop;
2402         spin_lock_irqsave(&priv->lec_arp_lock, flags);
2403         to_add = make_entry(priv, mac_addr);
2404         if (!to_add) {
2405                 vcc->pop = vpriv->old_pop;
2406                 kfree(vpriv);
2407                 err = -ENOMEM;
2408                 goto out;
2409         }
2410         memcpy(to_add->atm_addr, vcc->remote.sas_addr.prv, ATM_ESA_LEN);
2411         to_add->status = ESI_FORWARD_DIRECT;
2412         to_add->flags |= LEC_PERMANENT_FLAG;
2413         to_add->vcc = vcc;
2414         to_add->old_push = vcc->push;
2415         vcc->push = lec_push;
2416         priv->mcast_vcc = vcc;
2417         lec_arp_add(priv, to_add);
2418 out:
2419         spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
2420         return err;
2421 }
2422
2423 static void lec_vcc_close(struct lec_priv *priv, struct atm_vcc *vcc)
2424 {
2425         unsigned long flags;
2426         struct hlist_node *node, *next;
2427         struct lec_arp_table *entry;
2428         int i;
2429
2430         DPRINTK("LEC_ARP: lec_vcc_close vpi:%d vci:%d\n", vcc->vpi, vcc->vci);
2431         dump_arp_table(priv);
2432
2433         spin_lock_irqsave(&priv->lec_arp_lock, flags);
2434
2435         for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) {
2436                 hlist_for_each_entry_safe(entry, node, next, &priv->lec_arp_tables[i], next) {
2437                         if (vcc == entry->vcc) {
2438                                 lec_arp_remove(priv, entry);
2439                                 lec_arp_put(entry);
2440                                 if (priv->mcast_vcc == vcc) {
2441                                         priv->mcast_vcc = NULL;
2442                                 }
2443                         }
2444                 }
2445         }
2446
2447         hlist_for_each_entry_safe(entry, node, next, &priv->lec_arp_empty_ones, next) {
2448                 if (entry->vcc == vcc) {
2449                         lec_arp_clear_vccs(entry);
2450                         del_timer(&entry->timer);
2451                         hlist_del(&entry->next);
2452                         lec_arp_put(entry);
2453                 }
2454         }
2455
2456         hlist_for_each_entry_safe(entry, node, next, &priv->lec_no_forward, next) {
2457                 if (entry->recv_vcc == vcc) {
2458                         lec_arp_clear_vccs(entry);
2459                         del_timer(&entry->timer);
2460                         hlist_del(&entry->next);
2461                         lec_arp_put(entry);
2462                 }
2463         }
2464
2465         hlist_for_each_entry_safe(entry, node, next, &priv->mcast_fwds, next) {
2466                 if (entry->recv_vcc == vcc) {
2467                         lec_arp_clear_vccs(entry);
2468                         /* No timer, LANEv2 7.1.20 and 2.3.5.3 */
2469                         hlist_del(&entry->next);
2470                         lec_arp_put(entry);
2471                 }
2472         }
2473
2474         spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
2475         dump_arp_table(priv);
2476 }
2477
2478 static void
2479 lec_arp_check_empties(struct lec_priv *priv,
2480                       struct atm_vcc *vcc, struct sk_buff *skb)
2481 {
2482         unsigned long flags;
2483         struct hlist_node *node, *next;
2484         struct lec_arp_table *entry, *tmp;
2485         struct lecdatahdr_8023 *hdr = (struct lecdatahdr_8023 *)skb->data;
2486         unsigned char *src;
2487 #ifdef CONFIG_TR
2488         struct lecdatahdr_8025 *tr_hdr = (struct lecdatahdr_8025 *)skb->data;
2489
2490         if (priv->is_trdev)
2491                 src = tr_hdr->h_source;
2492         else
2493 #endif
2494                 src = hdr->h_source;
2495
2496         spin_lock_irqsave(&priv->lec_arp_lock, flags);
2497         hlist_for_each_entry_safe(entry, node, next, &priv->lec_arp_empty_ones, next) {
2498                 if (vcc == entry->vcc) {
2499                         del_timer(&entry->timer);
2500                         memcpy(entry->mac_addr, src, ETH_ALEN);
2501                         entry->status = ESI_FORWARD_DIRECT;
2502                         entry->last_used = jiffies;
2503                         /* We might have got an entry */
2504                         if ((tmp = lec_arp_find(priv, src))) {
2505                                 lec_arp_remove(priv, tmp);
2506                                 lec_arp_put(tmp);
2507                         }
2508                         hlist_del(&entry->next);
2509                         lec_arp_add(priv, entry);
2510                         goto out;
2511                 }
2512         }
2513         DPRINTK("LEC_ARP: Arp_check_empties: entry not found!\n");
2514 out:
2515         spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
2516 }
2517
2518 MODULE_LICENSE("GPL");