void sendDataPacket (TI_HANDLE hOs) { TI_UINT32 i; TTxCtrlBlk * pPktCtrlBlk; TI_UINT8 * pPktBuf; TEthernetHeader tEthHeader; char SrcBssid[6] = {0x88,0x88,0x88,0x88,0x88,0x88}; char DesBssid[6] = {0x22,0x22,0x22,0x22,0x22,0x22}; /* Allocate a TxCtrlBlk for the Tx packet and save timestamp, length and packet handle */ pPktCtrlBlk = TWD_txCtrlBlk_Alloc (tmp_hTWD); if( NULL == pPktCtrlBlk ) { os_printf("\n sendDataPacket() : pPktCtrlBlk returned as NULL from TWD_txCtrlBlk_Alloc() "); return; } pPktCtrlBlk->tTxDescriptor.startTime = os_timeStampMs (hOs); pPktCtrlBlk->tTxDescriptor.length = (TI_UINT16)packetLength + ETHERNET_HDR_LEN; pPktCtrlBlk->tTxDescriptor.tid = 0; pPktCtrlBlk->tTxPktParams.uPktType = TX_PKT_TYPE_ETHER; /* Allocate buffer with headroom for getting the IP header in a 4-byte aligned address */ pPktBuf = txCtrl_AllocPacketBuffer (tmp_hTxCtrl, pPktCtrlBlk, packetLength + ETHERNET_HDR_LEN + 2); /* Prepare Ethernet header */ tEthHeader.type = HTOWLANS(ETHERTYPE_IP); MAC_COPY (tEthHeader.src, SrcBssid); MAC_COPY (tEthHeader.dst, DesBssid); if( pPktBuf ) { os_memoryCopy (hOs, pPktBuf + 2, &tEthHeader, ETHERNET_HDR_LEN); /* Build BDL */ BUILD_TX_TWO_BUF_PKT_BDL (pPktCtrlBlk, pPktBuf + 2, ETHERNET_HDR_LEN, pPktBuf + 2 + ETHERNET_HDR_LEN, packetLength) /* Fill data buffer with incremented numbers */ for (i = 0; i < packetLength; i++) { *(pPktBuf + 2 + ETHERNET_HDR_LEN + i) = i; } } else {
/**************************************************************************************** * dummyPktReqCB * **************************************************************************************** DESCRIPTION: Callback for the TWD_OWN_EVENT_DUMMY_PKT_REQ event - transmits a dummy packet INPUT: - hTxMgmtQ - Handle to the TxMgmtQ module - str - Buffer containing the event data - strLen - Event data length OUTPUT: RETURN: void.\n ****************************************************************************************/ void dummyPktReqCB(TI_HANDLE hTxMgmtQ, char* str , TI_UINT32 strLen) { TTxMgmtQ *pTxMgmtQ = (TTxMgmtQ*)hTxMgmtQ; TTxCtrlBlk* pTxCtrlBlk; void* pPayload; const TI_UINT16 uDummyPktBufLen = 1400; TI_STATUS status; /* Allocate control block for dummy packet */ pTxCtrlBlk = TWD_txCtrlBlk_Alloc(pTxMgmtQ->hTWD); if (NULL == pTxCtrlBlk) { TRACE0(pTxMgmtQ->hReport, REPORT_SEVERITY_ERROR, "dummyPktReqCB: TxCtrlBlk allocation failed!\n"); return; } /* Allocate payload buffer */ pPayload = txCtrl_AllocPacketBuffer(pTxMgmtQ->hTxCtrl, pTxCtrlBlk, WLAN_HDR_LEN + uDummyPktBufLen); if (NULL == pPayload) { TRACE0(pTxMgmtQ->hReport, REPORT_SEVERITY_ERROR, "dummyPktReqCB: Packet buffer allocation failed!\n"); TWD_txCtrlBlk_Free (pTxMgmtQ->hTWD, pTxCtrlBlk); return; } /* Set packet parameters */ { pTxCtrlBlk->tTxDescriptor.startTime = os_timeStampMs(pTxMgmtQ->hOs); /* Mark as a Dummy Blocks Packet */ pTxCtrlBlk->tTxPktParams.uPktType = TX_PKT_TYPE_DUMMY_BLKS; BUILD_TX_TWO_BUF_PKT_BDL (pTxCtrlBlk, pTxCtrlBlk->aPktHdr, WLAN_HDR_LEN, pPayload, uDummyPktBufLen); } pTxMgmtQ->tDbgCounters.uDummyPackets++; /* Enqueue packet in the management-queues and run the scheduler. */ status = txMgmtQ_Xmit(pTxMgmtQ, pTxCtrlBlk, TI_FALSE); if (TI_NOK == status) { TRACE0(pTxMgmtQ->hReport, REPORT_SEVERITY_ERROR, "dummyPktReqCB: xmit failed!\n"); } }
/** * \fn wlanDrvIf_Xmit * \brief Packets transmission * * The network stack calls this function in order to transmit a packet * through the WLAN interface. * The packet is inserted to the drver Tx queues and its handling is continued * after switching to the driver context. * * \note * \param skb - The Linux packet buffer structure * \param dev - The driver network-interface handle * \return 0 (= OK) * \sa */ static int wlanDrvIf_Xmit (struct sk_buff *skb, struct net_device *dev) { TWlanDrvIfObj *drv = (TWlanDrvIfObj *)NETDEV_GET_PRIVATE(dev); TTxCtrlBlk * pPktCtrlBlk; int status; CL_TRACE_START_L1(); os_profile (drv, 0, 0); drv->stats.tx_packets++; drv->stats.tx_bytes += skb->len; /* Allocate a TxCtrlBlk for the Tx packet and save timestamp, length and packet handle */ pPktCtrlBlk = TWD_txCtrlBlk_Alloc (drv->tCommon.hTWD); pPktCtrlBlk->tTxDescriptor.startTime = os_timeStampMs(drv); /* remove use of skb->tstamp.off_usec */ pPktCtrlBlk->tTxDescriptor.length = skb->len; pPktCtrlBlk->tTxPktParams.pInputPkt = skb; /* Point the first BDL buffer to the Ethernet header, and the second buffer to the rest of the packet */ pPktCtrlBlk->tTxnStruct.aBuf[0] = skb->data; pPktCtrlBlk->tTxnStruct.aLen[0] = ETHERNET_HDR_LEN; pPktCtrlBlk->tTxnStruct.aBuf[1] = skb->data + ETHERNET_HDR_LEN; pPktCtrlBlk->tTxnStruct.aLen[1] = (TI_UINT16)skb->len - ETHERNET_HDR_LEN; pPktCtrlBlk->tTxnStruct.aLen[2] = 0; /* Send the packet to the driver for transmission. */ status = txDataQ_InsertPacket (drv->tCommon.hTxDataQ, pPktCtrlBlk,(TI_UINT8)skb->priority); /* If failed (queue full or driver not running), drop the packet. */ if (status != TI_OK) { drv->stats.tx_errors++; } os_profile (drv, 1, 0); CL_TRACE_END_L1("tiwlan_drv.ko", "OS", "TX", ""); return 0; }
TI_STATUS mlmeBuilder_sendFrame(TI_HANDLE hMlme, dot11MgmtSubType_e type, TI_UINT8 *pDataBuff, TI_UINT32 dataLen, TI_UINT8 setWepOpt) { mlme_t *pHandle = (mlme_t*)hMlme; TI_STATUS status; TTxCtrlBlk *pPktCtrlBlk; TI_UINT8 *pPktBuffer; TMacAddr daBssid, saBssid; dot11_mgmtHeader_t *pDot11Header; /* Allocate a TxCtrlBlk and data buffer (large enough for the max management packet) */ pPktCtrlBlk = TWD_txCtrlBlk_Alloc (pHandle->hTWD); if (pPktCtrlBlk == NULL) return TI_NOK; pPktBuffer = txCtrl_AllocPacketBuffer (pHandle->hTxCtrl, pPktCtrlBlk, MAX_MANAGEMENT_FRAME_BODY_LEN + WLAN_HDR_LEN); if (pPktBuffer == NULL) { TRACE0(pHandle->hReport, REPORT_SEVERITY_ERROR , ": No memory\n"); TWD_txCtrlBlk_Free (pHandle->hTWD, pPktCtrlBlk); return TI_NOK; } pDot11Header = (dot11_mgmtHeader_t *)(pPktCtrlBlk->aPktHdr); status = mlmeBuilder_buildFrameCtrl (pHandle, type, (TI_UINT16 *)&pDot11Header->fc, setWepOpt); if (status != TI_OK) { txCtrl_FreePacket (pHandle->hTxCtrl, pPktCtrlBlk, TI_NOK); return TI_NOK; } status = ctrlData_getParamBssid(pHandle->hCtrlData, CTRL_DATA_CURRENT_BSSID_PARAM, daBssid); if (status != TI_OK) { txCtrl_FreePacket (pHandle->hTxCtrl, pPktCtrlBlk, TI_NOK); return TI_NOK; } /* copy destination mac address */ MAC_COPY (pDot11Header->DA, daBssid); status = ctrlData_getParamMacAddr(pHandle->hCtrlData, saBssid); if (status != TI_OK) { txCtrl_FreePacket (pHandle->hTxCtrl, pPktCtrlBlk, TI_NOK); return TI_NOK; } /* copy source mac address */ MAC_COPY (pDot11Header->SA, saBssid); /* copy BSSID (destination mac address) */ MAC_COPY (pDot11Header->BSSID, daBssid); if (pDataBuff != NULL) { os_memoryCopy (pHandle->hOs, pPktBuffer, pDataBuff, dataLen); } /* Update packet parameters (start-time, length, pkt-type) */ pPktCtrlBlk->tTxDescriptor.startTime = os_timeStampMs (pHandle->hOs); pPktCtrlBlk->tTxPktParams.uPktType = TX_PKT_TYPE_MGMT; BUILD_TX_TWO_BUF_PKT_BDL (pPktCtrlBlk, (TI_UINT8 *)pDot11Header, WLAN_HDR_LEN, pPktBuffer, dataLen) /* Enqueue packet in the mgmt-queues and run the scheduler. */ status = txMgmtQ_Xmit (pHandle->hTxMgmtQ, pPktCtrlBlk, TI_FALSE); return status; }
static int xmit_Bridge (struct sk_buff *skb, struct net_device *dev, TIntraBssBridge *pBssBridgeParam) { TWlanDrvIfObj *drv = (TWlanDrvIfObj *)NETDEV_GET_PRIVATE(dev); TTxCtrlBlk * pPktCtrlBlk; TEthernetHeader *pEthHead = (TEthernetHeader *)(skb->data); int status; CL_TRACE_START_L1(); os_profile (drv, 0, 0); drv->stats.tx_packets++; drv->stats.tx_bytes += skb->len; /* Allocate a TxCtrlBlk for the Tx packet and save timestamp, length and packet handle */ pPktCtrlBlk = TWD_txCtrlBlk_Alloc (drv->tCommon.hTWD); if (pPktCtrlBlk == NULL) { drv->stats.tx_errors++; os_profile (drv, 1, 0); CL_TRACE_END_L1("tiwlan_drv.ko", "OS", "TX", ""); return 0; } /* Set interface type according to net device interface number */ if (drv->tCommon.eIfRole == IF_ROLE_TYPE_AP) SET_PKT_TYPE_IF_ROLE_AP(pPktCtrlBlk); else SET_PKT_TYPE_IF_ROLE_STA(pPktCtrlBlk); pPktCtrlBlk->tTxDescriptor.startTime = os_timeStampMs(drv); /* remove use of skb->tstamp.off_usec */ pPktCtrlBlk->tTxDescriptor.length = skb->len; pPktCtrlBlk->tTxPktParams.pInputPkt = skb; /* Check MGMT packet from hostapd, forward it to the Mgmt-Queue and exit without ethernet header */ if (HTOWLANS(pEthHead->type) == AP_MGMT_ETH_TYPE) { /* Copy WLAN header into aPktHdr - format for MGMT packets */ memcpy (pPktCtrlBlk->aPktHdr, skb->data + ETHERNET_HDR_LEN , WLAN_HDR_LEN ); /* Skip ethernet header, send as management frame */ pPktCtrlBlk->tTxPktParams.uPktType = TX_PKT_TYPE_MGMT; pPktCtrlBlk->tTxnStruct.aBuf[0] = (TI_UINT8 *)pPktCtrlBlk->aPktHdr; pPktCtrlBlk->tTxnStruct.aLen[0] = WLAN_HDR_LEN; pPktCtrlBlk->tTxnStruct.aBuf[1] = skb->data + ETHERNET_HDR_LEN + WLAN_HDR_LEN; pPktCtrlBlk->tTxnStruct.aLen[1] = (TI_UINT16)skb->len - ETHERNET_HDR_LEN - WLAN_HDR_LEN; pPktCtrlBlk->tTxnStruct.aLen[2] = 0; pPktCtrlBlk->tTxPktParams.uInputPktLen = skb->len; pPktCtrlBlk->tTxDescriptor.length = (TI_UINT16)((pPktCtrlBlk->tTxnStruct.aLen[0]) + (pPktCtrlBlk->tTxnStruct.aLen[1])); status = txMgmtQ_Xmit (drv->tCommon.hTxMgmtQ, pPktCtrlBlk, TI_TRUE); } else { /* Point the first BDL buffer to the Ethernet header, and the second buffer to the rest of the packet */ pPktCtrlBlk->tTxnStruct.aBuf[0] = skb->data; pPktCtrlBlk->tTxnStruct.aLen[0] = ETHERNET_HDR_LEN; pPktCtrlBlk->tTxnStruct.aBuf[1] = skb->data + ETHERNET_HDR_LEN; pPktCtrlBlk->tTxnStruct.aLen[1] = (TI_UINT16)skb->len - ETHERNET_HDR_LEN; pPktCtrlBlk->tTxnStruct.aLen[2] = 0; /* Send the packet to the driver for transmission. */ status = txDataQ_InsertPacket (drv->tCommon.hTxDataQ, pPktCtrlBlk,(TI_UINT8)skb->priority, pBssBridgeParam); } /* If failed (queue full or driver not running), drop the packet. */ if (status != TI_OK) { drv->stats.tx_errors++; } os_profile (drv, 1, 0); CL_TRACE_END_L1("tiwlan_drv.ko", "OS", "TX", ""); return 0; }