| /* |
| * *************************************************************************** |
| * FILE: unifi_sme.c |
| * |
| * PURPOSE: SME related functions. |
| * |
| * Copyright (C) 2007-2009 by Cambridge Silicon Radio Ltd. |
| * |
| * Refer to LICENSE.txt included with this source code for details on |
| * the license terms. |
| * |
| * *************************************************************************** |
| */ |
| |
| #include "unifi_priv.h" |
| #include "csr_wifi_hip_unifi.h" |
| #include "csr_wifi_hip_conversions.h" |
| |
| |
| |
| |
| int |
| convert_sme_error(CsrResult error) |
| { |
| switch (error) { |
| case CSR_RESULT_SUCCESS: |
| return 0; |
| case CSR_RESULT_FAILURE: |
| case CSR_WIFI_RESULT_NOT_FOUND: |
| case CSR_WIFI_RESULT_TIMED_OUT: |
| case CSR_WIFI_RESULT_CANCELLED: |
| case CSR_WIFI_RESULT_UNAVAILABLE: |
| return -EIO; |
| case CSR_WIFI_RESULT_NO_ROOM: |
| return -EBUSY; |
| case CSR_WIFI_RESULT_INVALID_PARAMETER: |
| return -EINVAL; |
| case CSR_WIFI_RESULT_UNSUPPORTED: |
| return -EOPNOTSUPP; |
| default: |
| return -EIO; |
| } |
| } |
| |
| |
| /* |
| * --------------------------------------------------------------------------- |
| * sme_log_event |
| * |
| * Callback function to be registered as the SME event callback. |
| * Copies the signal content into a new udi_log_t struct and adds |
| * it to the read queue for the SME client. |
| * |
| * Arguments: |
| * arg This is the value given to unifi_add_udi_hook, in |
| * this case a pointer to the client instance. |
| * signal Pointer to the received signal. |
| * signal_len Size of the signal structure in bytes. |
| * bulkdata Pointers to any associated bulk data. |
| * dir Direction of the signal. Zero means from host, |
| * non-zero means to host. |
| * |
| * Returns: |
| * None. |
| * --------------------------------------------------------------------------- |
| */ |
| void |
| sme_log_event(ul_client_t *pcli, |
| const u8 *signal, int signal_len, |
| const bulk_data_param_t *bulkdata, |
| int dir) |
| { |
| unifi_priv_t *priv; |
| CSR_SIGNAL unpacked_signal; |
| CsrWifiSmeDataBlock mlmeCommand; |
| CsrWifiSmeDataBlock dataref1; |
| CsrWifiSmeDataBlock dataref2; |
| CsrResult result = CSR_RESULT_SUCCESS; |
| int r; |
| |
| func_enter(); |
| /* Just a sanity check */ |
| if ((signal == NULL) || (signal_len <= 0)) { |
| func_exit(); |
| return; |
| } |
| |
| priv = uf_find_instance(pcli->instance); |
| if (!priv) { |
| unifi_error(priv, "sme_log_event: invalid priv\n"); |
| func_exit(); |
| return; |
| } |
| |
| if (priv->smepriv == NULL) { |
| unifi_error(priv, "sme_log_event: invalid smepriv\n"); |
| func_exit(); |
| return; |
| } |
| |
| unifi_trace(priv, UDBG3, |
| "sme_log_event: Process signal 0x%.4X\n", |
| CSR_GET_UINT16_FROM_LITTLE_ENDIAN(signal)); |
| |
| |
| /* If the signal is known, then do any filtering required, otherwise it pass it to the SME. */ |
| r = read_unpack_signal(signal, &unpacked_signal); |
| if (r == CSR_RESULT_SUCCESS) { |
| if ((unpacked_signal.SignalPrimitiveHeader.SignalId == CSR_DEBUG_STRING_INDICATION_ID) || |
| (unpacked_signal.SignalPrimitiveHeader.SignalId == CSR_DEBUG_WORD16_INDICATION_ID)) |
| { |
| func_exit(); |
| return; |
| } |
| if (unpacked_signal.SignalPrimitiveHeader.SignalId == CSR_MA_PACKET_INDICATION_ID) |
| { |
| u16 frmCtrl; |
| u8 unicastPdu = TRUE; |
| u8 *macHdrLocation; |
| u8 *raddr = NULL, *taddr = NULL; |
| CsrWifiMacAddress peerMacAddress; |
| /* Check if we need to send CsrWifiRouterCtrlMicFailureInd*/ |
| CSR_MA_PACKET_INDICATION *ind = &unpacked_signal.u.MaPacketIndication; |
| |
| macHdrLocation = (u8 *) bulkdata->d[0].os_data_ptr; |
| /* Fetch the frame control value from mac header */ |
| frmCtrl = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(macHdrLocation); |
| |
| /* Point to the addresses */ |
| raddr = macHdrLocation + MAC_HEADER_ADDR1_OFFSET; |
| taddr = macHdrLocation + MAC_HEADER_ADDR2_OFFSET; |
| |
| memcpy(peerMacAddress.a, taddr, ETH_ALEN); |
| |
| if(ind->ReceptionStatus == CSR_MICHAEL_MIC_ERROR) |
| { |
| if (*raddr & 0x1) |
| unicastPdu = FALSE; |
| |
| CsrWifiRouterCtrlMicFailureIndSend (priv->CSR_WIFI_SME_IFACEQUEUE, 0, |
| (ind->VirtualInterfaceIdentifier & 0xff),peerMacAddress, |
| unicastPdu); |
| return; |
| } |
| else |
| { |
| if(ind->ReceptionStatus == CSR_RX_SUCCESS) |
| { |
| u8 pmBit = (frmCtrl & 0x1000)?0x01:0x00; |
| u16 interfaceTag = (ind->VirtualInterfaceIdentifier & 0xff); |
| CsrWifiRouterCtrlStaInfo_t *srcStaInfo = CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(priv,taddr,interfaceTag); |
| if((srcStaInfo != NULL) && (uf_check_broadcast_bssid(priv, bulkdata)== FALSE)) |
| { |
| uf_process_pm_bit_for_peer(priv,srcStaInfo,pmBit,interfaceTag); |
| |
| /* Update station last activity flag */ |
| srcStaInfo->activity_flag = TRUE; |
| } |
| } |
| } |
| } |
| |
| if (unpacked_signal.SignalPrimitiveHeader.SignalId == CSR_MA_PACKET_CONFIRM_ID) |
| { |
| CSR_MA_PACKET_CONFIRM *cfm = &unpacked_signal.u.MaPacketConfirm; |
| u16 interfaceTag = (cfm->VirtualInterfaceIdentifier & 0xff); |
| netInterface_priv_t *interfacePriv; |
| CSR_MA_PACKET_REQUEST *req; |
| CsrWifiMacAddress peerMacAddress; |
| |
| if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) |
| { |
| unifi_error(priv, "Bad MA_PACKET_CONFIRM interfaceTag %d\n", interfaceTag); |
| func_exit(); |
| return; |
| } |
| |
| unifi_trace(priv,UDBG1,"MA-PACKET Confirm (%x, %x)\n", cfm->HostTag, cfm->TransmissionStatus); |
| |
| interfacePriv = priv->interfacePriv[interfaceTag]; |
| #ifdef CSR_SUPPORT_SME |
| if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP || |
| interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) { |
| |
| if(cfm->HostTag == interfacePriv->multicastPduHostTag){ |
| uf_process_ma_pkt_cfm_for_ap(priv ,interfaceTag, cfm); |
| } |
| } |
| #endif |
| |
| req = &interfacePriv->m4_signal.u.MaPacketRequest; |
| |
| if(cfm->HostTag & 0x80000000) |
| { |
| if (cfm->TransmissionStatus != CSR_TX_SUCCESSFUL) |
| { |
| result = CSR_RESULT_FAILURE; |
| } |
| #ifdef CSR_SUPPORT_SME |
| memcpy(peerMacAddress.a, req->Ra.x, ETH_ALEN); |
| /* Check if this is a confirm for EAPOL M4 frame and we need to send transmistted ind*/ |
| if (interfacePriv->m4_sent && (cfm->HostTag == interfacePriv->m4_hostTag)) |
| { |
| unifi_trace(priv, UDBG1, "%s: Sending M4 Transmit CFM\n", __FUNCTION__); |
| CsrWifiRouterCtrlM4TransmittedIndSend(priv->CSR_WIFI_SME_IFACEQUEUE, 0, |
| interfaceTag, |
| peerMacAddress, |
| result); |
| interfacePriv->m4_sent = FALSE; |
| interfacePriv->m4_hostTag = 0xffffffff; |
| } |
| #endif |
| /* If EAPOL was requested via router APIs then send cfm else ignore*/ |
| if((cfm->HostTag & 0x80000000) != CSR_WIFI_EAPOL_M4_HOST_TAG) { |
| CsrWifiRouterMaPacketCfmSend((u16)signal[2], |
| cfm->VirtualInterfaceIdentifier, |
| result, |
| (cfm->HostTag & 0x3fffffff), cfm->Rate); |
| } else { |
| unifi_trace(priv, UDBG1, "%s: M4 received from netdevice\n", __FUNCTION__); |
| } |
| func_exit(); |
| return; |
| } |
| } |
| } |
| |
| mlmeCommand.length = signal_len; |
| mlmeCommand.data = (u8*)signal; |
| |
| dataref1.length = bulkdata->d[0].data_length; |
| if (dataref1.length > 0) { |
| dataref1.data = (u8 *) bulkdata->d[0].os_data_ptr; |
| } else |
| { |
| dataref1.data = NULL; |
| } |
| |
| dataref2.length = bulkdata->d[1].data_length; |
| if (dataref2.length > 0) { |
| dataref2.data = (u8 *) bulkdata->d[1].os_data_ptr; |
| } else |
| { |
| dataref2.data = NULL; |
| } |
| |
| CsrWifiRouterCtrlHipIndSend(priv->CSR_WIFI_SME_IFACEQUEUE, mlmeCommand.length, mlmeCommand.data, |
| dataref1.length, dataref1.data, |
| dataref2.length, dataref2.data); |
| |
| func_exit(); |
| } /* sme_log_event() */ |
| |
| |
| /* |
| * --------------------------------------------------------------------------- |
| * uf_sme_port_state |
| * |
| * Return the state of the controlled port. |
| * |
| * Arguments: |
| * priv Pointer to device private context struct |
| * address Pointer to the destination for tx or sender for rx address |
| * queue Controlled or uncontrolled queue |
| * |
| * Returns: |
| * An unifi_ControlledPortAction value. |
| * --------------------------------------------------------------------------- |
| */ |
| CsrWifiRouterCtrlPortAction |
| uf_sme_port_state(unifi_priv_t *priv, unsigned char *address, int queue, u16 interfaceTag) |
| { |
| int i; |
| unifi_port_config_t *port; |
| netInterface_priv_t *interfacePriv; |
| |
| if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) { |
| unifi_error(priv, "uf_sme_port_state: bad interfaceTag\n"); |
| return CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_CLOSED_DISCARD; |
| } |
| |
| interfacePriv = priv->interfacePriv[interfaceTag]; |
| |
| if (queue == UF_CONTROLLED_PORT_Q) { |
| port = &interfacePriv->controlled_data_port; |
| } else { |
| port = &interfacePriv->uncontrolled_data_port; |
| } |
| |
| if (!port->entries_in_use) { |
| unifi_trace(priv, UDBG5, "No port configurations, return Discard.\n"); |
| return CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_CLOSED_DISCARD; |
| } |
| |
| /* If the port configuration is common for all destinations, return it. */ |
| if (port->overide_action == UF_DATA_PORT_OVERIDE) { |
| unifi_trace(priv, UDBG5, "Single port configuration (%d).\n", |
| port->port_cfg[0].port_action); |
| return port->port_cfg[0].port_action; |
| } |
| |
| unifi_trace(priv, UDBG5, "Multiple (%d) port configurations.\n", port->entries_in_use); |
| |
| /* If multiple configurations exist.. */ |
| for (i = 0; i < UNIFI_MAX_CONNECTIONS; i++) { |
| /* .. go through the list and match the destination address. */ |
| if (port->port_cfg[i].in_use && |
| memcmp(address, port->port_cfg[i].mac_address.a, ETH_ALEN) == 0) { |
| /* Return the desired action. */ |
| return port->port_cfg[i].port_action; |
| } |
| } |
| |
| /* Could not find any information, return Open. */ |
| unifi_trace(priv, UDBG5, "port configuration not found, return Open.\n"); |
| return CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_OPEN; |
| } /* uf_sme_port_state() */ |
| |
| /* |
| * --------------------------------------------------------------------------- |
| * uf_sme_port_config_handle |
| * |
| * Return the port config handle of the controlled/uncontrolled port. |
| * |
| * Arguments: |
| * priv Pointer to device private context struct |
| * address Pointer to the destination for tx or sender for rx address |
| * queue Controlled or uncontrolled queue |
| * |
| * Returns: |
| * An unifi_port_cfg_t* . |
| * --------------------------------------------------------------------------- |
| */ |
| unifi_port_cfg_t* |
| uf_sme_port_config_handle(unifi_priv_t *priv, unsigned char *address, int queue, u16 interfaceTag) |
| { |
| int i; |
| unifi_port_config_t *port; |
| netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag]; |
| |
| if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) { |
| unifi_error(priv, "uf_sme_port_config_handle: bad interfaceTag\n"); |
| return NULL; |
| } |
| |
| if (queue == UF_CONTROLLED_PORT_Q) { |
| port = &interfacePriv->controlled_data_port; |
| } else { |
| port = &interfacePriv->uncontrolled_data_port; |
| } |
| |
| if (!port->entries_in_use) { |
| unifi_trace(priv, UDBG5, "No port configurations, return Discard.\n"); |
| return NULL; |
| } |
| |
| /* If the port configuration is common for all destinations, return it. */ |
| if (port->overide_action == UF_DATA_PORT_OVERIDE) { |
| unifi_trace(priv, UDBG5, "Single port configuration (%d).\n", |
| port->port_cfg[0].port_action); |
| if (address) { |
| unifi_trace(priv, UDBG5, "addr[0] = %x, addr[1] = %x, addr[2] = %x, addr[3] = %x\n", address[0], address[1], address[2], address[3]); |
| } |
| return &port->port_cfg[0]; |
| } |
| |
| unifi_trace(priv, UDBG5, "Multiple port configurations.\n"); |
| |
| /* If multiple configurations exist.. */ |
| for (i = 0; i < UNIFI_MAX_CONNECTIONS; i++) { |
| /* .. go through the list and match the destination address. */ |
| if (port->port_cfg[i].in_use && |
| memcmp(address, port->port_cfg[i].mac_address.a, ETH_ALEN) == 0) { |
| /* Return the desired action. */ |
| return &port->port_cfg[i]; |
| } |
| } |
| |
| /* Could not find any information, return Open. */ |
| unifi_trace(priv, UDBG5, "port configuration not found, returning NULL (debug).\n"); |
| return NULL; |
| } /* uf_sme_port_config_handle */ |
| |
| void |
| uf_multicast_list_wq(struct work_struct *work) |
| { |
| unifi_priv_t *priv = container_of(work, unifi_priv_t, |
| multicast_list_task); |
| int i; |
| u16 interfaceTag = 0; |
| CsrWifiMacAddress* multicast_address_list = NULL; |
| int mc_count; |
| u8 *mc_list; |
| netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag]; |
| |
| if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) { |
| unifi_error(priv, "uf_multicast_list_wq: bad interfaceTag\n"); |
| return; |
| } |
| |
| unifi_trace(priv, UDBG5, |
| "uf_multicast_list_wq: list count = %d\n", |
| interfacePriv->mc_list_count); |
| |
| /* Flush the current list */ |
| CsrWifiRouterCtrlMulticastAddressIndSend(priv->CSR_WIFI_SME_IFACEQUEUE,0, interfaceTag, CSR_WIFI_SME_LIST_ACTION_FLUSH, 0, NULL); |
| |
| mc_count = interfacePriv->mc_list_count; |
| mc_list = interfacePriv->mc_list; |
| /* |
| * Allocate a new list, need to free it later |
| * in unifi_mgt_multicast_address_cfm(). |
| */ |
| multicast_address_list = kmalloc(mc_count * sizeof(CsrWifiMacAddress), GFP_KERNEL); |
| |
| if (multicast_address_list == NULL) { |
| return; |
| } |
| |
| for (i = 0; i < mc_count; i++) { |
| memcpy(multicast_address_list[i].a, mc_list, ETH_ALEN); |
| mc_list += ETH_ALEN; |
| } |
| |
| if (priv->smepriv == NULL) { |
| kfree(multicast_address_list); |
| return; |
| } |
| |
| CsrWifiRouterCtrlMulticastAddressIndSend(priv->CSR_WIFI_SME_IFACEQUEUE,0, |
| interfaceTag, |
| CSR_WIFI_SME_LIST_ACTION_ADD, |
| mc_count, multicast_address_list); |
| |
| /* The SME will take a copy of the addreses*/ |
| kfree(multicast_address_list); |
| } |
| |
| |
| int unifi_cfg_power(unifi_priv_t *priv, unsigned char *arg) |
| { |
| unifi_cfg_power_t cfg_power; |
| int rc; |
| int wol; |
| |
| if (get_user(cfg_power, (unifi_cfg_power_t*)(((unifi_cfg_command_t*)arg) + 1))) { |
| unifi_error(priv, "UNIFI_CFG: Failed to get the argument\n"); |
| return -EFAULT; |
| } |
| |
| switch (cfg_power) { |
| case UNIFI_CFG_POWER_OFF: |
| priv->wol_suspend = (enable_wol == UNIFI_WOL_OFF) ? FALSE : TRUE; |
| rc = sme_sys_suspend(priv); |
| if (rc) { |
| return rc; |
| } |
| break; |
| case UNIFI_CFG_POWER_ON: |
| wol = priv->wol_suspend; |
| rc = sme_sys_resume(priv); |
| if (rc) { |
| return rc; |
| } |
| if (wol) { |
| /* Kick the BH to ensure pending transfers are handled when |
| * a suspend happened with card powered. |
| */ |
| unifi_send_signal(priv->card, NULL, 0, NULL); |
| } |
| break; |
| default: |
| unifi_error(priv, "WIFI POWER: Unknown value.\n"); |
| return -EINVAL; |
| } |
| |
| return 0; |
| } |
| |
| |
| int unifi_cfg_power_save(unifi_priv_t *priv, unsigned char *arg) |
| { |
| unifi_cfg_powersave_t cfg_power_save; |
| CsrWifiSmePowerConfig powerConfig; |
| int rc; |
| |
| if (get_user(cfg_power_save, (unifi_cfg_powersave_t*)(((unifi_cfg_command_t*)arg) + 1))) { |
| unifi_error(priv, "UNIFI_CFG: Failed to get the argument\n"); |
| return -EFAULT; |
| } |
| |
| /* Get the coex info from the SME */ |
| rc = sme_mgt_power_config_get(priv, &powerConfig); |
| if (rc) { |
| unifi_error(priv, "UNIFI_CFG: Get unifi_PowerConfigValue failed.\n"); |
| return rc; |
| } |
| |
| switch (cfg_power_save) { |
| case UNIFI_CFG_POWERSAVE_NONE: |
| powerConfig.powerSaveLevel = CSR_WIFI_SME_POWER_SAVE_LEVEL_LOW; |
| break; |
| case UNIFI_CFG_POWERSAVE_FAST: |
| powerConfig.powerSaveLevel = CSR_WIFI_SME_POWER_SAVE_LEVEL_MED; |
| break; |
| case UNIFI_CFG_POWERSAVE_FULL: |
| powerConfig.powerSaveLevel = CSR_WIFI_SME_POWER_SAVE_LEVEL_HIGH; |
| break; |
| case UNIFI_CFG_POWERSAVE_AUTO: |
| powerConfig.powerSaveLevel = CSR_WIFI_SME_POWER_SAVE_LEVEL_AUTO; |
| break; |
| default: |
| unifi_error(priv, "POWERSAVE: Unknown value.\n"); |
| return -EINVAL; |
| } |
| |
| rc = sme_mgt_power_config_set(priv, &powerConfig); |
| |
| if (rc) { |
| unifi_error(priv, "UNIFI_CFG: Set unifi_PowerConfigValue failed.\n"); |
| } |
| |
| return rc; |
| } |
| |
| |
| int unifi_cfg_power_supply(unifi_priv_t *priv, unsigned char *arg) |
| { |
| unifi_cfg_powersupply_t cfg_power_supply; |
| CsrWifiSmeHostConfig hostConfig; |
| int rc; |
| |
| if (get_user(cfg_power_supply, (unifi_cfg_powersupply_t*)(((unifi_cfg_command_t*)arg) + 1))) { |
| unifi_error(priv, "UNIFI_CFG: Failed to get the argument\n"); |
| return -EFAULT; |
| } |
| |
| /* Get the coex info from the SME */ |
| rc = sme_mgt_host_config_get(priv, &hostConfig); |
| if (rc) { |
| unifi_error(priv, "UNIFI_CFG: Get unifi_HostConfigValue failed.\n"); |
| return rc; |
| } |
| |
| switch (cfg_power_supply) { |
| case UNIFI_CFG_POWERSUPPLY_MAINS: |
| hostConfig.powerMode = CSR_WIFI_SME_HOST_POWER_MODE_ACTIVE; |
| break; |
| case UNIFI_CFG_POWERSUPPLY_BATTERIES: |
| hostConfig.powerMode = CSR_WIFI_SME_HOST_POWER_MODE_POWER_SAVE; |
| break; |
| default: |
| unifi_error(priv, "POWERSUPPLY: Unknown value.\n"); |
| return -EINVAL; |
| } |
| |
| rc = sme_mgt_host_config_set(priv, &hostConfig); |
| if (rc) { |
| unifi_error(priv, "UNIFI_CFG: Set unifi_HostConfigValue failed.\n"); |
| } |
| |
| return rc; |
| } |
| |
| |
| int unifi_cfg_packet_filters(unifi_priv_t *priv, unsigned char *arg) |
| { |
| unsigned char *tclas_buffer; |
| unsigned int tclas_buffer_length; |
| tclas_t *dhcp_tclas; |
| int rc; |
| |
| /* Free any TCLASs previously allocated */ |
| if (priv->packet_filters.tclas_ies_length) { |
| kfree(priv->filter_tclas_ies); |
| priv->filter_tclas_ies = NULL; |
| } |
| |
| tclas_buffer = ((unsigned char*)arg) + sizeof(unifi_cfg_command_t) + sizeof(unsigned int); |
| if (copy_from_user(&priv->packet_filters, (void*)tclas_buffer, |
| sizeof(uf_cfg_bcast_packet_filter_t))) { |
| unifi_error(priv, "UNIFI_CFG: Failed to get the filter struct\n"); |
| return -EFAULT; |
| } |
| |
| tclas_buffer_length = priv->packet_filters.tclas_ies_length; |
| |
| /* Allocate TCLASs if necessary */ |
| if (priv->packet_filters.dhcp_filter) { |
| priv->packet_filters.tclas_ies_length += sizeof(tclas_t); |
| } |
| if (priv->packet_filters.tclas_ies_length > 0) { |
| priv->filter_tclas_ies = kmalloc(priv->packet_filters.tclas_ies_length, GFP_KERNEL); |
| if (priv->filter_tclas_ies == NULL) { |
| return -ENOMEM; |
| } |
| if (tclas_buffer_length) { |
| tclas_buffer += sizeof(uf_cfg_bcast_packet_filter_t) - sizeof(unsigned char*); |
| if (copy_from_user(priv->filter_tclas_ies, |
| tclas_buffer, |
| tclas_buffer_length)) { |
| unifi_error(priv, "UNIFI_CFG: Failed to get the TCLAS buffer\n"); |
| return -EFAULT; |
| } |
| } |
| } |
| |
| if(priv->packet_filters.dhcp_filter) |
| { |
| /* Append the DHCP tclas IE */ |
| dhcp_tclas = (tclas_t*)(priv->filter_tclas_ies + tclas_buffer_length); |
| memset(dhcp_tclas, 0, sizeof(tclas_t)); |
| dhcp_tclas->element_id = 14; |
| dhcp_tclas->length = sizeof(tcpip_clsfr_t) + 1; |
| dhcp_tclas->user_priority = 0; |
| dhcp_tclas->tcp_ip_cls_fr.cls_fr_type = 1; |
| dhcp_tclas->tcp_ip_cls_fr.version = 4; |
| ((u8*)(&dhcp_tclas->tcp_ip_cls_fr.source_port))[0] = 0x00; |
| ((u8*)(&dhcp_tclas->tcp_ip_cls_fr.source_port))[1] = 0x44; |
| ((u8*)(&dhcp_tclas->tcp_ip_cls_fr.dest_port))[0] = 0x00; |
| ((u8*)(&dhcp_tclas->tcp_ip_cls_fr.dest_port))[1] = 0x43; |
| dhcp_tclas->tcp_ip_cls_fr.protocol = 0x11; |
| dhcp_tclas->tcp_ip_cls_fr.cls_fr_mask = 0x58; //bits: 3,4,6 |
| } |
| |
| rc = sme_mgt_packet_filter_set(priv); |
| |
| return rc; |
| } |
| |
| |
| int unifi_cfg_wmm_qos_info(unifi_priv_t *priv, unsigned char *arg) |
| { |
| u8 wmm_qos_info; |
| int rc = 0; |
| |
| if (get_user(wmm_qos_info, (u8*)(((unifi_cfg_command_t*)arg) + 1))) { |
| unifi_error(priv, "UNIFI_CFG: Failed to get the argument\n"); |
| return -EFAULT; |
| } |
| |
| /* Store the value in the connection info */ |
| priv->connection_config.wmmQosInfo = wmm_qos_info; |
| |
| return rc; |
| } |
| |
| |
| int unifi_cfg_wmm_addts(unifi_priv_t *priv, unsigned char *arg) |
| { |
| u32 addts_tid; |
| u8 addts_ie_length; |
| u8 *addts_ie; |
| u8 *addts_params; |
| CsrWifiSmeDataBlock tspec; |
| CsrWifiSmeDataBlock tclas; |
| int rc; |
| |
| addts_params = (u8*)(((unifi_cfg_command_t*)arg) + 1); |
| if (get_user(addts_tid, (u32*)addts_params)) { |
| unifi_error(priv, "unifi_cfg_wmm_addts: Failed to get the argument\n"); |
| return -EFAULT; |
| } |
| |
| addts_params += sizeof(u32); |
| if (get_user(addts_ie_length, (u8*)addts_params)) { |
| unifi_error(priv, "unifi_cfg_wmm_addts: Failed to get the argument\n"); |
| return -EFAULT; |
| } |
| |
| unifi_trace(priv, UDBG4, "addts: tid = 0x%x ie_length = %d\n", |
| addts_tid, addts_ie_length); |
| |
| addts_ie = kmalloc(addts_ie_length, GFP_KERNEL); |
| if (addts_ie == NULL) { |
| unifi_error(priv, |
| "unifi_cfg_wmm_addts: Failed to malloc %d bytes for addts_ie buffer\n", |
| addts_ie_length); |
| return -ENOMEM; |
| } |
| |
| addts_params += sizeof(u8); |
| rc = copy_from_user(addts_ie, addts_params, addts_ie_length); |
| if (rc) { |
| unifi_error(priv, "unifi_cfg_wmm_addts: Failed to get the addts buffer\n"); |
| kfree(addts_ie); |
| return -EFAULT; |
| } |
| |
| tspec.data = addts_ie; |
| tspec.length = addts_ie_length; |
| tclas.data = NULL; |
| tclas.length = 0; |
| |
| rc = sme_mgt_tspec(priv, CSR_WIFI_SME_LIST_ACTION_ADD, addts_tid, |
| &tspec, &tclas); |
| |
| kfree(addts_ie); |
| return rc; |
| } |
| |
| |
| int unifi_cfg_wmm_delts(unifi_priv_t *priv, unsigned char *arg) |
| { |
| u32 delts_tid; |
| u8 *delts_params; |
| CsrWifiSmeDataBlock tspec; |
| CsrWifiSmeDataBlock tclas; |
| int rc; |
| |
| delts_params = (u8*)(((unifi_cfg_command_t*)arg) + 1); |
| if (get_user(delts_tid, (u32*)delts_params)) { |
| unifi_error(priv, "unifi_cfg_wmm_delts: Failed to get the argument\n"); |
| return -EFAULT; |
| } |
| |
| unifi_trace(priv, UDBG4, "delts: tid = 0x%x\n", delts_tid); |
| |
| tspec.data = tclas.data = NULL; |
| tspec.length = tclas.length = 0; |
| |
| rc = sme_mgt_tspec(priv, CSR_WIFI_SME_LIST_ACTION_REMOVE, delts_tid, |
| &tspec, &tclas); |
| |
| return rc; |
| } |
| |
| int unifi_cfg_strict_draft_n(unifi_priv_t *priv, unsigned char *arg) |
| { |
| u8 strict_draft_n; |
| u8 *strict_draft_n_params; |
| int rc; |
| |
| CsrWifiSmeStaConfig staConfig; |
| CsrWifiSmeDeviceConfig deviceConfig; |
| |
| strict_draft_n_params = (u8*)(((unifi_cfg_command_t*)arg) + 1); |
| if (get_user(strict_draft_n, (u8*)strict_draft_n_params)) { |
| unifi_error(priv, "unifi_cfg_strict_draft_n: Failed to get the argument\n"); |
| return -EFAULT; |
| } |
| |
| unifi_trace(priv, UDBG4, "strict_draft_n: = %s\n", ((strict_draft_n) ? "yes":"no")); |
| |
| rc = sme_mgt_sme_config_get(priv, &staConfig, &deviceConfig); |
| |
| if (rc) { |
| unifi_warning(priv, "unifi_cfg_strict_draft_n: Get unifi_SMEConfigValue failed.\n"); |
| return -EFAULT; |
| } |
| |
| deviceConfig.enableStrictDraftN = strict_draft_n; |
| |
| rc = sme_mgt_sme_config_set(priv, &staConfig, &deviceConfig); |
| if (rc) { |
| unifi_warning(priv, "unifi_cfg_strict_draft_n: Set unifi_SMEConfigValue failed.\n"); |
| rc = -EFAULT; |
| } |
| |
| return rc; |
| } |
| |
| |
| int unifi_cfg_enable_okc(unifi_priv_t *priv, unsigned char *arg) |
| { |
| u8 enable_okc; |
| u8 *enable_okc_params; |
| int rc; |
| |
| CsrWifiSmeStaConfig staConfig; |
| CsrWifiSmeDeviceConfig deviceConfig; |
| |
| enable_okc_params = (u8*)(((unifi_cfg_command_t*)arg) + 1); |
| if (get_user(enable_okc, (u8*)enable_okc_params)) { |
| unifi_error(priv, "unifi_cfg_enable_okc: Failed to get the argument\n"); |
| return -EFAULT; |
| } |
| |
| unifi_trace(priv, UDBG4, "enable_okc: = %s\n", ((enable_okc) ? "yes":"no")); |
| |
| rc = sme_mgt_sme_config_get(priv, &staConfig, &deviceConfig); |
| if (rc) { |
| unifi_warning(priv, "unifi_cfg_enable_okc: Get unifi_SMEConfigValue failed.\n"); |
| return -EFAULT; |
| } |
| |
| staConfig.enableOpportunisticKeyCaching = enable_okc; |
| |
| rc = sme_mgt_sme_config_set(priv, &staConfig, &deviceConfig); |
| if (rc) { |
| unifi_warning(priv, "unifi_cfg_enable_okc: Set unifi_SMEConfigValue failed.\n"); |
| rc = -EFAULT; |
| } |
| |
| return rc; |
| } |
| |
| |
| int unifi_cfg_get_info(unifi_priv_t *priv, unsigned char *arg) |
| { |
| unifi_cfg_get_t get_cmd; |
| char inst_name[IFNAMSIZ]; |
| int rc; |
| |
| if (get_user(get_cmd, (unifi_cfg_get_t*)(((unifi_cfg_command_t*)arg) + 1))) { |
| unifi_error(priv, "UNIFI_CFG: Failed to get the argument\n"); |
| return -EFAULT; |
| } |
| |
| switch (get_cmd) { |
| case UNIFI_CFG_GET_COEX: |
| { |
| CsrWifiSmeCoexInfo coexInfo; |
| /* Get the coex info from the SME */ |
| rc = sme_mgt_coex_info_get(priv, &coexInfo); |
| if (rc) { |
| unifi_error(priv, "UNIFI_CFG: Get unifi_CoexInfoValue failed.\n"); |
| return rc; |
| } |
| |
| /* Copy the info to the out buffer */ |
| if (copy_to_user((void*)arg, |
| &coexInfo, |
| sizeof(CsrWifiSmeCoexInfo))) { |
| unifi_error(priv, "UNIFI_CFG: Failed to copy the coex info\n"); |
| return -EFAULT; |
| } |
| break; |
| } |
| case UNIFI_CFG_GET_POWER_MODE: |
| { |
| CsrWifiSmePowerConfig powerConfig; |
| rc = sme_mgt_power_config_get(priv, &powerConfig); |
| if (rc) { |
| unifi_error(priv, "UNIFI_CFG: Get unifi_PowerConfigValue failed.\n"); |
| return rc; |
| } |
| |
| /* Copy the info to the out buffer */ |
| if (copy_to_user((void*)arg, |
| &powerConfig.powerSaveLevel, |
| sizeof(CsrWifiSmePowerSaveLevel))) { |
| unifi_error(priv, "UNIFI_CFG: Failed to copy the power save info\n"); |
| return -EFAULT; |
| } |
| break; |
| } |
| case UNIFI_CFG_GET_POWER_SUPPLY: |
| { |
| CsrWifiSmeHostConfig hostConfig; |
| rc = sme_mgt_host_config_get(priv, &hostConfig); |
| if (rc) { |
| unifi_error(priv, "UNIFI_CFG: Get unifi_HostConfigValue failed.\n"); |
| return rc; |
| } |
| |
| /* Copy the info to the out buffer */ |
| if (copy_to_user((void*)arg, |
| &hostConfig.powerMode, |
| sizeof(CsrWifiSmeHostPowerMode))) { |
| unifi_error(priv, "UNIFI_CFG: Failed to copy the host power mode\n"); |
| return -EFAULT; |
| } |
| break; |
| } |
| case UNIFI_CFG_GET_VERSIONS: |
| break; |
| case UNIFI_CFG_GET_INSTANCE: |
| { |
| u16 InterfaceId=0; |
| uf_net_get_name(priv->netdev[InterfaceId], &inst_name[0], sizeof(inst_name)); |
| |
| /* Copy the info to the out buffer */ |
| if (copy_to_user((void*)arg, |
| &inst_name[0], |
| sizeof(inst_name))) { |
| unifi_error(priv, "UNIFI_CFG: Failed to copy the instance name\n"); |
| return -EFAULT; |
| } |
| } |
| break; |
| |
| case UNIFI_CFG_GET_AP_CONFIG: |
| { |
| #ifdef CSR_SUPPORT_WEXT_AP |
| uf_cfg_ap_config_t cfg_ap_config; |
| cfg_ap_config.channel = priv->ap_config.channel; |
| cfg_ap_config.beaconInterval = priv->ap_mac_config.beaconInterval; |
| cfg_ap_config.wmmEnabled = priv->ap_mac_config.wmmEnabled; |
| cfg_ap_config.dtimPeriod = priv->ap_mac_config.dtimPeriod; |
| cfg_ap_config.phySupportedBitmap = priv->ap_mac_config.phySupportedBitmap; |
| if (copy_to_user((void*)arg, |
| &cfg_ap_config, |
| sizeof(uf_cfg_ap_config_t))) { |
| unifi_error(priv, "UNIFI_CFG: Failed to copy the AP configuration\n"); |
| return -EFAULT; |
| } |
| #else |
| return -EPERM; |
| #endif |
| } |
| break; |
| |
| |
| default: |
| unifi_error(priv, "unifi_cfg_get_info: Unknown value.\n"); |
| return -EINVAL; |
| } |
| |
| return 0; |
| } |
| #ifdef CSR_SUPPORT_WEXT_AP |
| int |
| uf_configure_supported_rates(u8 * supportedRates, u8 phySupportedBitmap) |
| { |
| int i=0; |
| u8 b=FALSE, g = FALSE, n = FALSE; |
| b = phySupportedBitmap & CSR_WIFI_SME_AP_PHY_SUPPORT_B; |
| n = phySupportedBitmap & CSR_WIFI_SME_AP_PHY_SUPPORT_N; |
| g = phySupportedBitmap & CSR_WIFI_SME_AP_PHY_SUPPORT_G; |
| if(b || g) { |
| supportedRates[i++]=0x82; |
| supportedRates[i++]=0x84; |
| supportedRates[i++]=0x8b; |
| supportedRates[i++]=0x96; |
| } else if(n) { |
| /* For some strange reasons WiFi stack needs both b and g rates*/ |
| supportedRates[i++]=0x02; |
| supportedRates[i++]=0x04; |
| supportedRates[i++]=0x0b; |
| supportedRates[i++]=0x16; |
| supportedRates[i++]=0x0c; |
| supportedRates[i++]=0x12; |
| supportedRates[i++]=0x18; |
| supportedRates[i++]=0x24; |
| supportedRates[i++]=0x30; |
| supportedRates[i++]=0x48; |
| supportedRates[i++]=0x60; |
| supportedRates[i++]=0x6c; |
| } |
| if(g) { |
| if(!b) { |
| supportedRates[i++]=0x8c; |
| supportedRates[i++]=0x98; |
| supportedRates[i++]=0xb0; |
| } else { |
| supportedRates[i++]=0x0c; |
| supportedRates[i++]=0x18; |
| supportedRates[i++]=0x30; |
| } |
| supportedRates[i++]=0x48; |
| supportedRates[i++]=0x12; |
| supportedRates[i++]=0x24; |
| supportedRates[i++]=0x60; |
| supportedRates[i++]=0x6c; |
| } |
| return i; |
| } |
| int unifi_cfg_set_ap_config(unifi_priv_t * priv,unsigned char* arg) |
| { |
| uf_cfg_ap_config_t cfg_ap_config; |
| char *buffer; |
| |
| buffer = ((unsigned char*)arg) + sizeof(unifi_cfg_command_t) + sizeof(unsigned int); |
| if (copy_from_user(&cfg_ap_config, (void*)buffer, |
| sizeof(uf_cfg_ap_config_t))) { |
| unifi_error(priv, "UNIFI_CFG: Failed to get the ap config struct\n"); |
| return -EFAULT; |
| } |
| priv->ap_config.channel = cfg_ap_config.channel; |
| priv->ap_mac_config.dtimPeriod = cfg_ap_config.dtimPeriod; |
| priv->ap_mac_config.beaconInterval = cfg_ap_config.beaconInterval; |
| priv->group_sec_config.apGroupkeyTimeout = cfg_ap_config.groupkeyTimeout; |
| priv->group_sec_config.apStrictGtkRekey = cfg_ap_config.strictGtkRekeyEnabled; |
| priv->group_sec_config.apGmkTimeout = cfg_ap_config.gmkTimeout; |
| priv->group_sec_config.apResponseTimeout = cfg_ap_config.responseTimeout; |
| priv->group_sec_config.apRetransLimit = cfg_ap_config.retransLimit; |
| |
| priv->ap_mac_config.shortSlotTimeEnabled = cfg_ap_config.shortSlotTimeEnabled; |
| priv->ap_mac_config.ctsProtectionType=cfg_ap_config.ctsProtectionType; |
| |
| priv->ap_mac_config.wmmEnabled = cfg_ap_config.wmmEnabled; |
| |
| priv->ap_mac_config.apHtParams.rxStbc=cfg_ap_config.rxStbc; |
| priv->ap_mac_config.apHtParams.rifsModeAllowed=cfg_ap_config.rifsModeAllowed; |
| |
| priv->ap_mac_config.phySupportedBitmap = cfg_ap_config.phySupportedBitmap; |
| priv->ap_mac_config.maxListenInterval=cfg_ap_config.maxListenInterval; |
| |
| priv->ap_mac_config.supportedRatesCount= uf_configure_supported_rates(priv->ap_mac_config.supportedRates,priv->ap_mac_config.phySupportedBitmap); |
| |
| return 0; |
| } |
| |
| #endif |
| #ifdef CSR_SUPPORT_WEXT |
| |
| void |
| uf_sme_config_wq(struct work_struct *work) |
| { |
| CsrWifiSmeStaConfig staConfig; |
| CsrWifiSmeDeviceConfig deviceConfig; |
| unifi_priv_t *priv = container_of(work, unifi_priv_t, sme_config_task); |
| |
| /* Register to receive indications from the SME */ |
| CsrWifiSmeEventMaskSetReqSend(0, |
| CSR_WIFI_SME_INDICATIONS_WIFIOFF | CSR_WIFI_SME_INDICATIONS_CONNECTIONQUALITY | |
| CSR_WIFI_SME_INDICATIONS_MEDIASTATUS | CSR_WIFI_SME_INDICATIONS_MICFAILURE); |
| |
| if (sme_mgt_sme_config_get(priv, &staConfig, &deviceConfig)) { |
| unifi_warning(priv, "uf_sme_config_wq: Get unifi_SMEConfigValue failed.\n"); |
| return; |
| } |
| |
| if (priv->if_index == CSR_INDEX_5G) { |
| staConfig.ifIndex = CSR_WIFI_SME_RADIO_IF_GHZ_5_0; |
| } else { |
| staConfig.ifIndex = CSR_WIFI_SME_RADIO_IF_GHZ_2_4; |
| } |
| |
| deviceConfig.trustLevel = (CsrWifiSme80211dTrustLevel)tl_80211d; |
| if (sme_mgt_sme_config_set(priv, &staConfig, &deviceConfig)) { |
| unifi_warning(priv, |
| "SME config for 802.11d Trust Level and Radio Band failed.\n"); |
| return; |
| } |
| |
| } /* uf_sme_config_wq() */ |
| |
| #endif /* CSR_SUPPORT_WEXT */ |
| |
| |
| /* |
| * --------------------------------------------------------------------------- |
| * uf_ta_ind_wq |
| * |
| * Deferred work queue function to send Traffic Analysis protocols |
| * indications to the SME. |
| * These are done in a deferred work queue for two reasons: |
| * - the CsrWifiRouterCtrl...Send() functions are not safe for atomic context |
| * - we want to load the main driver data path as lightly as possible |
| * |
| * The TA classifications already come from a workqueue. |
| * |
| * Arguments: |
| * work Pointer to work queue item. |
| * |
| * Returns: |
| * None. |
| * --------------------------------------------------------------------------- |
| */ |
| void |
| uf_ta_ind_wq(struct work_struct *work) |
| { |
| struct ta_ind *ind = container_of(work, struct ta_ind, task); |
| unifi_priv_t *priv = container_of(ind, unifi_priv_t, ta_ind_work); |
| u16 interfaceTag = 0; |
| |
| |
| CsrWifiRouterCtrlTrafficProtocolIndSend(priv->CSR_WIFI_SME_IFACEQUEUE,0, |
| interfaceTag, |
| ind->packet_type, |
| ind->direction, |
| ind->src_addr); |
| ind->in_use = 0; |
| |
| } /* uf_ta_ind_wq() */ |
| |
| |
| /* |
| * --------------------------------------------------------------------------- |
| * uf_ta_sample_ind_wq |
| * |
| * Deferred work queue function to send Traffic Analysis sample |
| * indications to the SME. |
| * These are done in a deferred work queue for two reasons: |
| * - the CsrWifiRouterCtrl...Send() functions are not safe for atomic context |
| * - we want to load the main driver data path as lightly as possible |
| * |
| * The TA classifications already come from a workqueue. |
| * |
| * Arguments: |
| * work Pointer to work queue item. |
| * |
| * Returns: |
| * None. |
| * --------------------------------------------------------------------------- |
| */ |
| void |
| uf_ta_sample_ind_wq(struct work_struct *work) |
| { |
| struct ta_sample_ind *ind = container_of(work, struct ta_sample_ind, task); |
| unifi_priv_t *priv = container_of(ind, unifi_priv_t, ta_sample_ind_work); |
| u16 interfaceTag = 0; |
| |
| unifi_trace(priv, UDBG5, "rxtcp %d txtcp %d rxudp %d txudp %d prio %d\n", |
| priv->rxTcpThroughput, |
| priv->txTcpThroughput, |
| priv->rxUdpThroughput, |
| priv->txUdpThroughput, |
| priv->bh_thread.prio); |
| |
| if(priv->rxTcpThroughput > 1000) |
| { |
| if (bh_priority == -1 && priv->bh_thread.prio != 1) |
| { |
| struct sched_param param; |
| priv->bh_thread.prio = 1; |
| unifi_trace(priv, UDBG1, "%s new thread (RT) priority = %d\n", |
| priv->bh_thread.name, priv->bh_thread.prio); |
| param.sched_priority = priv->bh_thread.prio; |
| sched_setscheduler(priv->bh_thread.thread_task, SCHED_FIFO, ¶m); |
| } |
| } else |
| { |
| if (bh_priority == -1 && priv->bh_thread.prio != DEFAULT_PRIO) |
| { |
| struct sched_param param; |
| param.sched_priority = 0; |
| sched_setscheduler(priv->bh_thread.thread_task, SCHED_NORMAL, ¶m); |
| priv->bh_thread.prio = DEFAULT_PRIO; |
| unifi_trace(priv, UDBG1, "%s new thread priority = %d\n", |
| priv->bh_thread.name, priv->bh_thread.prio); |
| set_user_nice(priv->bh_thread.thread_task, PRIO_TO_NICE(priv->bh_thread.prio)); |
| } |
| } |
| |
| CsrWifiRouterCtrlTrafficSampleIndSend(priv->CSR_WIFI_SME_IFACEQUEUE,0, interfaceTag, ind->stats); |
| |
| ind->in_use = 0; |
| |
| } /* uf_ta_sample_ind_wq() */ |
| |
| |
| /* |
| * --------------------------------------------------------------------------- |
| * uf_send_m4_ready_wq |
| * |
| * Deferred work queue function to send M4 ReadyToSend inds to the SME. |
| * These are done in a deferred work queue for two reasons: |
| * - the CsrWifiRouterCtrl...Send() functions are not safe for atomic context |
| * - we want to load the main driver data path as lightly as possible |
| * |
| * Arguments: |
| * work Pointer to work queue item. |
| * |
| * Returns: |
| * None. |
| * --------------------------------------------------------------------------- |
| */ |
| void |
| uf_send_m4_ready_wq(struct work_struct *work) |
| { |
| netInterface_priv_t *InterfacePriv = container_of(work, netInterface_priv_t, send_m4_ready_task); |
| u16 iface = InterfacePriv->InterfaceTag; |
| unifi_priv_t *priv = InterfacePriv->privPtr; |
| CSR_MA_PACKET_REQUEST *req = &InterfacePriv->m4_signal.u.MaPacketRequest; |
| CsrWifiMacAddress peer; |
| unsigned long flags; |
| |
| func_enter(); |
| |
| /* The peer address was stored in the signal */ |
| spin_lock_irqsave(&priv->m4_lock, flags); |
| memcpy(peer.a, req->Ra.x, sizeof(peer.a)); |
| spin_unlock_irqrestore(&priv->m4_lock, flags); |
| |
| /* Send a signal to SME */ |
| CsrWifiRouterCtrlM4ReadyToSendIndSend(priv->CSR_WIFI_SME_IFACEQUEUE, 0, iface, peer); |
| |
| unifi_trace(priv, UDBG1, "M4ReadyToSendInd sent for peer %pMF\n", |
| peer.a); |
| |
| func_exit(); |
| |
| } /* uf_send_m4_ready_wq() */ |
| |
| #if (defined(CSR_WIFI_SECURITY_WAPI_ENABLE) && defined(CSR_WIFI_SECURITY_WAPI_SW_ENCRYPTION)) |
| /* |
| * --------------------------------------------------------------------------- |
| * uf_send_pkt_to_encrypt |
| * |
| * Deferred work queue function to send the WAPI data pkts to SME when unicast KeyId = 1 |
| * These are done in a deferred work queue for two reasons: |
| * - the CsrWifiRouterCtrl...Send() functions are not safe for atomic context |
| * - we want to load the main driver data path as lightly as possible |
| * |
| * Arguments: |
| * work Pointer to work queue item. |
| * |
| * Returns: |
| * None. |
| * --------------------------------------------------------------------------- |
| */ |
| void uf_send_pkt_to_encrypt(struct work_struct *work) |
| { |
| netInterface_priv_t *interfacePriv = container_of(work, netInterface_priv_t, send_pkt_to_encrypt); |
| u16 interfaceTag = interfacePriv->InterfaceTag; |
| unifi_priv_t *priv = interfacePriv->privPtr; |
| |
| u32 pktBulkDataLength; |
| u8 *pktBulkData; |
| unsigned long flags; |
| |
| if (interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_STA) { |
| |
| func_enter(); |
| |
| pktBulkDataLength = interfacePriv->wapi_unicast_bulk_data.data_length; |
| |
| if (pktBulkDataLength > 0) { |
| pktBulkData = kmalloc(pktBulkDataLength, GFP_KERNEL); |
| memset(pktBulkData, 0, pktBulkDataLength); |
| } else { |
| unifi_error(priv, "uf_send_pkt_to_encrypt() : invalid buffer\n"); |
| return; |
| } |
| |
| spin_lock_irqsave(&priv->wapi_lock, flags); |
| /* Copy over the MA PKT REQ bulk data */ |
| memcpy(pktBulkData, (u8*)interfacePriv->wapi_unicast_bulk_data.os_data_ptr, pktBulkDataLength); |
| /* Free any bulk data buffers allocated for the WAPI Data pkt */ |
| unifi_net_data_free(priv, &interfacePriv->wapi_unicast_bulk_data); |
| interfacePriv->wapi_unicast_bulk_data.net_buf_length = 0; |
| interfacePriv->wapi_unicast_bulk_data.data_length = 0; |
| interfacePriv->wapi_unicast_bulk_data.os_data_ptr = interfacePriv->wapi_unicast_bulk_data.os_net_buf_ptr = NULL; |
| spin_unlock_irqrestore(&priv->wapi_lock, flags); |
| |
| CsrWifiRouterCtrlWapiUnicastTxEncryptIndSend(priv->CSR_WIFI_SME_IFACEQUEUE, 0, interfaceTag, pktBulkDataLength, pktBulkData); |
| unifi_trace(priv, UDBG1, "WapiUnicastTxEncryptInd sent to SME\n"); |
| |
| kfree(pktBulkData); /* Would have been copied over by the SME Handler */ |
| |
| func_exit(); |
| } else { |
| unifi_warning(priv, "uf_send_pkt_to_encrypt() is NOT applicable for interface mode - %d\n",interfacePriv->interfaceMode); |
| } |
| }/* uf_send_pkt_to_encrypt() */ |
| #endif |
