#define MAX_FRAGMENTEDIP_CLASSIFICATION_ENTRIES 256
 #include "Debug.h"
 
-struct _LEADER {
+struct bcm_leader {
        USHORT  Vcid;
        USHORT  PLength;
        UCHAR   Status;
        UCHAR   Unused[3];
 } __packed;
-typedef struct _LEADER LEADER, *PLEADER;
 
 struct bcm_packettosend {
-       LEADER  Leader;
+       struct bcm_leader Leader;
        UCHAR   ucPayload;
 } __packed;
 
 } __packed;
 
 struct bcm_link_request {
-       LEADER  Leader;
+       struct bcm_leader Leader;
        UCHAR   szData[4];
 } __packed;
 
 
        stServiceFlowParamSI *psfLocalSet = NULL;
        stLocalSFAddIndicationAlt *pstAddIndication = NULL;
        stLocalSFChangeIndicationAlt *pstChangeIndication = NULL;
-       PLEADER pLeader = NULL;
+       struct bcm_leader *pLeader = NULL;
 
        /*
         * Otherwise the message contains a target address from where we need to
 
        DumpCmControlPacket(pstAddIndication);
        BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "====>");
-       pLeader = (PLEADER)Adapter->caDsxReqResp;
+       pLeader = (struct bcm_leader *)Adapter->caDsxReqResp;
 
        pLeader->Status = CM_CONTROL_NEWDSX_MULTICLASSIFIER_REQ;
        pLeader->Vcid = 0;
 
        PUSB_RCB pRcb = (PUSB_RCB)urb->context;
        PS_INTERFACE_ADAPTER psIntfAdapter = pRcb->psIntfAdapter;
        PMINI_ADAPTER Adapter = psIntfAdapter->psAdapter;
-       PLEADER pLeader = urb->transfer_buffer;
+       struct bcm_leader *pLeader = urb->transfer_buffer;
 
        if (unlikely(netif_msg_rx_status(Adapter)))
                pr_info(PFX "%s: rx urb status %d length %d\n",
            BCM_DEBUG_PRINT(psIntfAdapter->psAdapter,DBG_TYPE_RX, RX_CTRL, DBG_LVL_ALL, "Received control pkt...");
                *(PUSHORT)skb->data = pLeader->Status;
                memcpy(skb->data+sizeof(USHORT), urb->transfer_buffer +
-                       (sizeof(LEADER)), pLeader->PLength);
+                       (sizeof(struct bcm_leader)), pLeader->PLength);
                skb->len = pLeader->PLength + sizeof(USHORT);
 
                spin_lock(&Adapter->control_queue_lock);
                  */
         BCM_DEBUG_PRINT(psIntfAdapter->psAdapter,DBG_TYPE_RX, RX_DATA, DBG_LVL_ALL, "Received Data pkt...");
                skb_reserve(skb, 2 + SKB_RESERVE_PHS_BYTES);
-               memcpy(skb->data+ETH_HLEN, (PUCHAR)urb->transfer_buffer + sizeof(LEADER), pLeader->PLength);
+               memcpy(skb->data+ETH_HLEN, (PUCHAR)urb->transfer_buffer + sizeof(struct bcm_leader), pLeader->PLength);
                skb->dev = Adapter->dev;
 
                /* currently skb->len has extra ETH_HLEN bytes in the beginning */
 
                                {
                                        spin_lock_bh(&psSF->SFQueueLock);
                                        psSF->NumOfPacketsSent++;
-                                       psSF->uiSentBytes+=((PLEADER)pControlPacket)->PLength;
+                                       psSF->uiSentBytes+=((struct bcm_leader *)pControlPacket)->PLength;
                                        psSF->uiSentPackets++;
                                        atomic_dec(&Adapter->TotalPacketCount);
-                                       psSF->uiCurrentBytesOnHost -= ((PLEADER)pControlPacket)->PLength;
+                                       psSF->uiCurrentBytesOnHost -= ((struct bcm_leader *)pControlPacket)->PLength;
                                        psSF->uiCurrentPacketsOnHost--;
                                        atomic_inc(&Adapter->index_rd_txcntrlpkt);
                                        spin_unlock_bh(&psSF->SFQueueLock);
 
 /*Leader related terms */
 #define LEADER_STATUS         0x00
 #define LEADER_STATUS_TCP_ACK 0x1
-#define LEADER_SIZE           sizeof(LEADER)
+#define LEADER_SIZE           sizeof(struct bcm_leader)
 #define MAC_ADDR_REQ_SIZE     sizeof(struct bcm_packettosend)
 #define SS_INFO_REQ_SIZE      sizeof(struct bcm_packettosend)
 #define CM_REQUEST_SIZE       (LEADER_SIZE + sizeof(stLocalSFChangeRequest))
 
  */
 INT CopyBufferToControlPacket(PMINI_ADAPTER Adapter, PVOID ioBuffer)
 {
-       PLEADER pLeader = NULL;
+       struct bcm_leader *pLeader = NULL;
        INT Status = 0;
        unsigned char *ctrl_buff = NULL;
        UINT pktlen = 0;
        }
 
        pLinkReq = (struct bcm_link_request *)ioBuffer;
-       pLeader = (PLEADER)ioBuffer; /* ioBuffer Contains sw_Status and Payload */
+       pLeader = (struct bcm_leader *)ioBuffer; /* ioBuffer Contains sw_Status and Payload */
 
        if (Adapter->bShutStatus == TRUE &&
                pLinkReq->szData[0] == LINK_DOWN_REQ_PAYLOAD &&
 
                memset(ctrl_buff, 0, pktlen+LEADER_SIZE);
                BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "Copying the Control Packet Buffer with length=%d\n", pLeader->PLength);
-               *(PLEADER)ctrl_buff = *pLeader;
+               *(struct bcm_leader *)ctrl_buff = *pLeader;
                memcpy(ctrl_buff + LEADER_SIZE, ((PUCHAR)ioBuffer + LEADER_SIZE), pLeader->PLength);
                BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "Enqueuing the Control Packet");
 
 
 */
 INT SendControlPacket(PMINI_ADAPTER Adapter, char *pControlPacket)
 {
-       PLEADER PLeader = (PLEADER)pControlPacket;
+       struct bcm_leader *PLeader = (struct bcm_leader *)pControlPacket;
 
        BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "Tx");
        if(!pControlPacket || !Adapter)
        BOOLEAN bHeaderSupressionEnabled = FALSE;
        B_UINT16            uiClassifierRuleID;
        u16     QueueIndex = skb_get_queue_mapping(Packet);
-       LEADER Leader={0};
+       struct bcm_leader Leader={0};
 
        if(Packet->len > MAX_DEVICE_DESC_SIZE)
        {
        else
        {
                Leader.PLength = Packet->len - ETH_HLEN;
-               memcpy((LEADER*)skb_pull(Packet, (ETH_HLEN - LEADER_SIZE)), &Leader, LEADER_SIZE);
+               memcpy((struct bcm_leader *)skb_pull(Packet, (ETH_HLEN - LEADER_SIZE)), &Leader, LEADER_SIZE);
        }
 
        status = Adapter->interface_transmit(Adapter->pvInterfaceAdapter,