diff --git a/openair2/NETWORK_DRIVER/UE_IP/Makefile b/openair2/NETWORK_DRIVER/UE_IP/Makefile index 76475760f9e2b3b0486c540a1edb5066236b148f..170b548af07088920465febc00634e9b4a13cac3 100755 --- a/openair2/NETWORK_DRIVER/UE_IP/Makefile +++ b/openair2/NETWORK_DRIVER/UE_IP/Makefile @@ -53,7 +53,7 @@ V3= $(if $(IS_KERNEL_MAIN_VERSION_IS_3),-DKERNEL_MAIN_VERSION_IS_3=1) #################################################### # EXTRA COMPILER FLAGS #################################################### -EXTRA_CFLAGS = -fno-common $(if $(IS_KERNEL_SUBVERSION_GREATER_THAN_20),-mregparm=3 -fno-stack-protector -mpreferred-stack-boundary=4) $(if $(SET_X64),-DARCH_64,) $(if $(SET_X64),-mcmodel=kernel,) $(if $(SET_X64),-m64,) $(GT2622) $(GT2629) $(V3) $(GT32) +EXTRA_CFLAGS = -I$(OPENAIR2_DIR)/COMMON -fno-common $(if $(IS_KERNEL_SUBVERSION_GREATER_THAN_20),-mregparm=3 -fno-stack-protector -mpreferred-stack-boundary=4) $(if $(SET_X64),-DARCH_64,) $(if $(SET_X64),-mcmodel=kernel,) $(if $(SET_X64),-m64,) $(GT2622) $(GT2629) $(V3) $(GT32) diff --git a/openair2/NETWORK_DRIVER/UE_IP/common.c b/openair2/NETWORK_DRIVER/UE_IP/common.c index 821263531963176bb9c00cdd89a5e1410fe02035..9c30c82ace6f69023f180e36f8a9bc65a30acbcd 100755 --- a/openair2/NETWORK_DRIVER/UE_IP/common.c +++ b/openair2/NETWORK_DRIVER/UE_IP/common.c @@ -67,105 +67,108 @@ //#define OAI_DRV_DEBUG_SEND //#define OAI_DRV_DEBUG_RECEIVE -void ue_ip_common_class_wireless2ip(u16 dlen, - void *pdcp_sdu, - int inst, - OaiNwDrvRadioBearerId_t rb_id) { + +void +ue_ip_common_class_wireless2ip( + sdu_size_t data_lenP, + void *pdcp_sdu_pP, + int instP, + rb_id_t rb_idP) { //--------------------------------------------------------------------------- - struct sk_buff *skb; - struct ipversion *ipv; - struct ue_ip_priv *gpriv=netdev_priv(ue_ip_dev[inst]); - unsigned int hard_header_len; + struct sk_buff *skb_p = NULL; + ipversion_t *ipv_p = NULL; + ue_ip_priv_t *gpriv_p = netdev_priv(ue_ip_dev[instP]); + unsigned int hard_header_len = 0; #ifdef OAI_DRV_DEBUG_RECEIVE - int i; - unsigned char *addr; + int i; + unsigned char *addr_p = 0; #endif unsigned char protocol; - struct iphdr *network_header; + struct iphdr *network_header_p = NULL; #ifdef OAI_DRV_DEBUG_RECEIVE - printk("[UE_IP_DRV][%s] begin RB %d Inst %d Length %d bytes\n",__FUNCTION__, rb_id,inst,dlen); + printk("[UE_IP_DRV][%s] begin RB %d Inst %d Length %d bytes\n",__FUNCTION__, rb_idP,instP,data_lenP); #endif - skb = dev_alloc_skb( dlen + 2 ); + skb_p = dev_alloc_skb( data_lenP + 2 ); - if(!skb) { + if(!skb_p) { printk("[UE_IP_DRV][%s] low on memory\n",__FUNCTION__); - ++gpriv->stats.rx_dropped; + ++gpriv_p->stats.rx_dropped; return; } - skb_reserve(skb,2); - memcpy(skb_put(skb, dlen), pdcp_sdu,dlen); + skb_reserve(skb_p,2); + memcpy(skb_put(skb_p, data_lenP), pdcp_sdu_pP,data_lenP); - skb->dev = ue_ip_dev[inst]; - hard_header_len = ue_ip_dev[inst]->hard_header_len; + skb_p->dev = ue_ip_dev[instP]; + hard_header_len = ue_ip_dev[instP]->hard_header_len; - skb_set_mac_header(skb, 0); - //skb->mac_header = skb->data; + skb_set_mac_header(skb_p, 0); + //skb_p->mac_header = skb_p->data; - //printk("[NAC_COMMIN_RECEIVE]: Packet Type %d (%d,%d)",skb->pkt_type,PACKET_HOST,PACKET_BROADCAST); - skb->pkt_type = PACKET_HOST; + //printk("[NAC_COMMIN_RECEIVE]: Packet Type %d (%d,%d)",skb_p->pkt_type,PACKET_HOST,PACKET_BROADCAST); + skb_p->pkt_type = PACKET_HOST; #ifdef OAI_DRV_DEBUG_RECEIVE - printk("[UE_IP_DRV][%s] Receiving packet of size %d from PDCP \n",__FUNCTION__, skb->len); + printk("[UE_IP_DRV][%s] Receiving packet of size %d from PDCP \n",__FUNCTION__, skb_p->len); - for (i=0;i<skb->len;i++) - printk("%2x ",((unsigned char *)(skb->data))[i]); + for (i=0;i<skb_p->len;i++) + printk("%2x ",((unsigned char *)(skb_p->data))[i]); printk("\n"); #endif #ifdef OAI_DRV_DEBUG_RECEIVE - printk("[UE_IP_DRV][%s] skb->data @ %p\n",__FUNCTION__, skb->data); - printk("[UE_IP_DRV][%s] skb->mac_header @ %p\n",__FUNCTION__, skb->mac_header); + printk("[UE_IP_DRV][%s] skb_p->data @ %p\n",__FUNCTION__, skb_p->data); + printk("[UE_IP_DRV][%s] skb_p->mac_header @ %p\n",__FUNCTION__, skb_p->mac_header); #endif - // LG TEST skb->ip_summed = CHECKSUM_NONE; - skb->ip_summed = CHECKSUM_UNNECESSARY; + // LG TEST skb_p->ip_summed = CHECKSUM_NONE; + skb_p->ip_summed = CHECKSUM_UNNECESSARY; - ipv = (struct ipversion *)&(skb->data[hard_header_len]); - switch (ipv->version) { + ipv_p = (struct ipversion *)&(skb_p->data[hard_header_len]); + switch (ipv_p->version) { case 6: #ifdef OAI_DRV_DEBUG_RECEIVE printk("[UE_IP_DRV][%s] receive IPv6 message\n",__FUNCTION__); #endif - skb_set_network_header(skb, hard_header_len); - //skb->network_header = &skb->data[hard_header_len]; + skb_set_network_header(skb_p, hard_header_len); + //skb_p->network_header_p = &skb_p->data[hard_header_len]; if (hard_header_len == 0) { - skb->protocol = htons(ETH_P_IPV6); + skb_p->protocol = htons(ETH_P_IPV6); } else { #ifdef OAI_NW_DRIVER_TYPE_ETHERNET - skb->protocol = eth_type_trans(skb, ue_ip_dev[inst]); + skb_p->protocol = eth_type_trans(skb_p, ue_ip_dev[instP]); #else #endif } - //printk("Writing packet with protocol %x\n",ntohs(skb->protocol)); + //printk("Writing packet with protocol %x\n",ntohs(skb_p->protocol)); break; case 4: #ifdef OAI_DRV_DEBUG_RECEIVE //printk("NAS_TOOL_RECEIVE: receive IPv4 message\n"); - addr = (unsigned char *)&((struct iphdr *)&skb->data[hard_header_len])->saddr; - if (addr) { - printk("[UE_IP_DRV][%s] Source %d.%d.%d.%d\n",__FUNCTION__, addr[0],addr[1],addr[2],addr[3]); + addr_p = (unsigned char *)&((struct iphdr *)&skb_p->data[hard_header_len])->saddr; + if (addr_p) { + printk("[UE_IP_DRV][%s] Source %d.%d.%d.%d\n",__FUNCTION__, addr_p[0],addr_p[1],addr_p[2],addr_p[3]); } - addr = (unsigned char *)&((struct iphdr *)&skb->data[hard_header_len])->daddr; - if (addr){ - printk("[UE_IP_DRV][%s] Dest %d.%d.%d.%d\n",__FUNCTION__, addr[0],addr[1],addr[2],addr[3]); + addr_p = (unsigned char *)&((struct iphdr *)&skb_p->data[hard_header_len])->daddr; + if (addr_p){ + printk("[UE_IP_DRV][%s] Dest %d.%d.%d.%d\n",__FUNCTION__, addr_p[0],addr_p[1],addr_p[2],addr_p[3]); } - printk("[UE_IP_DRV][%s] protocol %d\n",__FUNCTION__, ((struct iphdr *)&skb->data[hard_header_len])->protocol); + printk("[UE_IP_DRV][%s] protocol %d\n",__FUNCTION__, ((struct iphdr *)&skb_p->data[hard_header_len])->protocol); #endif - skb->network_header = &skb->data[hard_header_len]; - //network_header = (struct iphdr *)skb_network_header(skb); - network_header = (struct iphdr *)skb_network_header(skb); - protocol = network_header->protocol; + skb_p->network_header = &skb_p->data[hard_header_len]; + //network_header_p = (struct iphdr *)skb_network_header(skb_p); + network_header_p = (struct iphdr *)skb_network_header(skb_p); + protocol = network_header_p->protocol; #ifdef OAI_DRV_DEBUG_RECEIVE switch (protocol) { @@ -190,25 +193,25 @@ void ue_ip_common_class_wireless2ip(u16 dlen, #endif if (hard_header_len == 0) { - skb->protocol = htons(ETH_P_IP); + skb_p->protocol = htons(ETH_P_IP); } - //printk("[UE_IP_DRV][COMMON] Writing packet with protocol %x\n",ntohs(skb->protocol)); + //printk("[UE_IP_DRV][COMMON] Writing packet with protocol %x\n",ntohs(skb_p->protocol)); break; default: - printk("[UE_IP_DRV][%s] begin RB %d Inst %d Length %d bytes\n",__FUNCTION__,rb_id,inst,dlen); - printk("[UE_IP_DRV][%s] Inst %d: receive unknown message (version=%d)\n",__FUNCTION__,inst,ipv->version); + printk("[UE_IP_DRV][%s] begin RB %d Inst %d Length %d bytes\n",__FUNCTION__,rb_idP,instP,data_lenP); + printk("[UE_IP_DRV][%s] Inst %d: receive unknown message (version=%d)\n",__FUNCTION__,instP,ipv_p->version); } - ++gpriv->stats.rx_packets; - gpriv->stats.rx_bytes += dlen; + ++gpriv_p->stats.rx_packets; + gpriv_p->stats.rx_bytes += data_lenP; #ifdef OAI_DRV_DEBUG_RECEIVE - printk("[UE_IP_DRV][%s] sending packet of size %d to kernel\n",__FUNCTION__,skb->len); - for (i=0;i<skb->len;i++) - printk("%2x ",((unsigned char *)(skb->data))[i]); + printk("[UE_IP_DRV][%s] sending packet of size %d to kernel\n",__FUNCTION__,skb_p->len); + for (i=0;i<skb_p->len;i++) + printk("%2x ",((unsigned char *)(skb_p->data))[i]); printk("\n"); #endif //OAI_DRV_DEBUG_RECEIVE - netif_rx(skb); + netif_rx(skb_p); #ifdef OAI_DRV_DEBUG_RECEIVE printk("[UE_IP_DRV][%s] end\n",__FUNCTION__); #endif @@ -216,18 +219,22 @@ void ue_ip_common_class_wireless2ip(u16 dlen, //--------------------------------------------------------------------------- // Delete the data -void ue_ip_common_ip2wireless_drop(struct sk_buff *skb, int inst){ +void ue_ip_common_ip2wireless_drop(struct sk_buff *skb_pP, int instP){ //--------------------------------------------------------------------------- - struct ue_ip_priv *priv=netdev_priv(ue_ip_dev[inst]); - ++priv->stats.tx_dropped; + ue_ip_priv_t *priv_p=netdev_priv(ue_ip_dev[instP]); + ++priv_p->stats.tx_dropped; } //--------------------------------------------------------------------------- // Request the transfer of data (QoS SAP) -void ue_ip_common_ip2wireless(struct sk_buff *skb, int inst){ +void +ue_ip_common_ip2wireless( + struct sk_buff *skb_pP, + int instP + ) { //--------------------------------------------------------------------------- struct pdcp_data_req_header_s pdcph; - struct ue_ip_priv *priv=netdev_priv(ue_ip_dev[inst]); + ue_ip_priv_t *priv_p=netdev_priv(ue_ip_dev[instP]); #ifdef LOOPBACK_TEST int i; #endif @@ -237,10 +244,10 @@ void ue_ip_common_ip2wireless(struct sk_buff *skb, int inst){ unsigned int bytes_wrote; // Start debug information #ifdef OAI_DRV_DEBUG_SEND - printk("[UE_IP_DRV][%s] inst %d begin \n",__FUNCTION__,inst); + printk("[UE_IP_DRV][%s] inst %d begin \n",__FUNCTION__,instP); #endif - if (skb==NULL){ + if (skb_pP==NULL){ #ifdef OAI_DRV_DEBUG_SEND printk("[UE_IP_DRV][%s] input parameter skb is NULL \n",__FUNCTION__); #endif @@ -248,79 +255,79 @@ void ue_ip_common_ip2wireless(struct sk_buff *skb, int inst){ } - pdcph.data_size = skb->len; - if (skb->mark) { - pdcph.rb_id = skb->mark; + pdcph.data_size = skb_pP->len; + if (skb_pP->mark) { + pdcph.rb_id = skb_pP->mark; } else { pdcph.rb_id = UE_IP_DEFAULT_RAB_ID; } - pdcph.inst = inst; + pdcph.inst = instP; bytes_wrote = ue_ip_netlink_send((char *)&pdcph,UE_IP_PDCPH_SIZE); #ifdef OAI_DRV_DEBUG_SEND printk("[UE_IP_DRV][%s] Wrote %d bytes (header for %d byte skb) to PDCP via netlink\n",__FUNCTION__, - bytes_wrote,skb->len); + bytes_wrote,skb_pP->len); #endif if (bytes_wrote != UE_IP_PDCPH_SIZE) { printk("[UE_IP_DRV][%s] problem while writing PDCP's header (bytes wrote = %d)\n",__FUNCTION__,bytes_wrote); printk("rb_id %d, Wrote %d, Header Size %d \n", pdcph.rb_id , bytes_wrote, UE_IP_PDCPH_SIZE); - priv->stats.tx_dropped ++; + priv_p->stats.tx_dropped ++; return; } - bytes_wrote += ue_ip_netlink_send((char *)skb->data,skb->len); + bytes_wrote += ue_ip_netlink_send((char *)skb_pP->data,skb_pP->len); - if (bytes_wrote != skb->len+UE_IP_PDCPH_SIZE) + if (bytes_wrote != skb_pP->len+UE_IP_PDCPH_SIZE) { printk("[UE_IP_DRV][%s] Inst %d, RB_ID %d: problem while writing PDCP's data, bytes_wrote = %d, Data_len %d, PDCPH_SIZE %d\n", __FUNCTION__, - inst, + instP, pdcph.rb_id, bytes_wrote, - skb->len, + skb_pP->len, UE_IP_PDCPH_SIZE); // congestion - priv->stats.tx_dropped ++; + priv_p->stats.tx_dropped ++; return; } #ifdef OAI_DRV_DEBUG_SEND - printk("[UE_IP_DRV][%s] Sending packet of size %d to PDCP \n",__FUNCTION__,skb->len); + printk("[UE_IP_DRV][%s] Sending packet of size %d to PDCP \n",__FUNCTION__,skb_pP->len); - for (j=0;j<skb->len;j++) - printk("%2x ",((unsigned char *)(skb->data))[j]); + for (j=0;j<skb_pP->len;j++) + printk("%2x ",((unsigned char *)(skb_pP->data))[j]); printk("\n"); #endif - priv->stats.tx_bytes += skb->len; - priv->stats.tx_packets ++; + priv_p->stats.tx_bytes += skb_pP->len; + priv_p->stats.tx_packets ++; #ifdef OAI_DRV_DEBUG_SEND printk("[UE_IP_DRV][%s] end \n",__FUNCTION__); #endif } //--------------------------------------------------------------------------- -void ue_ip_common_wireless2ip(struct nlmsghdr *nlh) { +void ue_ip_common_wireless2ip(struct nlmsghdr *nlh_pP) { //--------------------------------------------------------------------------- - struct pdcp_data_ind_header_s *pdcph = (struct pdcp_data_ind_header_s *)NLMSG_DATA(nlh); - struct ue_ip_priv *priv; + struct pdcp_data_ind_header_s *pdcph_p = (struct pdcp_data_ind_header_s *)NLMSG_DATA(nlh_pP); + ue_ip_priv_t *priv_p; - priv = netdev_priv(ue_ip_dev[pdcph->inst]); + priv_p = netdev_priv(ue_ip_dev[pdcph_p->inst]); #ifdef OAI_DRV_DEBUG_RECEIVE printk("[UE_IP_DRV][%s] QOS receive from PDCP, size %d, rab %d, inst %d\n",__FUNCTION__, - pdcph->data_size,pdcph->rb_id,pdcph->inst); + pdcph_p->data_size,pdcph_p->rb_id,pdcph_p->inst); #endif - ue_ip_common_class_wireless2ip(pdcph->data_size, - (unsigned char *)NLMSG_DATA(nlh) + UE_IP_PDCPH_SIZE, - pdcph->inst, - pdcph->rb_id); + ue_ip_common_class_wireless2ip(pdcph_p->data_size, + (unsigned char *)NLMSG_DATA(nlh_pP) + UE_IP_PDCPH_SIZE, + pdcph_p->inst, + pdcph_p->rb_id); } diff --git a/openair2/NETWORK_DRIVER/UE_IP/device.c b/openair2/NETWORK_DRIVER/UE_IP/device.c index a3a1ea33e1077d3d2f274e69a4f91108fb795c2a..5e7a13608a64c74ff2b7c9a749b7b3931b436ae7 100755 --- a/openair2/NETWORK_DRIVER/UE_IP/device.c +++ b/openair2/NETWORK_DRIVER/UE_IP/device.c @@ -70,12 +70,12 @@ extern int ue_ip_netlink_init(void); #endif //--------------------------------------------------------------------------- -int ue_ip_find_inst(struct net_device *dev) { +int ue_ip_find_inst(struct net_device *dev_pP) { //--------------------------------------------------------------------------- int i; for (i=0;i<UE_IP_NB_INSTANCES_MAX;i++) - if (ue_ip_dev[i] == dev) + if (ue_ip_dev[i] == dev_pP) return(i); return(-1); } @@ -85,23 +85,23 @@ int ue_ip_find_inst(struct net_device *dev) { #ifndef OAI_NW_DRIVER_USE_NETLINK void *ue_ip_interrupt(void){ //--------------------------------------------------------------------------- - u8 cxi; + uint8_t cxi; - // struct ue_ip_priv *priv=netdev_priv(dev_id); + // ue_ip_priv_t *priv_p=netdev_priv(dev_id); // unsigned int flags; - // priv->lock = SPIN_LOCK_UNLOCKED; + // priv_p->lock = SPIN_LOCK_UNLOCKED; #ifdef OAI_DRV_DEBUG_INTERRUPT printk("INTERRUPT - begin\n"); #endif - // spin_lock_irqsave(&priv->lock,flags); + // spin_lock_irqsave(&priv_p->lock,flags); cxi=0; // mesh_GC_receive(); // mesh_DC_receive(naspriv->cx+cxi); #ifndef OAI_NW_DRIVER_USE_NETLINK ue_ip_common_wireless2ip(); #endif - // spin_unlock_irqrestore(&priv->lock,flags); + // spin_unlock_irqrestore(&priv_p->lock,flags); #ifdef OAI_DRV_DEBUG_INTERRUPT printk("INTERRUPT: end\n"); #endif @@ -109,15 +109,15 @@ void *ue_ip_interrupt(void){ } #endif //NETLINK //--------------------------------------------------------------------------- -void ue_ip_timer(unsigned long data){ +void ue_ip_timer(unsigned long dataP){ //--------------------------------------------------------------------------- - struct ue_ip_priv *priv=(struct ue_ip_priv *)data; - spin_lock(&priv->lock); - (priv->timer).function=ue_ip_timer; - (priv->timer).expires=jiffies+UE_IP_TIMER_TICK; - (priv->timer).data=data; - add_timer(&priv->timer); - spin_unlock(&priv->lock); + ue_ip_priv_t *priv_p=(ue_ip_priv_t *)dataP; + spin_lock(&priv_p->lock); + (priv_p->timer).function=ue_ip_timer; + (priv_p->timer).expires=jiffies+UE_IP_TIMER_TICK; + (priv_p->timer).data=dataP; + add_timer(&priv_p->timer); + spin_unlock(&priv_p->lock); return; // add_timer(&gpriv->timer); // spin_unlock(&gpriv->lock); @@ -125,9 +125,9 @@ void ue_ip_timer(unsigned long data){ //--------------------------------------------------------------------------- // Called by ifconfig when the device is activated by ifconfig -int ue_ip_open(struct net_device *dev){ +int ue_ip_open(struct net_device *dev_pP){ //--------------------------------------------------------------------------- - struct ue_ip_priv *priv=netdev_priv(dev); + ue_ip_priv_t *priv_p=netdev_priv(dev_pP); // Address has already been set at init #ifndef OAI_NW_DRIVER_USE_NETLINK @@ -137,45 +137,45 @@ int ue_ip_open(struct net_device *dev){ } #endif //OAI_NW_DRIVER_USE_NETLINK - if(!netif_queue_stopped(dev)) - netif_start_queue(dev); + if(!netif_queue_stopped(dev_pP)) + netif_start_queue(dev_pP); else - netif_wake_queue(dev); + netif_wake_queue(dev_pP); - init_timer(&priv->timer); - (priv->timer).expires = jiffies+UE_IP_TIMER_TICK; - (priv->timer).data = (unsigned long)priv; - (priv->timer).function = ue_ip_timer; - //add_timer(&priv->timer); + init_timer(&priv_p->timer); + (priv_p->timer).expires = jiffies+UE_IP_TIMER_TICK; + (priv_p->timer).data = (unsigned long)priv_p; + (priv_p->timer).function = ue_ip_timer; + //add_timer(&priv_p->timer); - printk("[UE_IP_DRV][%s] name = %s\n", __FUNCTION__, dev->name); + printk("[UE_IP_DRV][%s] name = %s\n", __FUNCTION__, dev_pP->name); return 0; } //--------------------------------------------------------------------------- // Called by ifconfig when the device is desactivated -int ue_ip_stop(struct net_device *dev){ +int ue_ip_stop(struct net_device *dev_pP){ //--------------------------------------------------------------------------- - struct ue_ip_priv *priv = netdev_priv(dev); + ue_ip_priv_t *priv_p = netdev_priv(dev_pP); printk("[UE_IP_DRV][%s] Begin\n", __FUNCTION__); - del_timer(&(priv->timer)); - netif_stop_queue(dev); + del_timer(&(priv_p->timer)); + netif_stop_queue(dev_pP); // MOD_DEC_USE_COUNT; printk("[UE_IP_DRV][%s] End\n", __FUNCTION__); return 0; } //--------------------------------------------------------------------------- -void ue_ip_teardown(struct net_device *dev){ +void ue_ip_teardown(struct net_device *dev_pP){ //--------------------------------------------------------------------------- - struct ue_ip_priv *priv; + ue_ip_priv_t *priv_p; int inst; printk("[UE_IP_DRV][%s] Begin\n", __FUNCTION__); - if (dev) { - priv = netdev_priv(dev); - inst = ue_ip_find_inst(dev); + if (dev_pP) { + priv_p = netdev_priv(dev_pP); + inst = ue_ip_find_inst(dev_pP); if ((inst<0) || (inst>=UE_IP_NB_INSTANCES_MAX)) { printk("[UE_IP_DRV][%s] ERROR, couldn't find instance\n", __FUNCTION__); return; @@ -183,38 +183,38 @@ void ue_ip_teardown(struct net_device *dev){ printk("[UE_IP_DRV][%s] End\n", __FUNCTION__); - } // check dev + } // check dev_pP else { printk("[UE_IP_DRV][%s] Device is null\n", __FUNCTION__); } } //--------------------------------------------------------------------------- -int ue_ip_set_config(struct net_device *dev, struct ifmap *map){ +int ue_ip_set_config(struct net_device *dev_pP, struct ifmap *map_pP){ //--------------------------------------------------------------------------- printk("[UE_IP_DRV][%s] Begin\n", __FUNCTION__); - if (dev->flags & IFF_UP) + if (dev_pP->flags & IFF_UP) return -EBUSY; - if (map->base_addr != dev->base_addr) { + if (map_pP->base_addr != dev_pP->base_addr) { printk(KERN_WARNING "[UE_IP_DRV][%s] Can't change I/O address\n", __FUNCTION__); return -EOPNOTSUPP; } - if (map->irq != dev->irq) - dev->irq = map->irq; + if (map_pP->irq != dev_pP->irq) + dev_pP->irq = map_pP->irq; printk("[UE_IP_DRV][%s] End\n", __FUNCTION__); return 0; } //--------------------------------------------------------------------------- // -int ue_ip_hard_start_xmit(struct sk_buff *skb, struct net_device *dev){ +int ue_ip_hard_start_xmit(struct sk_buff *skb_pP, struct net_device *dev_pP){ //--------------------------------------------------------------------------- int inst; - if (dev) { - inst = ue_ip_find_inst(dev); + if (dev_pP) { + inst = ue_ip_find_inst(dev_pP); } else { - printk("[UE_IP_DRV][%s] ERROR, device is null\n", __FUNCTION__); - return -1; + printk("[UE_IP_DRV][%s] ERROR, device is null\n", __FUNCTION__); + return -1; } if ((inst>=0) && (inst<UE_IP_NB_INSTANCES_MAX)) { @@ -222,25 +222,25 @@ int ue_ip_hard_start_xmit(struct sk_buff *skb, struct net_device *dev){ printk("[UE_IP_DRV][%s] inst %d, begin\n", __FUNCTION__,inst); #endif - if (!skb){ + if (!skb_pP){ printk("[UE_IP_DRV][%s] input parameter skb is NULL\n", __FUNCTION__); return -1; } // End debug information - netif_stop_queue(dev); - dev->trans_start = jiffies; + netif_stop_queue(dev_pP); + dev_pP->trans_start = jiffies; #ifdef OAI_DRV_DEBUG_DEVICE printk("[UE_IP_DRV][%s] step 1\n", __FUNCTION__); #endif - ue_ip_common_ip2wireless(skb,inst); + ue_ip_common_ip2wireless(skb_pP,inst); #ifdef OAI_DRV_DEBUG_DEVICE printk("[UE_IP_DRV][%s] step 2\n", __FUNCTION__); #endif - dev_kfree_skb(skb); + dev_kfree_skb(skb_pP); #ifdef OAI_DRV_DEBUG_DEVICE printk("[UE_IP_DRV][%s] step 3\n", __FUNCTION__); #endif - netif_wake_queue(dev); + netif_wake_queue(dev_pP); #ifdef OAI_DRV_DEBUG_DEVICE printk("[UE_IP_DRV][%s] end\n", __FUNCTION__); #endif @@ -252,50 +252,48 @@ int ue_ip_hard_start_xmit(struct sk_buff *skb, struct net_device *dev){ } //--------------------------------------------------------------------------- -struct net_device_stats *ue_ip_get_stats(struct net_device *dev){ +struct net_device_stats *ue_ip_get_stats(struct net_device *dev_pP){ //--------------------------------------------------------------------------- - // return &((struct ue_ip_priv *)dev->priv)->stats; - struct ue_ip_priv *priv = netdev_priv(dev); - //printk("[UE_IP_DRV][%s]\n", __FUNCTION__); - return &priv->stats; + ue_ip_priv_t *priv_p = netdev_priv(dev_pP); + return &priv_p->stats; } //--------------------------------------------------------------------------- -int ue_ip_set_mac_address(struct net_device *dev, void *mac) { +int ue_ip_set_mac_address(struct net_device *dev_pP, void *mac_pP) { //--------------------------------------------------------------------------- - //struct sockaddr *addr = mac; + //struct sockaddr *addr = mac_pP; printk("[UE_IP_DRV][%s] CHANGE MAC ADDRESS UNSUPPORTED\n", __FUNCTION__); - //memcpy(dev->dev_addr, addr->sa_data, dev->addr_len); + //memcpy(dev_pP->dev_addr, addr->sa_data, dev_pP->addr_len); return 0; } //--------------------------------------------------------------------------- -int ue_ip_change_mtu(struct net_device *dev, int mtu){ +int ue_ip_change_mtu(struct net_device *dev_pP, int mtuP){ //--------------------------------------------------------------------------- - printk("[UE_IP_DRV][%s] CHANGE MTU %d bytes\n", __FUNCTION__, mtu); - if ((mtu<50) || (mtu>1500)) + printk("[UE_IP_DRV][%s] CHANGE MTU %d bytes\n", __FUNCTION__, mtuP); + if ((mtuP<50) || (mtuP>1500)) return -EINVAL; - dev->mtu = mtu; + dev_pP->mtu = mtuP; return 0; } //--------------------------------------------------------------------------- -void ue_ip_change_rx_flags(struct net_device *dev, int flags){ +void ue_ip_change_rx_flags(struct net_device *dev_pP, int flagsP){ //--------------------------------------------------------------------------- - struct ue_ip_priv *priv = netdev_priv(dev); - printk("[UE_IP_DRV][%s] CHANGE RX FLAGS %08X\n", __FUNCTION__, flags); - priv->rx_flags ^= flags; + ue_ip_priv_t *priv_p = netdev_priv(dev_pP); + printk("[UE_IP_DRV][%s] CHANGE RX FLAGS %08X\n", __FUNCTION__, flagsP); + priv_p->rx_flags ^= flagsP; } //--------------------------------------------------------------------------- -void ue_ip_tx_timeout(struct net_device *dev){ +void ue_ip_tx_timeout(struct net_device *dev_pP){ //--------------------------------------------------------------------------- // Transmitter timeout, serious problems. - struct ue_ip_priv *priv = netdev_priv(dev); + ue_ip_priv_t *priv_p = netdev_priv(dev_pP); printk("[UE_IP_DRV][%s] begin\n", __FUNCTION__); - // (struct ue_ip_priv *)(dev->priv)->stats.tx_errors++; - (priv->stats).tx_errors++; - dev->trans_start = jiffies; - netif_wake_queue(dev); - printk("[UE_IP_DRV][%s] transmit timed out %s\n", __FUNCTION__,dev->name); + // (ue_ip_priv_t *)(dev_pP->priv_p)->stats.tx_errors++; + (priv_p->stats).tx_errors++; + dev_pP->trans_start = jiffies; + netif_wake_queue(dev_pP); + printk("[UE_IP_DRV][%s] transmit timed out %s\n", __FUNCTION__,dev_pP->name); } static const struct net_device_ops ue_ip_netdev_ops = { @@ -315,23 +313,23 @@ static const struct net_device_ops ue_ip_netdev_ops = { //--------------------------------------------------------------------------- // Initialisation of the network device -void ue_ip_init(struct net_device *dev){ +void ue_ip_init(struct net_device *dev_pP){ //--------------------------------------------------------------------------- - struct ue_ip_priv *priv; - if (dev) { - priv = netdev_priv(dev); - memset(priv, 0, sizeof(struct ue_ip_priv)); - spin_lock_init(&priv->lock); + ue_ip_priv_t *priv_p = NULL; + if (dev_pP) { + priv_p = netdev_priv(dev_pP); + memset(priv_p, 0, sizeof(ue_ip_priv_t)); + spin_lock_init(&priv_p->lock); #ifdef KERNEL_VERSION_GREATER_THAN_2629 - dev->netdev_ops = &ue_ip_netdev_ops; + dev_pP->netdev_ops = &ue_ip_netdev_ops; #else #error "KERNEL VERSION MUST BE NEWER THAN 2.6.29" #endif - dev->hard_header_len = 0; - dev->addr_len = UE_IP_ADDR_LEN; - dev->flags = IFF_BROADCAST|IFF_MULTICAST|IFF_NOARP; - dev->tx_queue_len = UE_IP_TX_QUEUE_LEN; - dev->mtu = UE_IP_MTU; + dev_pP->hard_header_len = 0; + dev_pP->addr_len = UE_IP_ADDR_LEN; + dev_pP->flags = IFF_BROADCAST|IFF_MULTICAST|IFF_NOARP; + dev_pP->tx_queue_len = UE_IP_TX_QUEUE_LEN; + dev_pP->mtu = UE_IP_MTU; } else { printk("[UE_IP_DRV][%s] ERROR, Device is NULL!!\n", __FUNCTION__); return; @@ -350,7 +348,7 @@ int init_module (void) { for (inst=0;inst<UE_IP_NB_INSTANCES_MAX;inst++) { printk("[UE_IP_DRV][%s] begin init instance %d\n", __FUNCTION__,inst); sprintf(devicename,"oip%d",inst); - ue_ip_dev[inst] = alloc_netdev(sizeof(struct ue_ip_priv),devicename, ue_ip_init); + ue_ip_dev[inst] = alloc_netdev(sizeof(ue_ip_priv_t),devicename, ue_ip_init); //netif_stop_queue(ue_ip_dev[inst]); if (ue_ip_dev[inst] == NULL) { printk("[UE_IP_DRV][%s][INST %02d] alloc_netdev FAILED\n", __FUNCTION__,inst); diff --git a/openair2/NETWORK_DRIVER/UE_IP/local.h b/openair2/NETWORK_DRIVER/UE_IP/local.h index 9454e7eaf3b8f27a58f12032fd0328b4475df5d0..cb45ffc609d081cfe551e2fb69e252fcb13c2ec4 100755 --- a/openair2/NETWORK_DRIVER/UE_IP/local.h +++ b/openair2/NETWORK_DRIVER/UE_IP/local.h @@ -63,33 +63,34 @@ #include "constant.h" +#include "platform_types.h" #include "sap.h" -struct ue_ip_priv { +typedef struct ue_ip_priv_s { int irq; int rx_flags; struct timer_list timer; spinlock_t lock; struct net_device_stats stats; - u8 retry_limit; - u32 timer_establishment; - u32 timer_release; + uint8_t retry_limit; + uint32_t timer_establishment; + uint32_t timer_release; struct sock *nl_sk; - u8 nlmsg[UE_IP_PRIMITIVE_MAX_LENGTH+sizeof(struct nlmsghdr)]; - u8 xbuffer[UE_IP_PRIMITIVE_MAX_LENGTH]; // transmition buffer - u8 rbuffer[UE_IP_PRIMITIVE_MAX_LENGTH]; // reception buffer -}; + uint8_t nlmsg[UE_IP_PRIMITIVE_MAX_LENGTH+sizeof(struct nlmsghdr)]; + uint8_t xbuffer[UE_IP_PRIMITIVE_MAX_LENGTH]; // transmition buffer + uint8_t rbuffer[UE_IP_PRIMITIVE_MAX_LENGTH]; // reception buffer +} ue_ip_priv_t; -struct ipversion { +typedef struct ipversion_s { #if defined(__LITTLE_ENDIAN_BITFIELD) - u8 reserved:4, + uint8_t reserved:4, version:4; #else - u8 version:4, + uint8_t version:4, reserved:4; #endif -}; +}ipversion_t; typedef struct pdcp_data_req_header_s { diff --git a/openair2/NETWORK_DRIVER/UE_IP/proto_extern.h b/openair2/NETWORK_DRIVER/UE_IP/proto_extern.h index d450f2d18cfdf761602b782e35f6b2780d3fb41a..a6df12f22774ebc3c7400d6165f6caf5848876eb 100755 --- a/openair2/NETWORK_DRIVER/UE_IP/proto_extern.h +++ b/openair2/NETWORK_DRIVER/UE_IP/proto_extern.h @@ -82,10 +82,10 @@ int ue_ip_find_inst(struct net_device *dev); @param inst Instance number @param rb_id Radio Bearer Id */ -void ue_ip_common_class_wireless2ip(unsigned short dlen, - void *pdcp_sdu, - int inst, - OaiNwDrvRadioBearerId_t rb_id); +void ue_ip_common_class_wireless2ip(sdu_size_t dlen, + void *pdcp_sdu, + int inst, + rb_id_t rb_id); /** \fn void ue_ip_common_ip2wireless(struct sk_buff *skb, struct cx_entity *cx, struct classifier_entity *gc,int inst)