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)