/* * *************************************************************************** * 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" #include 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; /* Just a sanity check */ if ((signal == NULL) || (signal_len <= 0)) { return; } priv = uf_find_instance(pcli->instance); if (!priv) { unifi_error(priv, "sme_log_event: invalid priv\n"); return; } if (priv->smepriv == NULL) { unifi_error(priv, "sme_log_event: invalid smepriv\n"); 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)) { 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); 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__); } 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); } /* 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; memset(&cfg_ap_config, 0, sizeof(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; /* 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); } /* 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) { pktBulkDataLength = interfacePriv->wapi_unicast_bulk_data.data_length; if (pktBulkDataLength > 0) { pktBulkData = kmalloc(pktBulkDataLength, GFP_KERNEL); } 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 */ } 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