net/atm/lec.c

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