/* * *************************************************************************** * FILE: unifi_event.c * * PURPOSE: * Process the signals received by UniFi. * It is part of the porting exercise. * * Copyright (C) 2009 by Cambridge Silicon Radio Ltd. * * Refer to LICENSE.txt included with this source code for details on * the license terms. * * *************************************************************************** */ /* * Porting notes: * The implementation of unifi_receive_event() in Linux is fairly complicated. * The linux driver support multiple userspace applications and several * build configurations, so the received signals are processed by different * processes and multiple times. * In a simple implementation, this function needs to deliver: * - The MLME-UNITDATA.ind signals to the Rx data plane and to the Traffic * Analysis using unifi_ta_sample(). * - The MLME-UNITDATA-STATUS.ind signals to the Tx data plane. * - All the other signals to the SME using unifi_sys_hip_ind(). */ #include "csr_wifi_hip_unifi.h" #include "csr_wifi_hip_conversions.h" #include "unifi_priv.h" /* * --------------------------------------------------------------------------- * send_to_client * * Helper for unifi_receive_event. * * This function forwards a signal to one client. * * Arguments: * priv Pointer to driver's private data. * client Pointer to the client structure. * receiver_id The reciever id of the signal. * sigdata Pointer to the packed signal buffer. * siglen Length of the packed signal. * bulkdata Pointer to the signal's bulk data. * * Returns: * None. * * --------------------------------------------------------------------------- */ static void send_to_client(unifi_priv_t *priv, ul_client_t *client, int receiver_id, unsigned char *sigdata, int siglen, const bulk_data_param_t *bulkdata) { if (client && client->event_hook) { /*unifi_trace(priv, UDBG3, "Receive: client %d, (s:0x%X, r:0x%X) - Signal 0x%.4X \n", client->client_id, client->sender_id, receiver_id, CSR_GET_UINT16_FROM_LITTLE_ENDIAN(sigdata));*/ client->event_hook(client, sigdata, siglen, bulkdata, UDI_TO_HOST); } } /* * --------------------------------------------------------------------------- * process_pkt_data_ind * * Dispatcher for received signals. * * This function receives the 'to host' signals and forwards * them to the unifi linux clients. * * Arguments: * priv Context * sigdata Pointer to the packed signal buffer(Its in form of MA-PACKET.ind). * bulkdata Pointer to signal's bulkdata * freeBulkData Pointer to a flag which gets set if the bulkdata needs to * be freed after calling the logging handlers. If it is not * set the bulkdata must be freed by the MLME handler or * passed to the network stack. * Returns: * TRUE if the packet should be routed to the SME etc. * FALSE if the packet is for the driver or network stack * --------------------------------------------------------------------------- */ static u8 check_routing_pkt_data_ind(unifi_priv_t *priv, u8 *sigdata, const bulk_data_param_t* bulkdata, u8 *freeBulkData, netInterface_priv_t *interfacePriv) { u16 frmCtrl, receptionStatus, frmCtrlSubType; u8 *macHdrLocation; u8 interfaceTag; u8 isDataFrame; u8 isProtocolVerInvalid = FALSE; u8 isDataFrameSubTypeNoData = FALSE; #ifdef CSR_WIFI_SECURITY_WAPI_ENABLE static const u8 wapiProtocolIdSNAPHeader[] = {0x88,0xb4}; static const u8 wapiProtocolIdSNAPHeaderOffset = 6; u8 *destAddr; u8 *srcAddr; u8 isWapiUnicastPkt = FALSE; #ifdef CSR_WIFI_SECURITY_WAPI_QOSCTRL_MIC_WORKAROUND u16 qosControl; #endif u8 llcSnapHeaderOffset = 0; destAddr = (u8 *) bulkdata->d[0].os_data_ptr + MAC_HEADER_ADDR1_OFFSET; srcAddr = (u8 *) bulkdata->d[0].os_data_ptr + MAC_HEADER_ADDR2_OFFSET; /*Individual/Group bit - Bit 0 of first byte*/ isWapiUnicastPkt = (!(destAddr[0] & 0x01)) ? TRUE : FALSE; #endif #define CSR_WIFI_MA_PKT_IND_RECEPTION_STATUS_OFFSET sizeof(CSR_SIGNAL_PRIMITIVE_HEADER) + 22 *freeBulkData = FALSE; /* Fetch the MAC header location from MA_PKT_IND packet */ macHdrLocation = (u8 *) bulkdata->d[0].os_data_ptr; /* Fetch the Frame Control value from MAC header */ frmCtrl = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(macHdrLocation); /* Pull out interface tag from virtual interface identifier */ interfaceTag = (CSR_GET_UINT16_FROM_LITTLE_ENDIAN(sigdata + 14)) & 0xff; /* check for MIC failure before processing the signal */ receptionStatus = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(sigdata + CSR_WIFI_MA_PKT_IND_RECEPTION_STATUS_OFFSET); /* To discard any spurious MIC failures that could be reported by the firmware */ isDataFrame = ((frmCtrl & IEEE80211_FC_TYPE_MASK) == (IEEE802_11_FC_TYPE_DATA & IEEE80211_FC_TYPE_MASK)) ? TRUE : FALSE; /* 0x00 is the only valid protocol version*/ isProtocolVerInvalid = (frmCtrl & IEEE80211_FC_PROTO_VERSION_MASK) ? TRUE : FALSE; frmCtrlSubType = (frmCtrl & IEEE80211_FC_SUBTYPE_MASK) >> FRAME_CONTROL_SUBTYPE_FIELD_OFFSET; /*Exclude the no data & reserved sub-types from MIC failure processing*/ isDataFrameSubTypeNoData = (((frmCtrlSubType>0x03)&&(frmCtrlSubType<0x08)) || (frmCtrlSubType>0x0B)) ? TRUE : FALSE; if ((receptionStatus == CSR_MICHAEL_MIC_ERROR) && ((!isDataFrame) || isProtocolVerInvalid || (isDataFrame && isDataFrameSubTypeNoData))) { /* Currently MIC errors are discarded for frames other than data frames. This might need changing when we start * supporting 802.11w (Protected Management frames) */ *freeBulkData = TRUE; unifi_trace(priv, UDBG4, "Discarding this frame and ignoring the MIC failure as this is a garbage/non-data/no data frame\n"); return FALSE; } #ifdef CSR_WIFI_SECURITY_WAPI_ENABLE if (receptionStatus == CSR_MICHAEL_MIC_ERROR) { if (interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_STA) { #ifdef CSR_WIFI_SECURITY_WAPI_QOSCTRL_MIC_WORKAROUND if ((isDataFrame) && ((IEEE802_11_FC_TYPE_QOS_DATA & IEEE80211_FC_SUBTYPE_MASK) == (frmCtrl & IEEE80211_FC_SUBTYPE_MASK)) && (priv->isWapiConnection)) { qosControl = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(macHdrLocation + (((frmCtrl & IEEE802_11_FC_TO_DS_MASK) && (frmCtrl & IEEE802_11_FC_FROM_DS_MASK)) ? 30 : 24) ); unifi_trace(priv, UDBG4, "check_routing_pkt_data_ind() :: Value of the QoS control field - 0x%04x \n", qosControl); if (qosControl & IEEE802_11_QC_NON_TID_BITS_MASK) { unifi_trace(priv, UDBG4, "Ignore the MIC failure and pass the MPDU to the stack when any of bits [4-15] is set in the QoS control field\n"); /*Exclude the MIC [16] and the PN [16] that are appended by the firmware*/ ((bulk_data_param_t*)bulkdata)->d[0].data_length = bulkdata->d[0].data_length - 32; /*Clear the reception status of the signal (CSR_RX_SUCCESS)*/ *(sigdata + CSR_WIFI_MA_PKT_IND_RECEPTION_STATUS_OFFSET) = 0x00; *(sigdata + CSR_WIFI_MA_PKT_IND_RECEPTION_STATUS_OFFSET+1) = 0x00; *freeBulkData = FALSE; return FALSE; } } #endif /* If this MIC ERROR reported by the firmware is either for * [1] a WAPI Multicast MPDU and the Multicast filter has NOT been set (It is set only when group key index (MSKID) = 1 in Group Rekeying) OR * [2] a WAPI Unicast MPDU and either the CONTROL PORT is open or the WAPI Unicast filter or filter(s) is NOT set * then report a MIC FAILURE indication to the SME. */ #ifndef CSR_WIFI_SECURITY_WAPI_SW_ENCRYPTION if ((priv->wapi_multicast_filter == 0) || isWapiUnicastPkt) { #else /*When SW encryption is enabled and USKID=1 (wapi_unicast_filter = 1), we are expected *to receive MIC failure INDs for unicast MPDUs*/ if ( ((priv->wapi_multicast_filter == 0) && !isWapiUnicastPkt) || ((priv->wapi_unicast_filter == 0) && isWapiUnicastPkt) ) { #endif /*Discard the frame*/ *freeBulkData = TRUE; unifi_trace(priv, UDBG4, "Discarding the contents of the frame with MIC failure \n"); if (isWapiUnicastPkt && ((uf_sme_port_state(priv,srcAddr,UF_CONTROLLED_PORT_Q,interfaceTag) != CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_OPEN)|| #ifndef CSR_WIFI_SECURITY_WAPI_SW_ENCRYPTION (priv->wapi_unicast_filter) || #endif (priv->wapi_unicast_queued_pkt_filter))) { /* Workaround to handle MIC failures reported by the firmware for encrypted packets from the AP * while we are in the process of re-association induced by unsupported WAPI Unicast key index * - Discard the packets with MIC failures "until" we have * a. negotiated a key, * b. opened the CONTROL PORT and * c. the AP has started using the new key */ unifi_trace(priv, UDBG4, "Ignoring the MIC failure as either a. CONTROL PORT isn't OPEN or b. Unicast filter is set or c. WAPI AP using old key for buffered pkts\n"); /*Ignore this MIC failure*/ return FALSE; }/*WAPI re-key specific workaround*/ unifi_trace(priv, UDBG6, "check_routing_pkt_data_ind - MIC FAILURE : interfaceTag %x Src Addr %x:%x:%x:%x:%x:%x\n", interfaceTag, srcAddr[0], srcAddr[1], srcAddr[2], srcAddr[3], srcAddr[4], srcAddr[5]); unifi_trace(priv, UDBG6, "check_routing_pkt_data_ind - MIC FAILURE : Dest Addr %x:%x:%x:%x:%x:%x\n", destAddr[0], destAddr[1], destAddr[2], destAddr[3], destAddr[4], destAddr[5]); unifi_trace(priv, UDBG6, "check_routing_pkt_data_ind - MIC FAILURE : Control Port State - 0x%.4X \n", uf_sme_port_state(priv,srcAddr,UF_CONTROLLED_PORT_Q,interfaceTag)); unifi_error(priv, "MIC failure in %s\n", __FUNCTION__); /*Report the MIC failure to the SME*/ return TRUE; } }/* STA mode */ else { /* Its AP Mode . Just Return */ *freeBulkData = TRUE; unifi_error(priv, "MIC failure in %s\n", __FUNCTION__); return TRUE; } /* AP mode */ }/* MIC error */ #else if (receptionStatus == CSR_MICHAEL_MIC_ERROR) { *freeBulkData = TRUE; unifi_error(priv, "MIC failure in %s\n", __FUNCTION__); return TRUE; } #endif /*CSR_WIFI_SECURITY_WAPI_ENABLE*/ unifi_trace(priv, UDBG4, "frmCtrl = 0x%04x %s\n", frmCtrl, (((frmCtrl & 0x000c)>>FRAME_CONTROL_TYPE_FIELD_OFFSET) == IEEE802_11_FRAMETYPE_MANAGEMENT) ? "Mgt" : "Ctrl/Data"); #ifdef CSR_WIFI_SECURITY_WAPI_ENABLE /* To ignore MIC failures reported due to the WAPI AP using the old key for queued packets before * starting to use the new key negotiated as part of unicast re-keying */ if ((interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_STA)&& isWapiUnicastPkt && (receptionStatus == CSR_RX_SUCCESS) && (priv->wapi_unicast_queued_pkt_filter==1)) { unifi_trace(priv, UDBG6, "check_routing_pkt_data_ind(): WAPI unicast pkt received when the (wapi_unicast_queued_pkt_filter) is set\n"); if (isDataFrame) { switch(frmCtrl & IEEE80211_FC_SUBTYPE_MASK) { case IEEE802_11_FC_TYPE_QOS_DATA & IEEE80211_FC_SUBTYPE_MASK: llcSnapHeaderOffset = MAC_HEADER_SIZE + 2; break; case IEEE802_11_FC_TYPE_QOS_NULL & IEEE80211_FC_SUBTYPE_MASK: case IEEE802_11_FC_TYPE_NULL & IEEE80211_FC_SUBTYPE_MASK: break; default: llcSnapHeaderOffset = MAC_HEADER_SIZE; } } if (llcSnapHeaderOffset > 0) { /* QoS data or Data */ unifi_trace(priv, UDBG6, "check_routing_pkt_data_ind(): SNAP header found & its offset %d\n",llcSnapHeaderOffset); if (memcmp((u8 *)(bulkdata->d[0].os_data_ptr+llcSnapHeaderOffset+wapiProtocolIdSNAPHeaderOffset), wapiProtocolIdSNAPHeader,sizeof(wapiProtocolIdSNAPHeader))) { unifi_trace(priv, UDBG6, "check_routing_pkt_data_ind(): This is a data & NOT a WAI protocol packet\n"); /* On the first unicast data pkt that is decrypted successfully after re-keying, reset the filter */ priv->wapi_unicast_queued_pkt_filter = 0; unifi_trace(priv, UDBG4, "check_routing_pkt_data_ind(): WAPI AP has started using the new unicast key, no more MIC failures expected (reset filter)\n"); } else { unifi_trace(priv, UDBG6, "check_routing_pkt_data_ind(): WAPI - This is a WAI protocol packet\n"); } } } #endif switch ((frmCtrl & 0x000c)>>FRAME_CONTROL_TYPE_FIELD_OFFSET) { case IEEE802_11_FRAMETYPE_MANAGEMENT: *freeBulkData = TRUE; /* Free (after SME handler copies it) */ /* In P2P device mode, filter the legacy AP beacons here */ if((interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2P)&&\ ((CSR_WIFI_80211_GET_FRAME_SUBTYPE(macHdrLocation)) == CSR_WIFI_80211_FRAME_SUBTYPE_BEACON)){ u8 *pSsid, *pSsidLen; static u8 P2PWildCardSsid[CSR_WIFI_P2P_WILDCARD_SSID_LENGTH] = {'D', 'I', 'R', 'E', 'C', 'T', '-'}; pSsidLen = macHdrLocation + MAC_HEADER_SIZE + CSR_WIFI_BEACON_FIXED_LENGTH; pSsid = pSsidLen + 2; if(*(pSsidLen + 1) >= CSR_WIFI_P2P_WILDCARD_SSID_LENGTH){ if(memcmp(pSsid, P2PWildCardSsid, CSR_WIFI_P2P_WILDCARD_SSID_LENGTH) == 0){ unifi_trace(priv, UDBG6, "Received a P2P Beacon, pass it to SME\n"); return TRUE; } } unifi_trace(priv, UDBG6, "Received a Legacy AP beacon in P2P mode, drop it\n"); return FALSE; } return TRUE; /* Route to SME */ case IEEE802_11_FRAMETYPE_DATA: case IEEE802_11_FRAMETYPE_CONTROL: *freeBulkData = FALSE; /* Network stack or MLME handler frees */ return FALSE; default: unifi_error(priv, "Unhandled frame type %04x\n", frmCtrl); *freeBulkData = TRUE; /* Not interested, but must free it */ return FALSE; } } /* * --------------------------------------------------------------------------- * unifi_process_receive_event * * Dispatcher for received signals. * * This function receives the 'to host' signals and forwards * them to the unifi linux clients. * * Arguments: * ospriv Pointer to driver's private data. * sigdata Pointer to the packed signal buffer. * siglen Length of the packed signal. * bulkdata Pointer to the signal's bulk data. * * Returns: * None. * * Notes: * The signals are received in the format described in the host interface * specification, i.e wire formatted. Certain clients use the same format * to interpret them and other clients use the host formatted structures. * Each client has to call read_unpack_signal() to transform the wire * formatted signal into the host formatted signal, if necessary. * The code is in the core, since the signals are defined therefore * binded to the host interface specification. * --------------------------------------------------------------------------- */ static void unifi_process_receive_event(void *ospriv, u8 *sigdata, u32 siglen, const bulk_data_param_t *bulkdata) { unifi_priv_t *priv = (unifi_priv_t*)ospriv; int i, receiver_id; int client_id; s16 signal_id; u8 pktIndToSme = FALSE, freeBulkData = FALSE; unifi_trace(priv, UDBG5, "unifi_process_receive_event: " "%04x %04x %04x %04x %04x %04x %04x %04x (%d)\n", CSR_GET_UINT16_FROM_LITTLE_ENDIAN((sigdata) + sizeof(s16)*0) & 0xFFFF, CSR_GET_UINT16_FROM_LITTLE_ENDIAN((sigdata) + sizeof(s16)*1) & 0xFFFF, CSR_GET_UINT16_FROM_LITTLE_ENDIAN((sigdata) + sizeof(s16)*2) & 0xFFFF, CSR_GET_UINT16_FROM_LITTLE_ENDIAN((sigdata) + sizeof(s16)*3) & 0xFFFF, CSR_GET_UINT16_FROM_LITTLE_ENDIAN((sigdata) + sizeof(s16)*4) & 0xFFFF, CSR_GET_UINT16_FROM_LITTLE_ENDIAN((sigdata) + sizeof(s16)*5) & 0xFFFF, CSR_GET_UINT16_FROM_LITTLE_ENDIAN((sigdata) + sizeof(s16)*6) & 0xFFFF, CSR_GET_UINT16_FROM_LITTLE_ENDIAN((sigdata) + sizeof(s16)*7) & 0xFFFF, siglen); receiver_id = CSR_GET_UINT16_FROM_LITTLE_ENDIAN((sigdata) + sizeof(s16)) & 0xFF00; client_id = (receiver_id & 0x0F00) >> UDI_SENDER_ID_SHIFT; signal_id = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(sigdata); /* check for the type of frame received (checks for 802.11 management frames) */ if (signal_id == CSR_MA_PACKET_INDICATION_ID) { #define CSR_MA_PACKET_INDICATION_INTERFACETAG_OFFSET 14 u8 interfaceTag; netInterface_priv_t *interfacePriv; /* Pull out interface tag from virtual interface identifier */ interfaceTag = (CSR_GET_UINT16_FROM_LITTLE_ENDIAN(sigdata + CSR_MA_PACKET_INDICATION_INTERFACETAG_OFFSET)) & 0xff; interfacePriv = priv->interfacePriv[interfaceTag]; /* Update activity for this station in case of IBSS */ #ifdef CSR_SUPPORT_SME if (interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_IBSS) { u8 *saddr; /* Fetch the source address from mac header */ saddr = (u8 *) bulkdata->d[0].os_data_ptr + MAC_HEADER_ADDR2_OFFSET; unifi_trace(priv, UDBG5, "Updating sta activity in IBSS interfaceTag %x Src Addr %x:%x:%x:%x:%x:%x\n", interfaceTag, saddr[0], saddr[1], saddr[2], saddr[3], saddr[4], saddr[5]); uf_update_sta_activity(priv, interfaceTag, saddr); } #endif pktIndToSme = check_routing_pkt_data_ind(priv, sigdata, bulkdata, &freeBulkData, interfacePriv); unifi_trace(priv, UDBG6, "RX: packet entry point to driver from HIP,pkt to SME ?(%s) \n", (pktIndToSme)? "YES":"NO"); } if (pktIndToSme) { /* Management MA_PACKET_IND for SME */ if(sigdata != NULL && bulkdata != NULL){ send_to_client(priv, priv->sme_cli, receiver_id, sigdata, siglen, bulkdata); } else{ unifi_error(priv, "unifi_receive_event2: sigdata or Bulkdata is NULL \n"); } #ifdef CSR_NATIVE_LINUX send_to_client(priv, priv->wext_client, receiver_id, sigdata, siglen, bulkdata); #endif } else { /* Signals with ReceiverId==0 are also reported to SME / WEXT, * unless they are data/control MA_PACKET_INDs or VIF_AVAILABILITY_INDs */ if (!receiver_id) { if(signal_id == CSR_MA_VIF_AVAILABILITY_INDICATION_ID) { uf_process_ma_vif_availibility_ind(priv, sigdata, siglen); } else if (signal_id != CSR_MA_PACKET_INDICATION_ID) { send_to_client(priv, priv->sme_cli, receiver_id, sigdata, siglen, bulkdata); #ifdef CSR_NATIVE_LINUX send_to_client(priv, priv->wext_client, receiver_id, sigdata, siglen, bulkdata); #endif } else { #if (defined(CSR_SUPPORT_SME) && defined(CSR_WIFI_SECURITY_WAPI_ENABLE)) #define CSR_MA_PACKET_INDICATION_RECEPTION_STATUS_OFFSET sizeof(CSR_SIGNAL_PRIMITIVE_HEADER) + 22 netInterface_priv_t *interfacePriv; u8 interfaceTag; u16 receptionStatus = CSR_RX_SUCCESS; /* Pull out interface tag from virtual interface identifier */ interfaceTag = (CSR_GET_UINT16_FROM_LITTLE_ENDIAN(sigdata + CSR_MA_PACKET_INDICATION_INTERFACETAG_OFFSET)) & 0xff; interfacePriv = priv->interfacePriv[interfaceTag]; /* check for MIC failure */ receptionStatus = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(sigdata + CSR_MA_PACKET_INDICATION_RECEPTION_STATUS_OFFSET); /* Send a WAPI MPDU to SME for re-check MIC if the respective filter has been set*/ if ((!freeBulkData) && (interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_STA) && (receptionStatus == CSR_MICHAEL_MIC_ERROR) && ((priv->wapi_multicast_filter == 1) #ifdef CSR_WIFI_SECURITY_WAPI_SW_ENCRYPTION || (priv->wapi_unicast_filter == 1) #endif )) { CSR_SIGNAL signal; u8 *destAddr; CsrResult res; u16 interfaceTag = 0; u8 isMcastPkt = TRUE; unifi_trace(priv, UDBG6, "Received a WAPI data packet when the Unicast/Multicast filter is set\n"); res = read_unpack_signal(sigdata, &signal); if (res) { unifi_error(priv, "Received unknown or corrupted signal (0x%x).\n", CSR_GET_UINT16_FROM_LITTLE_ENDIAN(sigdata)); return; } /* Check if the type of MPDU and the respective filter status*/ destAddr = (u8 *) bulkdata->d[0].os_data_ptr + MAC_HEADER_ADDR1_OFFSET; isMcastPkt = (destAddr[0] & 0x01) ? TRUE : FALSE; unifi_trace(priv, UDBG6, "1.MPDU type: (%s), 2.Multicast filter: (%s), 3. Unicast filter: (%s)\n", ((isMcastPkt) ? "Multiast":"Unicast"), ((priv->wapi_multicast_filter) ? "Enabled":"Disabled"), ((priv->wapi_unicast_filter) ? "Enabled":"Disabled")); if (((isMcastPkt) && (priv->wapi_multicast_filter == 1)) #ifdef CSR_WIFI_SECURITY_WAPI_SW_ENCRYPTION || ((!isMcastPkt) && (priv->wapi_unicast_filter == 1)) #endif ) { unifi_trace(priv, UDBG4, "Sending the WAPI MPDU for MIC check\n"); CsrWifiRouterCtrlWapiRxMicCheckIndSend(priv->CSR_WIFI_SME_IFACEQUEUE, 0, interfaceTag, siglen, sigdata, bulkdata->d[0].data_length, (u8*)bulkdata->d[0].os_data_ptr); for (i = 0; i < UNIFI_MAX_DATA_REFERENCES; i++) { if (bulkdata->d[i].data_length != 0) { unifi_net_data_free(priv, (void *)&bulkdata->d[i]); } } return; } } /* CSR_MA_PACKET_INDICATION_ID */ #endif /*CSR_SUPPORT_SME && CSR_WIFI_SECURITY_WAPI_ENABLE*/ } } /* calls the registered clients handler callback func. * netdev_mlme_event_handler is one of the registered handler used to route * data packet to network stack or AMP/EAPOL related data to SME * * The freeBulkData check ensures that, it has received a management frame and * the frame needs to be freed here. So not to be passed to netdev handler */ if(!freeBulkData){ if ((client_id < MAX_UDI_CLIENTS) && (&priv->ul_clients[client_id] != priv->logging_client)) { unifi_trace(priv, UDBG6, "Call the registered clients handler callback func\n"); send_to_client(priv, &priv->ul_clients[client_id], receiver_id, sigdata, siglen, bulkdata); } } } /* * Free bulk data buffers here unless it is a CSR_MA_PACKET_INDICATION */ switch (signal_id) { #ifdef UNIFI_SNIFF_ARPHRD case CSR_MA_SNIFFDATA_INDICATION_ID: #endif break; case CSR_MA_PACKET_INDICATION_ID: if (!freeBulkData) { break; } /* FALLS THROUGH... */ default: for (i = 0; i < UNIFI_MAX_DATA_REFERENCES; i++) { if (bulkdata->d[i].data_length != 0) { unifi_net_data_free(priv, (void *)&bulkdata->d[i]); } } } } /* unifi_process_receive_event() */ #ifdef CSR_WIFI_RX_PATH_SPLIT static u8 signal_buffer_is_full(unifi_priv_t* priv) { return (((priv->rxSignalBuffer.writePointer + 1)% priv->rxSignalBuffer.size) == (priv->rxSignalBuffer.readPointer)); } void unifi_rx_queue_flush(void *ospriv) { unifi_priv_t *priv = (unifi_priv_t*)ospriv; unifi_trace(priv, UDBG4, "rx_wq_handler: RdPtr = %d WritePtr = %d\n", priv->rxSignalBuffer.readPointer,priv->rxSignalBuffer.writePointer); if(priv != NULL) { u8 readPointer = priv->rxSignalBuffer.readPointer; while (readPointer != priv->rxSignalBuffer.writePointer) { rx_buff_struct_t *buf = &priv->rxSignalBuffer.rx_buff[readPointer]; unifi_trace(priv, UDBG6, "rx_wq_handler: RdPtr = %d WritePtr = %d\n", readPointer,priv->rxSignalBuffer.writePointer); unifi_process_receive_event(priv, buf->bufptr, buf->sig_len, &buf->data_ptrs); readPointer ++; if(readPointer >= priv->rxSignalBuffer.size) { readPointer = 0; } } priv->rxSignalBuffer.readPointer = readPointer; } } void rx_wq_handler(struct work_struct *work) { unifi_priv_t *priv = container_of(work, unifi_priv_t, rx_work_struct); unifi_rx_queue_flush(priv); } #endif /* * --------------------------------------------------------------------------- * unifi_receive_event * * Dispatcher for received signals. * * This function receives the 'to host' signals and forwards * them to the unifi linux clients. * * Arguments: * ospriv Pointer to driver's private data. * sigdata Pointer to the packed signal buffer. * siglen Length of the packed signal. * bulkdata Pointer to the signal's bulk data. * * Returns: * None. * * Notes: * The signals are received in the format described in the host interface * specification, i.e wire formatted. Certain clients use the same format * to interpret them and other clients use the host formatted structures. * Each client has to call read_unpack_signal() to transform the wire * formatted signal into the host formatted signal, if necessary. * The code is in the core, since the signals are defined therefore * binded to the host interface specification. * --------------------------------------------------------------------------- */ void unifi_receive_event(void *ospriv, u8 *sigdata, u32 siglen, const bulk_data_param_t *bulkdata) { #ifdef CSR_WIFI_RX_PATH_SPLIT unifi_priv_t *priv = (unifi_priv_t*)ospriv; u8 writePointer; int i; rx_buff_struct_t * rx_buff; unifi_trace(priv, UDBG5, "unifi_receive_event: " "%04x %04x %04x %04x %04x %04x %04x %04x (%d)\n", CSR_GET_UINT16_FROM_LITTLE_ENDIAN((sigdata) + sizeof(s16)*0) & 0xFFFF, CSR_GET_UINT16_FROM_LITTLE_ENDIAN((sigdata) + sizeof(s16)*1) & 0xFFFF, CSR_GET_UINT16_FROM_LITTLE_ENDIAN((sigdata) + sizeof(s16)*2) & 0xFFFF, CSR_GET_UINT16_FROM_LITTLE_ENDIAN((sigdata) + sizeof(s16)*3) & 0xFFFF, CSR_GET_UINT16_FROM_LITTLE_ENDIAN((sigdata) + sizeof(s16)*4) & 0xFFFF, CSR_GET_UINT16_FROM_LITTLE_ENDIAN((sigdata) + sizeof(s16)*5) & 0xFFFF, CSR_GET_UINT16_FROM_LITTLE_ENDIAN((sigdata) + sizeof(s16)*6) & 0xFFFF, CSR_GET_UINT16_FROM_LITTLE_ENDIAN((sigdata) + sizeof(s16)*7) & 0xFFFF, siglen); if(signal_buffer_is_full(priv)) { unifi_error(priv,"TO HOST signal queue FULL dropping the PDU\n"); for (i = 0; i < UNIFI_MAX_DATA_REFERENCES; i++) { if (bulkdata->d[i].data_length != 0) { unifi_net_data_free(priv, (void *)&bulkdata->d[i]); } } return; } writePointer = priv->rxSignalBuffer.writePointer; rx_buff = &priv->rxSignalBuffer.rx_buff[writePointer]; memcpy(rx_buff->bufptr,sigdata,siglen); rx_buff->sig_len = siglen; rx_buff->data_ptrs = *bulkdata; writePointer++; if(writePointer >= priv->rxSignalBuffer.size) { writePointer =0; } unifi_trace(priv, UDBG4, "unifi_receive_event:writePtr = %d\n",priv->rxSignalBuffer.writePointer); priv->rxSignalBuffer.writePointer = writePointer; #ifndef CSR_WIFI_RX_PATH_SPLIT_DONT_USE_WQ queue_work(priv->rx_workqueue, &priv->rx_work_struct); #endif #else unifi_process_receive_event(ospriv, sigdata, siglen, bulkdata); #endif } /* unifi_receive_event() */