开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
lec.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：79k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

lec.c：源码内容
  1. /*
  2.  * lec.c: Lan Emulation driver 
  3.  * Marko Kiiskila carnil@cs.tut.fi
  4.  *
  5.  */
  7. #include <linux/config.h>
  8. #include <linux/kernel.h>
  9. #include <linux/bitops.h>
  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>
  24. /* TokenRing if needed */
  25. #ifdef CONFIG_TR
  26. #include <linux/trdevice.h>
  27. #endif
  29. /* And atm device */
  30. #include <linux/atmdev.h>
  31. #include <linux/atmlec.h>
  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
  40. /* Modular too */
  41. #include <linux/module.h>
  42. #include <linux/init.h>
  44. #include "lec.h"
  45. #include "lec_arpc.h"
  46. #include "resources.h"  /* for bind_vcc() */
  48. #if 0
  49. #define DPRINTK printk
  50. #else
  51. #define DPRINTK(format,args...)
  52. #endif
  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);
  59. #define DUMP_PACKETS 0 /* 0 = None,
  60.                         * 1 = 30 first bytes
  61.                         * 2 = Whole packet
  62.                         */
  64. #define LEC_UNRES_QUE_LEN 8 /* number of tx packets to queue for a
  65.                                single destination while waiting for SVC */
  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);
  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. };
  90. static unsigned char bus_mac[ETH_ALEN] = {0xff,0xff,0xff,0xff,0xff,0xff};
  92. /* Device structures */
  93. static struct net_device *dev_lec[MAX_LEC_ITF];
  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. }
  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;
  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;
  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 */
  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.         }
  130.         return;
  131. }
  132. #endif /* defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE) */
  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 */
  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 */
  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.         }
  175.         return NULL;
  176. }
  177. #endif /* CONFIG_TR */
  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.  */
  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. }
  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 calledn");  
  218.         if (!priv->lecd) {
  219.                 printk("%s:No lecd attachedn",dev->name);
  220.                 priv->stats.tx_errors++;
  221.                 netif_stop_queue(dev);
  222.                 return -EUNATCH;
  223.         } 
  225.         DPRINTK("skbuff head:%lx data:%lx tail:%lx end:%lxn",
  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
  233.         /* Make sure we have room for lec_id */
  234.         if (skb_headroom(skb) < 2) {
  236.                 DPRINTK("lec_send_packet: reallocating skbn");
  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);
  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); 
  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
  259. #if DUMP_PACKETS > 0
  260.         printk("%s: send datalen:%ld lecid:%4.4xn", 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("%sn",buf);
  273.         else
  274.                 printk("%s...n",buf);
  275. #endif /* DUMP_PACKETS > 0 */
  277.         /* Minimum ethernet-frame size */
  278.         if (skb->len <62) {
  279.                 if (skb->truesize < 62) {
  280.                         printk("%s:data packet %d / %dn",
  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:%pn", 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:%02xn",
  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:%02xn",
  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:%dn", 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:%02xn",
  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:%dn", 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.         }
  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. }
  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. }
  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. }
  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. }
  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 */
  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:%dn", 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);
  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_updaten");
  447.                 if (mesg->sizeoftlvs != 0) { /* LANE2 3.1.5 */
  448.                         DPRINTK("lec: LANE2 3.1.5, got tlvs, size %dn", 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 failedn", 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;
  489.                 DPRINTK("%s: bridge zeppelin asks about 0x%02x:%02x:%02x:%02x:%02x:%02xn",
  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]);
  495.                 if (br_fdb_get_hook == NULL || dev->br_port == NULL)
  496.                         break;
  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;
  505.                         DPRINTK("%s: entry found, responding to zeppelinn", 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 %dn", dev->name, mesg->type);
  523.                 dev_kfree_skb(skb);
  524.                 return -EINVAL;
  525.         }
  526.         dev_kfree_skb(skb);
  527.         return 0;
  528. }
  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;
  537.         priv->lecd = NULL;
  538.         /* Do something needful? */
  540.         netif_stop_queue(dev);
  541.         lec_arp_destroy(priv);
  543.         if (skb_peek(&vcc->recvq))
  544. printk("%s lec_atm_close: closing with messages pendingn",
  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. }
  555. static struct atmdev_ops lecdev_ops = {
  556.         close: lec_atm_close,
  557.         send: lec_atm_send
  558. };
  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. };
  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;
  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);
  603.         atm_force_charge(priv->lecd, skb->truesize);
  604. skb_queue_tail(&priv->lecd->recvq, skb);
  605.         wake_up(&priv->lecd->sleep);
  607.         if (data != NULL) {
  608.                 DPRINTK("lec: about to send %d bytes of datan", 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.         }
  614.         return 0;
  615. }
  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. }
  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;
  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. }
  641. static unsigned char lec_ctrl_magic[] = {
  642.         0xff,
  643.         0x00,
  644.         0x01,
  645.         0x01 };
  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; 
  653. #if DUMP_PACKETS >0
  654.         int i=0;
  655.         char buf[300];
  657.         printk("%s: lec_push vcc vpi:%d vci:%dn", dev->name,
  658.                vcc->vpi, vcc->vci);
  659. #endif
  660.         if (!skb) {
  661.                 DPRINTK("%s: null skbn",dev->name);
  662.                 lec_vcc_close(priv, vcc);
  663.                 return;
  664.         }
  665. #if DUMP_PACKETS > 0
  666.         printk("%s: rcv datalen:%ld lecid:%4.4xn", 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("%sn",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 daemonn",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;
  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;
  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. }
  726. int 
  727. lec_vcc_attach(struct atm_vcc *vcc, void *arg)
  728. {
  729.         int bytes_left;
  730.         struct atmlec_ioc ioc_data;
  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 bytesn",
  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. }
  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. }
  757. /* Initialize device. */
  758. int 
  759. lecd_attach(struct atm_vcc *vcc, int arg)
  760. {  
  761.         int i;
  762.         struct lec_priv *priv;
  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;
  778.                 is_trdev = 0;
  779.                 if (i >= (MAX_LEC_ITF - NUM_TR_DEVS))
  780.                         is_trdev = 1;
  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;
  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);
  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);
  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. }
  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;
  836.         printk("lec.c: " __DATE__ " " __TIME__ " initializedn");
  838. return;
  839. }
  841. static int __init lane_module_init(void)
  842. {
  843.         extern struct atm_lane_ops atm_lane_ops;
  845.         atm_lane_init_ops(&atm_lane_ops);
  847.         return 0;
  848. }
  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;
  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;
  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.         }
  875.         return;                                    
  876. }
  878. module_init(lane_module_init);
  879. module_exit(lane_module_cleanup);
  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;
  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.         }
  911. if (sizeoftlvs == NULL)
  912. retval = send_to_lecd(priv, l_arp_xmt, dst_mac, NULL, NULL);
  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. }        
  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;
  940.         if ( memcmp(lan_dst, dev->dev_addr, ETH_ALEN) != 0 )
  941.                 return (0);       /* not our mac address */
  943.         kfree(priv->tlvs); /* NULL if there was no previous association */
  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);
  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() failedn");
  959.         /* If the previous association has changed we must
  960.          * somehow notify other LANE entities about the change
  961.          */
  962.         return (1);
  963. }
  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);
  980.         if (entry == NULL)
  981.                 return;     /* should not happen */
  983.         kfree(entry->tlvs);
  985.         entry->tlvs = kmalloc(sizeoftlvs, GFP_KERNEL);
  986.         if (entry->tlvs == NULL)
  987.                 return;
  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=%dn", sizeoftlvs);
  995.         while (i < sizeoftlvs)
  996.                 printk("%02x ", tlvs[i++]);
  997.         
  998.         printk("n");
  999. #endif
  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. }
  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.  */
  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>
  1026. #if 0
  1027. #define DPRINTK(format,args...)
  1028. /*
  1029. #define DPRINTK printk
  1030. */
  1031. #endif
  1032. #define DEBUG_ARP_TABLE 0
  1034. #define LEC_ARP_REFRESH_INTERVAL (3*HZ)
  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);
  1040. /* 
  1041.  * Arp table funcs
  1042.  */
  1044. #define HASH(ch) (ch & (LEC_ARP_TABLE_SIZE -1))
  1046. static __inline__ void 
  1047. lec_arp_lock(struct lec_priv *priv)
  1048. {
  1049.         atomic_inc(&priv->lec_arp_lock_var);
  1050. }
  1052. static __inline__ void 
  1053. lec_arp_unlock(struct lec_priv *priv)
  1054. {
  1055.         atomic_dec(&priv->lec_arp_lock_var);
  1056. }
  1058. /*
  1059.  * Initialization of arp-cache
  1060.  */
  1061. void 
  1062. lec_arp_init(struct lec_priv *priv)
  1063. {
  1064.         unsigned short i;
  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. }
  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. }
  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;
  1113.         save_flags(flags);
  1114.         cli();
  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.         }
  1128.         restore_flags(flags);
  1129.         DPRINTK("LEC_ARP: Added entry:%2.2x %2.2x %2.2x %2.2x %2.2x %2.2xn",
  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. }
  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;
  1147.         save_flags(flags);
  1148.         cli();
  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.2xn",
  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. }
  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
  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;
  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: %pn",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,"->%pn",rulla->next);
  1265.                         rulla = rulla->next;
  1266.                 }
  1267.                 printk("%s",buf);
  1268.         }
  1269.         rulla = lec_no_forward;
  1270.         if (rulla)
  1271.                 printk("No forwardn");  
  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,"->%lxn",(long)rulla->next);
  1297.                 rulla = rulla->next;
  1298.                 printk("%s",buf);
  1299.         }
  1300.         rulla = lec_arp_empty_ones;
  1301.         if (rulla)
  1302.                 printk("Empty onesn");  
  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,"->%lxn",(long)rulla->next);
  1328.                 rulla = rulla->next;
  1329.                 printk("%s",buf);
  1330.         }
  1332.         rulla = mcast_fwds;
  1333.         if (rulla)
  1334.                 printk("Multicast Forward VCCsn");  
  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,"->%lxn",(long)rulla->next);
  1360.                 rulla = rulla->next;
  1361.                 printk("%s",buf);
  1362.         }
  1364. #endif
  1365. }
  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;
  1377.         save_flags(flags);
  1378.         cli();
  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. }
  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;
  1436.         DPRINTK("LEC_ARP: lec_arp_find :%2.2x %2.2x %2.2x %2.2x %2.2x %2.2xn",
  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. }
  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;
  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 failedn");
  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. }
  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;
  1486.         entry = (struct lec_arp_table *)data;
  1488.         del_timer(&entry->timer);
  1490.         DPRINTK("lec_arp_expire_arpn");
  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. }
  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;
  1516.         del_timer(&to_remove->timer);
  1518.         DPRINTK("LEC_ARP %p %p: lec_arp_expire_vcc vpi:%d vci:%dn",
  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:%pn",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. }
  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;
  1574.         del_timer(&priv->lec_arp_timer);
  1576.         DPRINTK("lec_arp_check_expire %p,%dn",priv,
  1577.                 priv->lec_arp_lock_var.counter);
  1578.         DPRINTK("expire: eo:%p nf:%pn",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;
  1591.                                 DPRINTK("About to expire: %lx - %lx > %lxn",
  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 outn");
  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;
  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.         }
  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 %pn", 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 entryn");
  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. }
  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;
  1714.         lec_arp_lock(priv);
  1715.         DPRINTK("lec_addr_deleten");
  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. }
  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;
  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.2xn",
  1746.                 mac_addr[0],mac_addr[1],mac_addr[2],mac_addr[3],
  1747.                 mac_addr[4],mac_addr[5]);
  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 updaten");
  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 update2n");
  1842.         dump_arp_table(priv);
  1843.         lec_arp_unlock(priv);
  1844. }
  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;
  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 */
  1861.                 DPRINTK("LEC_ARP: Attaching mcast forwardn");
  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.2xn",
  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.2xn",
  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 directn");
  1935.                                 DPRINTK("Currently -> Vcc: %d, Rvcc:%dn",
  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 addedn");
  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 addedn");
  1998. dump_arp_table(priv);
  1999. }
  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 %lxn",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: Flushedn");
  2014.                         }
  2015.                 }
  2016.         }
  2017.         dump_arp_table(priv);
  2018. }
  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;
  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 %pn",tran_id,entry);
  2032.                         }
  2033. }
  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. }
  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;
  2066.         DPRINTK("LEC_ARP: lec_vcc_close vpi:%d vci:%dn",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.         }
  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.         }
  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.         }
  2130.         lec_arp_unlock(priv);
  2131. dump_arp_table(priv);
  2132. }
  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;
  2145.         if (priv->is_trdev) src = tr_hdr->h_source;
  2146.         else
  2147. #endif
  2148.         src = hdr->h_source;
  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");