forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1855 lines
46 KiB
1855 lines
46 KiB
/* SPDX-License-Identifier: GPL-2.0-only */ |
|
/* |
|
* WSM host interface (HI) interface for ST-Ericsson CW1200 mac80211 drivers |
|
* |
|
* Copyright (c) 2010, ST-Ericsson |
|
* Author: Dmitry Tarnyagin <[email protected]> |
|
* |
|
* Based on CW1200 UMAC WSM API, which is |
|
* Copyright (C) ST-Ericsson SA 2010 |
|
* Author: Stewart Mathers <[email protected]> |
|
*/ |
|
|
|
#ifndef CW1200_WSM_H_INCLUDED |
|
#define CW1200_WSM_H_INCLUDED |
|
|
|
#include <linux/spinlock.h> |
|
|
|
struct cw1200_common; |
|
|
|
/* Bands */ |
|
/* Radio band 2.412 -2.484 GHz. */ |
|
#define WSM_PHY_BAND_2_4G (0) |
|
|
|
/* Radio band 4.9375-5.8250 GHz. */ |
|
#define WSM_PHY_BAND_5G (1) |
|
|
|
/* Transmit rates */ |
|
/* 1 Mbps ERP-DSSS */ |
|
#define WSM_TRANSMIT_RATE_1 (0) |
|
|
|
/* 2 Mbps ERP-DSSS */ |
|
#define WSM_TRANSMIT_RATE_2 (1) |
|
|
|
/* 5.5 Mbps ERP-CCK */ |
|
#define WSM_TRANSMIT_RATE_5 (2) |
|
|
|
/* 11 Mbps ERP-CCK */ |
|
#define WSM_TRANSMIT_RATE_11 (3) |
|
|
|
/* 22 Mbps ERP-PBCC (Not supported) */ |
|
/* #define WSM_TRANSMIT_RATE_22 (4) */ |
|
|
|
/* 33 Mbps ERP-PBCC (Not supported) */ |
|
/* #define WSM_TRANSMIT_RATE_33 (5) */ |
|
|
|
/* 6 Mbps (3 Mbps) ERP-OFDM, BPSK coding rate 1/2 */ |
|
#define WSM_TRANSMIT_RATE_6 (6) |
|
|
|
/* 9 Mbps (4.5 Mbps) ERP-OFDM, BPSK coding rate 3/4 */ |
|
#define WSM_TRANSMIT_RATE_9 (7) |
|
|
|
/* 12 Mbps (6 Mbps) ERP-OFDM, QPSK coding rate 1/2 */ |
|
#define WSM_TRANSMIT_RATE_12 (8) |
|
|
|
/* 18 Mbps (9 Mbps) ERP-OFDM, QPSK coding rate 3/4 */ |
|
#define WSM_TRANSMIT_RATE_18 (9) |
|
|
|
/* 24 Mbps (12 Mbps) ERP-OFDM, 16QAM coding rate 1/2 */ |
|
#define WSM_TRANSMIT_RATE_24 (10) |
|
|
|
/* 36 Mbps (18 Mbps) ERP-OFDM, 16QAM coding rate 3/4 */ |
|
#define WSM_TRANSMIT_RATE_36 (11) |
|
|
|
/* 48 Mbps (24 Mbps) ERP-OFDM, 64QAM coding rate 1/2 */ |
|
#define WSM_TRANSMIT_RATE_48 (12) |
|
|
|
/* 54 Mbps (27 Mbps) ERP-OFDM, 64QAM coding rate 3/4 */ |
|
#define WSM_TRANSMIT_RATE_54 (13) |
|
|
|
/* 6.5 Mbps HT-OFDM, BPSK coding rate 1/2 */ |
|
#define WSM_TRANSMIT_RATE_HT_6 (14) |
|
|
|
/* 13 Mbps HT-OFDM, QPSK coding rate 1/2 */ |
|
#define WSM_TRANSMIT_RATE_HT_13 (15) |
|
|
|
/* 19.5 Mbps HT-OFDM, QPSK coding rate 3/4 */ |
|
#define WSM_TRANSMIT_RATE_HT_19 (16) |
|
|
|
/* 26 Mbps HT-OFDM, 16QAM coding rate 1/2 */ |
|
#define WSM_TRANSMIT_RATE_HT_26 (17) |
|
|
|
/* 39 Mbps HT-OFDM, 16QAM coding rate 3/4 */ |
|
#define WSM_TRANSMIT_RATE_HT_39 (18) |
|
|
|
/* 52 Mbps HT-OFDM, 64QAM coding rate 2/3 */ |
|
#define WSM_TRANSMIT_RATE_HT_52 (19) |
|
|
|
/* 58.5 Mbps HT-OFDM, 64QAM coding rate 3/4 */ |
|
#define WSM_TRANSMIT_RATE_HT_58 (20) |
|
|
|
/* 65 Mbps HT-OFDM, 64QAM coding rate 5/6 */ |
|
#define WSM_TRANSMIT_RATE_HT_65 (21) |
|
|
|
/* Scan types */ |
|
/* Foreground scan */ |
|
#define WSM_SCAN_TYPE_FOREGROUND (0) |
|
|
|
/* Background scan */ |
|
#define WSM_SCAN_TYPE_BACKGROUND (1) |
|
|
|
/* Auto scan */ |
|
#define WSM_SCAN_TYPE_AUTO (2) |
|
|
|
/* Scan flags */ |
|
/* Forced background scan means if the station cannot */ |
|
/* enter the power-save mode, it shall force to perform a */ |
|
/* background scan. Only valid when ScanType is */ |
|
/* background scan. */ |
|
#define WSM_SCAN_FLAG_FORCE_BACKGROUND (BIT(0)) |
|
|
|
/* The WLAN device scans one channel at a time so */ |
|
/* that disturbance to the data traffic is minimized. */ |
|
#define WSM_SCAN_FLAG_SPLIT_METHOD (BIT(1)) |
|
|
|
/* Preamble Type. Long if not set. */ |
|
#define WSM_SCAN_FLAG_SHORT_PREAMBLE (BIT(2)) |
|
|
|
/* 11n Tx Mode. Mixed if not set. */ |
|
#define WSM_SCAN_FLAG_11N_GREENFIELD (BIT(3)) |
|
|
|
/* Scan constraints */ |
|
/* Maximum number of channels to be scanned. */ |
|
#define WSM_SCAN_MAX_NUM_OF_CHANNELS (48) |
|
|
|
/* The maximum number of SSIDs that the device can scan for. */ |
|
#define WSM_SCAN_MAX_NUM_OF_SSIDS (2) |
|
|
|
/* Power management modes */ |
|
/* 802.11 Active mode */ |
|
#define WSM_PSM_ACTIVE (0) |
|
|
|
/* 802.11 PS mode */ |
|
#define WSM_PSM_PS BIT(0) |
|
|
|
/* Fast Power Save bit */ |
|
#define WSM_PSM_FAST_PS_FLAG BIT(7) |
|
|
|
/* Dynamic aka Fast power save */ |
|
#define WSM_PSM_FAST_PS (BIT(0) | BIT(7)) |
|
|
|
/* Undetermined */ |
|
/* Note : Undetermined status is reported when the */ |
|
/* NULL data frame used to advertise the PM mode to */ |
|
/* the AP at Pre or Post Background Scan is not Acknowledged */ |
|
#define WSM_PSM_UNKNOWN BIT(1) |
|
|
|
/* Queue IDs */ |
|
/* best effort/legacy */ |
|
#define WSM_QUEUE_BEST_EFFORT (0) |
|
|
|
/* background */ |
|
#define WSM_QUEUE_BACKGROUND (1) |
|
|
|
/* video */ |
|
#define WSM_QUEUE_VIDEO (2) |
|
|
|
/* voice */ |
|
#define WSM_QUEUE_VOICE (3) |
|
|
|
/* HT TX parameters */ |
|
/* Non-HT */ |
|
#define WSM_HT_TX_NON_HT (0) |
|
|
|
/* Mixed format */ |
|
#define WSM_HT_TX_MIXED (1) |
|
|
|
/* Greenfield format */ |
|
#define WSM_HT_TX_GREENFIELD (2) |
|
|
|
/* STBC allowed */ |
|
#define WSM_HT_TX_STBC (BIT(7)) |
|
|
|
/* EPTA prioirty flags for BT Coex */ |
|
/* default epta priority */ |
|
#define WSM_EPTA_PRIORITY_DEFAULT 4 |
|
/* use for normal data */ |
|
#define WSM_EPTA_PRIORITY_DATA 4 |
|
/* use for connect/disconnect/roaming*/ |
|
#define WSM_EPTA_PRIORITY_MGT 5 |
|
/* use for action frames */ |
|
#define WSM_EPTA_PRIORITY_ACTION 5 |
|
/* use for AC_VI data */ |
|
#define WSM_EPTA_PRIORITY_VIDEO 5 |
|
/* use for AC_VO data */ |
|
#define WSM_EPTA_PRIORITY_VOICE 6 |
|
/* use for EAPOL exchange */ |
|
#define WSM_EPTA_PRIORITY_EAPOL 7 |
|
|
|
/* TX status */ |
|
/* Frame was sent aggregated */ |
|
/* Only valid for WSM_SUCCESS status. */ |
|
#define WSM_TX_STATUS_AGGREGATION (BIT(0)) |
|
|
|
/* Host should requeue this frame later. */ |
|
/* Valid only when status is WSM_REQUEUE. */ |
|
#define WSM_TX_STATUS_REQUEUE (BIT(1)) |
|
|
|
/* Normal Ack */ |
|
#define WSM_TX_STATUS_NORMAL_ACK (0<<2) |
|
|
|
/* No Ack */ |
|
#define WSM_TX_STATUS_NO_ACK (1<<2) |
|
|
|
/* No explicit acknowledgement */ |
|
#define WSM_TX_STATUS_NO_EXPLICIT_ACK (2<<2) |
|
|
|
/* Block Ack */ |
|
/* Only valid for WSM_SUCCESS status. */ |
|
#define WSM_TX_STATUS_BLOCK_ACK (3<<2) |
|
|
|
/* RX status */ |
|
/* Unencrypted */ |
|
#define WSM_RX_STATUS_UNENCRYPTED (0<<0) |
|
|
|
/* WEP */ |
|
#define WSM_RX_STATUS_WEP (1<<0) |
|
|
|
/* TKIP */ |
|
#define WSM_RX_STATUS_TKIP (2<<0) |
|
|
|
/* AES */ |
|
#define WSM_RX_STATUS_AES (3<<0) |
|
|
|
/* WAPI */ |
|
#define WSM_RX_STATUS_WAPI (4<<0) |
|
|
|
/* Macro to fetch encryption subfield. */ |
|
#define WSM_RX_STATUS_ENCRYPTION(status) ((status) & 0x07) |
|
|
|
/* Frame was part of an aggregation */ |
|
#define WSM_RX_STATUS_AGGREGATE (BIT(3)) |
|
|
|
/* Frame was first in the aggregation */ |
|
#define WSM_RX_STATUS_AGGREGATE_FIRST (BIT(4)) |
|
|
|
/* Frame was last in the aggregation */ |
|
#define WSM_RX_STATUS_AGGREGATE_LAST (BIT(5)) |
|
|
|
/* Indicates a defragmented frame */ |
|
#define WSM_RX_STATUS_DEFRAGMENTED (BIT(6)) |
|
|
|
/* Indicates a Beacon frame */ |
|
#define WSM_RX_STATUS_BEACON (BIT(7)) |
|
|
|
/* Indicates STA bit beacon TIM field */ |
|
#define WSM_RX_STATUS_TIM (BIT(8)) |
|
|
|
/* Indicates Beacon frame's virtual bitmap contains multicast bit */ |
|
#define WSM_RX_STATUS_MULTICAST (BIT(9)) |
|
|
|
/* Indicates frame contains a matching SSID */ |
|
#define WSM_RX_STATUS_MATCHING_SSID (BIT(10)) |
|
|
|
/* Indicates frame contains a matching BSSI */ |
|
#define WSM_RX_STATUS_MATCHING_BSSI (BIT(11)) |
|
|
|
/* Indicates More bit set in Framectl field */ |
|
#define WSM_RX_STATUS_MORE_DATA (BIT(12)) |
|
|
|
/* Indicates frame received during a measurement process */ |
|
#define WSM_RX_STATUS_MEASUREMENT (BIT(13)) |
|
|
|
/* Indicates frame received as an HT packet */ |
|
#define WSM_RX_STATUS_HT (BIT(14)) |
|
|
|
/* Indicates frame received with STBC */ |
|
#define WSM_RX_STATUS_STBC (BIT(15)) |
|
|
|
/* Indicates Address 1 field matches dot11StationId */ |
|
#define WSM_RX_STATUS_ADDRESS1 (BIT(16)) |
|
|
|
/* Indicates Group address present in the Address 1 field */ |
|
#define WSM_RX_STATUS_GROUP (BIT(17)) |
|
|
|
/* Indicates Broadcast address present in the Address 1 field */ |
|
#define WSM_RX_STATUS_BROADCAST (BIT(18)) |
|
|
|
/* Indicates group key used with encrypted frames */ |
|
#define WSM_RX_STATUS_GROUP_KEY (BIT(19)) |
|
|
|
/* Macro to fetch encryption key index. */ |
|
#define WSM_RX_STATUS_KEY_IDX(status) (((status >> 20)) & 0x0F) |
|
|
|
/* Indicates TSF inclusion after 802.11 frame body */ |
|
#define WSM_RX_STATUS_TSF_INCLUDED (BIT(24)) |
|
|
|
/* Frame Control field starts at Frame offset + 2 */ |
|
#define WSM_TX_2BYTES_SHIFT (BIT(7)) |
|
|
|
/* Join mode */ |
|
/* IBSS */ |
|
#define WSM_JOIN_MODE_IBSS (0) |
|
|
|
/* BSS */ |
|
#define WSM_JOIN_MODE_BSS (1) |
|
|
|
/* PLCP preamble type */ |
|
/* For long preamble */ |
|
#define WSM_JOIN_PREAMBLE_LONG (0) |
|
|
|
/* For short preamble (Long for 1Mbps) */ |
|
#define WSM_JOIN_PREAMBLE_SHORT (1) |
|
|
|
/* For short preamble (Long for 1 and 2Mbps) */ |
|
#define WSM_JOIN_PREAMBLE_SHORT_2 (2) |
|
|
|
/* Join flags */ |
|
/* Unsynchronized */ |
|
#define WSM_JOIN_FLAGS_UNSYNCRONIZED BIT(0) |
|
/* The BSS owner is a P2P GO */ |
|
#define WSM_JOIN_FLAGS_P2P_GO BIT(1) |
|
/* Force to join BSS with the BSSID and the |
|
* SSID specified without waiting for beacons. The |
|
* ProbeForJoin parameter is ignored. |
|
*/ |
|
#define WSM_JOIN_FLAGS_FORCE BIT(2) |
|
/* Give probe request/response higher |
|
* priority over the BT traffic |
|
*/ |
|
#define WSM_JOIN_FLAGS_PRIO BIT(3) |
|
/* Issue immediate join confirmation and use |
|
* join complete to notify about completion |
|
*/ |
|
#define WSM_JOIN_FLAGS_FORCE_WITH_COMPLETE_IND BIT(5) |
|
|
|
/* Key types */ |
|
#define WSM_KEY_TYPE_WEP_DEFAULT (0) |
|
#define WSM_KEY_TYPE_WEP_PAIRWISE (1) |
|
#define WSM_KEY_TYPE_TKIP_GROUP (2) |
|
#define WSM_KEY_TYPE_TKIP_PAIRWISE (3) |
|
#define WSM_KEY_TYPE_AES_GROUP (4) |
|
#define WSM_KEY_TYPE_AES_PAIRWISE (5) |
|
#define WSM_KEY_TYPE_WAPI_GROUP (6) |
|
#define WSM_KEY_TYPE_WAPI_PAIRWISE (7) |
|
|
|
/* Key indexes */ |
|
#define WSM_KEY_MAX_INDEX (10) |
|
|
|
/* ACK policy */ |
|
#define WSM_ACK_POLICY_NORMAL (0) |
|
#define WSM_ACK_POLICY_NO_ACK (1) |
|
|
|
/* Start modes */ |
|
#define WSM_START_MODE_AP (0) /* Mini AP */ |
|
#define WSM_START_MODE_P2P_GO (1) /* P2P GO */ |
|
#define WSM_START_MODE_P2P_DEV (2) /* P2P device */ |
|
|
|
/* SetAssociationMode MIB flags */ |
|
#define WSM_ASSOCIATION_MODE_USE_PREAMBLE_TYPE (BIT(0)) |
|
#define WSM_ASSOCIATION_MODE_USE_HT_MODE (BIT(1)) |
|
#define WSM_ASSOCIATION_MODE_USE_BASIC_RATE_SET (BIT(2)) |
|
#define WSM_ASSOCIATION_MODE_USE_MPDU_START_SPACING (BIT(3)) |
|
#define WSM_ASSOCIATION_MODE_SNOOP_ASSOC_FRAMES (BIT(4)) |
|
|
|
/* RcpiRssiThreshold MIB flags */ |
|
#define WSM_RCPI_RSSI_THRESHOLD_ENABLE (BIT(0)) |
|
#define WSM_RCPI_RSSI_USE_RSSI (BIT(1)) |
|
#define WSM_RCPI_RSSI_DONT_USE_UPPER (BIT(2)) |
|
#define WSM_RCPI_RSSI_DONT_USE_LOWER (BIT(3)) |
|
|
|
/* Update-ie constants */ |
|
#define WSM_UPDATE_IE_BEACON (BIT(0)) |
|
#define WSM_UPDATE_IE_PROBE_RESP (BIT(1)) |
|
#define WSM_UPDATE_IE_PROBE_REQ (BIT(2)) |
|
|
|
/* WSM events */ |
|
/* Error */ |
|
#define WSM_EVENT_ERROR (0) |
|
|
|
/* BSS lost */ |
|
#define WSM_EVENT_BSS_LOST (1) |
|
|
|
/* BSS regained */ |
|
#define WSM_EVENT_BSS_REGAINED (2) |
|
|
|
/* Radar detected */ |
|
#define WSM_EVENT_RADAR_DETECTED (3) |
|
|
|
/* RCPI or RSSI threshold triggered */ |
|
#define WSM_EVENT_RCPI_RSSI (4) |
|
|
|
/* BT inactive */ |
|
#define WSM_EVENT_BT_INACTIVE (5) |
|
|
|
/* BT active */ |
|
#define WSM_EVENT_BT_ACTIVE (6) |
|
|
|
/* MIB IDs */ |
|
/* 4.1 dot11StationId */ |
|
#define WSM_MIB_ID_DOT11_STATION_ID 0x0000 |
|
|
|
/* 4.2 dot11MaxtransmitMsduLifeTime */ |
|
#define WSM_MIB_ID_DOT11_MAX_TRANSMIT_LIFTIME 0x0001 |
|
|
|
/* 4.3 dot11MaxReceiveLifeTime */ |
|
#define WSM_MIB_ID_DOT11_MAX_RECEIVE_LIFETIME 0x0002 |
|
|
|
/* 4.4 dot11SlotTime */ |
|
#define WSM_MIB_ID_DOT11_SLOT_TIME 0x0003 |
|
|
|
/* 4.5 dot11GroupAddressesTable */ |
|
#define WSM_MIB_ID_DOT11_GROUP_ADDRESSES_TABLE 0x0004 |
|
#define WSM_MAX_GRP_ADDRTABLE_ENTRIES 8 |
|
|
|
/* 4.6 dot11WepDefaultKeyId */ |
|
#define WSM_MIB_ID_DOT11_WEP_DEFAULT_KEY_ID 0x0005 |
|
|
|
/* 4.7 dot11CurrentTxPowerLevel */ |
|
#define WSM_MIB_ID_DOT11_CURRENT_TX_POWER_LEVEL 0x0006 |
|
|
|
/* 4.8 dot11RTSThreshold */ |
|
#define WSM_MIB_ID_DOT11_RTS_THRESHOLD 0x0007 |
|
|
|
/* 4.9 NonErpProtection */ |
|
#define WSM_MIB_ID_NON_ERP_PROTECTION 0x1000 |
|
|
|
/* 4.10 ArpIpAddressesTable */ |
|
#define WSM_MIB_ID_ARP_IP_ADDRESSES_TABLE 0x1001 |
|
#define WSM_MAX_ARP_IP_ADDRTABLE_ENTRIES 1 |
|
|
|
/* 4.11 TemplateFrame */ |
|
#define WSM_MIB_ID_TEMPLATE_FRAME 0x1002 |
|
|
|
/* 4.12 RxFilter */ |
|
#define WSM_MIB_ID_RX_FILTER 0x1003 |
|
|
|
/* 4.13 BeaconFilterTable */ |
|
#define WSM_MIB_ID_BEACON_FILTER_TABLE 0x1004 |
|
|
|
/* 4.14 BeaconFilterEnable */ |
|
#define WSM_MIB_ID_BEACON_FILTER_ENABLE 0x1005 |
|
|
|
/* 4.15 OperationalPowerMode */ |
|
#define WSM_MIB_ID_OPERATIONAL_POWER_MODE 0x1006 |
|
|
|
/* 4.16 BeaconWakeUpPeriod */ |
|
#define WSM_MIB_ID_BEACON_WAKEUP_PERIOD 0x1007 |
|
|
|
/* 4.17 RcpiRssiThreshold */ |
|
#define WSM_MIB_ID_RCPI_RSSI_THRESHOLD 0x1009 |
|
|
|
/* 4.18 StatisticsTable */ |
|
#define WSM_MIB_ID_STATISTICS_TABLE 0x100A |
|
|
|
/* 4.19 IbssPsConfig */ |
|
#define WSM_MIB_ID_IBSS_PS_CONFIG 0x100B |
|
|
|
/* 4.20 CountersTable */ |
|
#define WSM_MIB_ID_COUNTERS_TABLE 0x100C |
|
|
|
/* 4.21 BlockAckPolicy */ |
|
#define WSM_MIB_ID_BLOCK_ACK_POLICY 0x100E |
|
|
|
/* 4.22 OverrideInternalTxRate */ |
|
#define WSM_MIB_ID_OVERRIDE_INTERNAL_TX_RATE 0x100F |
|
|
|
/* 4.23 SetAssociationMode */ |
|
#define WSM_MIB_ID_SET_ASSOCIATION_MODE 0x1010 |
|
|
|
/* 4.24 UpdateEptaConfigData */ |
|
#define WSM_MIB_ID_UPDATE_EPTA_CONFIG_DATA 0x1011 |
|
|
|
/* 4.25 SelectCcaMethod */ |
|
#define WSM_MIB_ID_SELECT_CCA_METHOD 0x1012 |
|
|
|
/* 4.26 SetUpasdInformation */ |
|
#define WSM_MIB_ID_SET_UAPSD_INFORMATION 0x1013 |
|
|
|
/* 4.27 SetAutoCalibrationMode WBF00004073 */ |
|
#define WSM_MIB_ID_SET_AUTO_CALIBRATION_MODE 0x1015 |
|
|
|
/* 4.28 SetTxRateRetryPolicy */ |
|
#define WSM_MIB_ID_SET_TX_RATE_RETRY_POLICY 0x1016 |
|
|
|
/* 4.29 SetHostMessageTypeFilter */ |
|
#define WSM_MIB_ID_SET_HOST_MSG_TYPE_FILTER 0x1017 |
|
|
|
/* 4.30 P2PFindInfo */ |
|
#define WSM_MIB_ID_P2P_FIND_INFO 0x1018 |
|
|
|
/* 4.31 P2PPsModeInfo */ |
|
#define WSM_MIB_ID_P2P_PS_MODE_INFO 0x1019 |
|
|
|
/* 4.32 SetEtherTypeDataFrameFilter */ |
|
#define WSM_MIB_ID_SET_ETHERTYPE_DATAFRAME_FILTER 0x101A |
|
|
|
/* 4.33 SetUDPPortDataFrameFilter */ |
|
#define WSM_MIB_ID_SET_UDPPORT_DATAFRAME_FILTER 0x101B |
|
|
|
/* 4.34 SetMagicDataFrameFilter */ |
|
#define WSM_MIB_ID_SET_MAGIC_DATAFRAME_FILTER 0x101C |
|
|
|
/* 4.35 P2PDeviceInfo */ |
|
#define WSM_MIB_ID_P2P_DEVICE_INFO 0x101D |
|
|
|
/* 4.36 SetWCDMABand */ |
|
#define WSM_MIB_ID_SET_WCDMA_BAND 0x101E |
|
|
|
/* 4.37 GroupTxSequenceCounter */ |
|
#define WSM_MIB_ID_GRP_SEQ_COUNTER 0x101F |
|
|
|
/* 4.38 ProtectedMgmtPolicy */ |
|
#define WSM_MIB_ID_PROTECTED_MGMT_POLICY 0x1020 |
|
|
|
/* 4.39 SetHtProtection */ |
|
#define WSM_MIB_ID_SET_HT_PROTECTION 0x1021 |
|
|
|
/* 4.40 GPIO Command */ |
|
#define WSM_MIB_ID_GPIO_COMMAND 0x1022 |
|
|
|
/* 4.41 TSF Counter Value */ |
|
#define WSM_MIB_ID_TSF_COUNTER 0x1023 |
|
|
|
/* Test Purposes Only */ |
|
#define WSM_MIB_ID_BLOCK_ACK_INFO 0x100D |
|
|
|
/* 4.42 UseMultiTxConfMessage */ |
|
#define WSM_MIB_USE_MULTI_TX_CONF 0x1024 |
|
|
|
/* 4.43 Keep-alive period */ |
|
#define WSM_MIB_ID_KEEP_ALIVE_PERIOD 0x1025 |
|
|
|
/* 4.44 Disable BSSID filter */ |
|
#define WSM_MIB_ID_DISABLE_BSSID_FILTER 0x1026 |
|
|
|
/* Frame template types */ |
|
#define WSM_FRAME_TYPE_PROBE_REQUEST (0) |
|
#define WSM_FRAME_TYPE_BEACON (1) |
|
#define WSM_FRAME_TYPE_NULL (2) |
|
#define WSM_FRAME_TYPE_QOS_NULL (3) |
|
#define WSM_FRAME_TYPE_PS_POLL (4) |
|
#define WSM_FRAME_TYPE_PROBE_RESPONSE (5) |
|
|
|
#define WSM_FRAME_GREENFIELD (0x80) /* See 4.11 */ |
|
|
|
/* Status */ |
|
/* The WSM firmware has completed a request */ |
|
/* successfully. */ |
|
#define WSM_STATUS_SUCCESS (0) |
|
|
|
/* This is a generic failure code if other error codes do */ |
|
/* not apply. */ |
|
#define WSM_STATUS_FAILURE (1) |
|
|
|
/* A request contains one or more invalid parameters. */ |
|
#define WSM_INVALID_PARAMETER (2) |
|
|
|
/* The request cannot perform because the device is in */ |
|
/* an inappropriate mode. */ |
|
#define WSM_ACCESS_DENIED (3) |
|
|
|
/* The frame received includes a decryption error. */ |
|
#define WSM_STATUS_DECRYPTFAILURE (4) |
|
|
|
/* A MIC failure is detected in the received packets. */ |
|
#define WSM_STATUS_MICFAILURE (5) |
|
|
|
/* The transmit request failed due to retry limit being */ |
|
/* exceeded. */ |
|
#define WSM_STATUS_RETRY_EXCEEDED (6) |
|
|
|
/* The transmit request failed due to MSDU life time */ |
|
/* being exceeded. */ |
|
#define WSM_STATUS_TX_LIFETIME_EXCEEDED (7) |
|
|
|
/* The link to the AP is lost. */ |
|
#define WSM_STATUS_LINK_LOST (8) |
|
|
|
/* No key was found for the encrypted frame */ |
|
#define WSM_STATUS_NO_KEY_FOUND (9) |
|
|
|
/* Jammer was detected when transmitting this frame */ |
|
#define WSM_STATUS_JAMMER_DETECTED (10) |
|
|
|
/* The message should be requeued later. */ |
|
/* This is applicable only to Transmit */ |
|
#define WSM_REQUEUE (11) |
|
|
|
/* Advanced filtering options */ |
|
#define WSM_MAX_FILTER_ELEMENTS (4) |
|
|
|
#define WSM_FILTER_ACTION_IGNORE (0) |
|
#define WSM_FILTER_ACTION_FILTER_IN (1) |
|
#define WSM_FILTER_ACTION_FILTER_OUT (2) |
|
|
|
#define WSM_FILTER_PORT_TYPE_DST (0) |
|
#define WSM_FILTER_PORT_TYPE_SRC (1) |
|
|
|
/* Actual header of WSM messages */ |
|
struct wsm_hdr { |
|
__le16 len; |
|
__le16 id; |
|
}; |
|
|
|
#define WSM_TX_SEQ_MAX (7) |
|
#define WSM_TX_SEQ(seq) \ |
|
((seq & WSM_TX_SEQ_MAX) << 13) |
|
#define WSM_TX_LINK_ID_MAX (0x0F) |
|
#define WSM_TX_LINK_ID(link_id) \ |
|
((link_id & WSM_TX_LINK_ID_MAX) << 6) |
|
|
|
#define MAX_BEACON_SKIP_TIME_MS 1000 |
|
|
|
#define WSM_CMD_LAST_CHANCE_TIMEOUT (HZ * 3 / 2) |
|
|
|
/* ******************************************************************** */ |
|
/* WSM capability */ |
|
|
|
#define WSM_STARTUP_IND_ID 0x0801 |
|
|
|
struct wsm_startup_ind { |
|
u16 input_buffers; |
|
u16 input_buffer_size; |
|
u16 status; |
|
u16 hw_id; |
|
u16 hw_subid; |
|
u16 fw_cap; |
|
u16 fw_type; |
|
u16 fw_api; |
|
u16 fw_build; |
|
u16 fw_ver; |
|
char fw_label[128]; |
|
u32 config[4]; |
|
}; |
|
|
|
/* ******************************************************************** */ |
|
/* WSM commands */ |
|
|
|
/* 3.1 */ |
|
#define WSM_CONFIGURATION_REQ_ID 0x0009 |
|
#define WSM_CONFIGURATION_RESP_ID 0x0409 |
|
|
|
struct wsm_tx_power_range { |
|
int min_power_level; |
|
int max_power_level; |
|
u32 stepping; |
|
}; |
|
|
|
struct wsm_configuration { |
|
/* [in] */ u32 dot11MaxTransmitMsduLifeTime; |
|
/* [in] */ u32 dot11MaxReceiveLifeTime; |
|
/* [in] */ u32 dot11RtsThreshold; |
|
/* [in, out] */ u8 *dot11StationId; |
|
/* [in] */ const void *dpdData; |
|
/* [in] */ size_t dpdData_size; |
|
/* [out] */ u8 dot11FrequencyBandsSupported; |
|
/* [out] */ u32 supportedRateMask; |
|
/* [out] */ struct wsm_tx_power_range txPowerRange[2]; |
|
}; |
|
|
|
int wsm_configuration(struct cw1200_common *priv, |
|
struct wsm_configuration *arg); |
|
|
|
/* 3.3 */ |
|
#define WSM_RESET_REQ_ID 0x000A |
|
#define WSM_RESET_RESP_ID 0x040A |
|
struct wsm_reset { |
|
/* [in] */ int link_id; |
|
/* [in] */ bool reset_statistics; |
|
}; |
|
|
|
int wsm_reset(struct cw1200_common *priv, const struct wsm_reset *arg); |
|
|
|
/* 3.5 */ |
|
#define WSM_READ_MIB_REQ_ID 0x0005 |
|
#define WSM_READ_MIB_RESP_ID 0x0405 |
|
int wsm_read_mib(struct cw1200_common *priv, u16 mib_id, void *buf, |
|
size_t buf_size); |
|
|
|
/* 3.7 */ |
|
#define WSM_WRITE_MIB_REQ_ID 0x0006 |
|
#define WSM_WRITE_MIB_RESP_ID 0x0406 |
|
int wsm_write_mib(struct cw1200_common *priv, u16 mib_id, void *buf, |
|
size_t buf_size); |
|
|
|
/* 3.9 */ |
|
#define WSM_START_SCAN_REQ_ID 0x0007 |
|
#define WSM_START_SCAN_RESP_ID 0x0407 |
|
|
|
struct wsm_ssid { |
|
u8 ssid[32]; |
|
u32 length; |
|
}; |
|
|
|
struct wsm_scan_ch { |
|
u16 number; |
|
u32 min_chan_time; |
|
u32 max_chan_time; |
|
u32 tx_power_level; |
|
}; |
|
|
|
struct wsm_scan { |
|
/* WSM_PHY_BAND_... */ |
|
u8 band; |
|
|
|
/* WSM_SCAN_TYPE_... */ |
|
u8 type; |
|
|
|
/* WSM_SCAN_FLAG_... */ |
|
u8 flags; |
|
|
|
/* WSM_TRANSMIT_RATE_... */ |
|
u8 max_tx_rate; |
|
|
|
/* Interval period in TUs that the device shall the re- */ |
|
/* execute the requested scan. Max value supported by the device */ |
|
/* is 256s. */ |
|
u32 auto_scan_interval; |
|
|
|
/* Number of probe requests (per SSID) sent to one (1) */ |
|
/* channel. Zero (0) means that none is send, which */ |
|
/* means that a passive scan is to be done. Value */ |
|
/* greater than zero (0) means that an active scan is to */ |
|
/* be done. */ |
|
u32 num_probes; |
|
|
|
/* Number of channels to be scanned. */ |
|
/* Maximum value is WSM_SCAN_MAX_NUM_OF_CHANNELS. */ |
|
u8 num_channels; |
|
|
|
/* Number of SSID provided in the scan command (this */ |
|
/* is zero (0) in broadcast scan) */ |
|
/* The maximum number of SSIDs is WSM_SCAN_MAX_NUM_OF_SSIDS. */ |
|
u8 num_ssids; |
|
|
|
/* The delay time (in microseconds) period */ |
|
/* before sending a probe-request. */ |
|
u8 probe_delay; |
|
|
|
/* SSIDs to be scanned [numOfSSIDs]; */ |
|
struct wsm_ssid *ssids; |
|
|
|
/* Channels to be scanned [numOfChannels]; */ |
|
struct wsm_scan_ch *ch; |
|
}; |
|
|
|
int wsm_scan(struct cw1200_common *priv, const struct wsm_scan *arg); |
|
|
|
/* 3.11 */ |
|
#define WSM_STOP_SCAN_REQ_ID 0x0008 |
|
#define WSM_STOP_SCAN_RESP_ID 0x0408 |
|
int wsm_stop_scan(struct cw1200_common *priv); |
|
|
|
/* 3.13 */ |
|
#define WSM_SCAN_COMPLETE_IND_ID 0x0806 |
|
struct wsm_scan_complete { |
|
/* WSM_STATUS_... */ |
|
u32 status; |
|
|
|
/* WSM_PSM_... */ |
|
u8 psm; |
|
|
|
/* Number of channels that the scan operation completed. */ |
|
u8 num_channels; |
|
}; |
|
|
|
/* 3.14 */ |
|
#define WSM_TX_CONFIRM_IND_ID 0x0404 |
|
#define WSM_MULTI_TX_CONFIRM_ID 0x041E |
|
|
|
struct wsm_tx_confirm { |
|
/* Packet identifier used in wsm_tx. */ |
|
u32 packet_id; |
|
|
|
/* WSM_STATUS_... */ |
|
u32 status; |
|
|
|
/* WSM_TRANSMIT_RATE_... */ |
|
u8 tx_rate; |
|
|
|
/* The number of times the frame was transmitted */ |
|
/* without receiving an acknowledgement. */ |
|
u8 ack_failures; |
|
|
|
/* WSM_TX_STATUS_... */ |
|
u16 flags; |
|
|
|
/* The total time in microseconds that the frame spent in */ |
|
/* the WLAN device before transmission as completed. */ |
|
u32 media_delay; |
|
|
|
/* The total time in microseconds that the frame spent in */ |
|
/* the WLAN device before transmission was started. */ |
|
u32 tx_queue_delay; |
|
}; |
|
|
|
/* 3.15 */ |
|
|
|
/* Note that ideology of wsm_tx struct is different against the rest of |
|
* WSM API. wsm_hdr is /not/ a caller-adapted struct to be used as an input |
|
* argument for WSM call, but a prepared bytestream to be sent to firmware. |
|
* It is filled partly in cw1200_tx, partly in low-level WSM code. |
|
* Please pay attention once again: ideology is different. |
|
* |
|
* Legend: |
|
* - [in]: cw1200_tx must fill this field. |
|
* - [wsm]: the field is filled by low-level WSM. |
|
*/ |
|
struct wsm_tx { |
|
/* common WSM header */ |
|
struct wsm_hdr hdr; |
|
|
|
/* Packet identifier that meant to be used in completion. */ |
|
u32 packet_id; /* Note this is actually a cookie */ |
|
|
|
/* WSM_TRANSMIT_RATE_... */ |
|
u8 max_tx_rate; |
|
|
|
/* WSM_QUEUE_... */ |
|
u8 queue_id; |
|
|
|
/* True: another packet is pending on the host for transmission. */ |
|
u8 more; |
|
|
|
/* Bit 0 = 0 - Start expiry time from first Tx attempt (default) */ |
|
/* Bit 0 = 1 - Start expiry time from receipt of Tx Request */ |
|
/* Bits 3:1 - PTA Priority */ |
|
/* Bits 6:4 - Tx Rate Retry Policy */ |
|
/* Bit 7 - Reserved */ |
|
u8 flags; |
|
|
|
/* Should be 0. */ |
|
u32 reserved; |
|
|
|
/* The elapsed time in TUs, after the initial transmission */ |
|
/* of an MSDU, after which further attempts to transmit */ |
|
/* the MSDU shall be terminated. Overrides the global */ |
|
/* dot11MaxTransmitMsduLifeTime setting [optional] */ |
|
/* Device will set the default value if this is 0. */ |
|
__le32 expire_time; |
|
|
|
/* WSM_HT_TX_... */ |
|
__le32 ht_tx_parameters; |
|
} __packed; |
|
|
|
/* = sizeof(generic hi hdr) + sizeof(wsm hdr) + sizeof(alignment) */ |
|
#define WSM_TX_EXTRA_HEADROOM (28) |
|
|
|
/* 3.16 */ |
|
#define WSM_RECEIVE_IND_ID 0x0804 |
|
|
|
struct wsm_rx { |
|
/* WSM_STATUS_... */ |
|
u32 status; |
|
|
|
/* Specifies the channel of the received packet. */ |
|
u16 channel_number; |
|
|
|
/* WSM_TRANSMIT_RATE_... */ |
|
u8 rx_rate; |
|
|
|
/* This value is expressed in signed Q8.0 format for */ |
|
/* RSSI and unsigned Q7.1 format for RCPI. */ |
|
u8 rcpi_rssi; |
|
|
|
/* WSM_RX_STATUS_... */ |
|
u32 flags; |
|
}; |
|
|
|
/* = sizeof(generic hi hdr) + sizeof(wsm hdr) */ |
|
#define WSM_RX_EXTRA_HEADROOM (16) |
|
|
|
/* 3.17 */ |
|
struct wsm_event { |
|
/* WSM_STATUS_... */ |
|
/* [out] */ u32 id; |
|
|
|
/* Indication parameters. */ |
|
/* For error indication, this shall be a 32-bit WSM status. */ |
|
/* For RCPI or RSSI indication, this should be an 8-bit */ |
|
/* RCPI or RSSI value. */ |
|
/* [out] */ u32 data; |
|
}; |
|
|
|
struct cw1200_wsm_event { |
|
struct list_head link; |
|
struct wsm_event evt; |
|
}; |
|
|
|
/* 3.18 - 3.22 */ |
|
/* Measurement. Skipped for now. Irrelevent. */ |
|
|
|
typedef void (*wsm_event_cb) (struct cw1200_common *priv, |
|
struct wsm_event *arg); |
|
|
|
/* 3.23 */ |
|
#define WSM_JOIN_REQ_ID 0x000B |
|
#define WSM_JOIN_RESP_ID 0x040B |
|
|
|
struct wsm_join { |
|
/* WSM_JOIN_MODE_... */ |
|
u8 mode; |
|
|
|
/* WSM_PHY_BAND_... */ |
|
u8 band; |
|
|
|
/* Specifies the channel number to join. The channel */ |
|
/* number will be mapped to an actual frequency */ |
|
/* according to the band */ |
|
u16 channel_number; |
|
|
|
/* Specifies the BSSID of the BSS or IBSS to be joined */ |
|
/* or the IBSS to be started. */ |
|
u8 bssid[6]; |
|
|
|
/* ATIM window of IBSS */ |
|
/* When ATIM window is zero the initiated IBSS does */ |
|
/* not support power saving. */ |
|
u16 atim_window; |
|
|
|
/* WSM_JOIN_PREAMBLE_... */ |
|
u8 preamble_type; |
|
|
|
/* Specifies if a probe request should be send with the */ |
|
/* specified SSID when joining to the network. */ |
|
u8 probe_for_join; |
|
|
|
/* DTIM Period (In multiples of beacon interval) */ |
|
u8 dtim_period; |
|
|
|
/* WSM_JOIN_FLAGS_... */ |
|
u8 flags; |
|
|
|
/* Length of the SSID */ |
|
u32 ssid_len; |
|
|
|
/* Specifies the SSID of the IBSS to join or start */ |
|
u8 ssid[32]; |
|
|
|
/* Specifies the time between TBTTs in TUs */ |
|
u32 beacon_interval; |
|
|
|
/* A bit mask that defines the BSS basic rate set. */ |
|
u32 basic_rate_set; |
|
}; |
|
|
|
struct wsm_join_cnf { |
|
u32 status; |
|
|
|
/* Minimum transmission power level in units of 0.1dBm */ |
|
u32 min_power_level; |
|
|
|
/* Maximum transmission power level in units of 0.1dBm */ |
|
u32 max_power_level; |
|
}; |
|
|
|
int wsm_join(struct cw1200_common *priv, struct wsm_join *arg); |
|
|
|
/* 3.24 */ |
|
struct wsm_join_complete { |
|
/* WSM_STATUS_... */ |
|
u32 status; |
|
}; |
|
|
|
/* 3.25 */ |
|
#define WSM_SET_PM_REQ_ID 0x0010 |
|
#define WSM_SET_PM_RESP_ID 0x0410 |
|
struct wsm_set_pm { |
|
/* WSM_PSM_... */ |
|
u8 mode; |
|
|
|
/* in unit of 500us; 0 to use default */ |
|
u8 fast_psm_idle_period; |
|
|
|
/* in unit of 500us; 0 to use default */ |
|
u8 ap_psm_change_period; |
|
|
|
/* in unit of 500us; 0 to disable auto-pspoll */ |
|
u8 min_auto_pspoll_period; |
|
}; |
|
|
|
int wsm_set_pm(struct cw1200_common *priv, const struct wsm_set_pm *arg); |
|
|
|
/* 3.27 */ |
|
struct wsm_set_pm_complete { |
|
u8 psm; /* WSM_PSM_... */ |
|
}; |
|
|
|
/* 3.28 */ |
|
#define WSM_SET_BSS_PARAMS_REQ_ID 0x0011 |
|
#define WSM_SET_BSS_PARAMS_RESP_ID 0x0411 |
|
struct wsm_set_bss_params { |
|
/* This resets the beacon loss counters only */ |
|
u8 reset_beacon_loss; |
|
|
|
/* The number of lost consecutive beacons after which */ |
|
/* the WLAN device should indicate the BSS-Lost event */ |
|
/* to the WLAN host driver. */ |
|
u8 beacon_lost_count; |
|
|
|
/* The AID received during the association process. */ |
|
u16 aid; |
|
|
|
/* The operational rate set mask */ |
|
u32 operational_rate_set; |
|
}; |
|
|
|
int wsm_set_bss_params(struct cw1200_common *priv, |
|
const struct wsm_set_bss_params *arg); |
|
|
|
/* 3.30 */ |
|
#define WSM_ADD_KEY_REQ_ID 0x000C |
|
#define WSM_ADD_KEY_RESP_ID 0x040C |
|
struct wsm_add_key { |
|
u8 type; /* WSM_KEY_TYPE_... */ |
|
u8 index; /* Key entry index: 0 -- WSM_KEY_MAX_INDEX */ |
|
u16 reserved; |
|
union { |
|
struct { |
|
u8 peer[6]; /* MAC address of the peer station */ |
|
u8 reserved; |
|
u8 keylen; /* Key length in bytes */ |
|
u8 keydata[16]; /* Key data */ |
|
} __packed wep_pairwise; |
|
struct { |
|
u8 keyid; /* Unique per key identifier (0..3) */ |
|
u8 keylen; /* Key length in bytes */ |
|
u16 reserved; |
|
u8 keydata[16]; /* Key data */ |
|
} __packed wep_group; |
|
struct { |
|
u8 peer[6]; /* MAC address of the peer station */ |
|
u16 reserved; |
|
u8 keydata[16]; /* TKIP key data */ |
|
u8 rx_mic_key[8]; /* Rx MIC key */ |
|
u8 tx_mic_key[8]; /* Tx MIC key */ |
|
} __packed tkip_pairwise; |
|
struct { |
|
u8 keydata[16]; /* TKIP key data */ |
|
u8 rx_mic_key[8]; /* Rx MIC key */ |
|
u8 keyid; /* Key ID */ |
|
u8 reserved[3]; |
|
u8 rx_seqnum[8]; /* Receive Sequence Counter */ |
|
} __packed tkip_group; |
|
struct { |
|
u8 peer[6]; /* MAC address of the peer station */ |
|
u16 reserved; |
|
u8 keydata[16]; /* AES key data */ |
|
} __packed aes_pairwise; |
|
struct { |
|
u8 keydata[16]; /* AES key data */ |
|
u8 keyid; /* Key ID */ |
|
u8 reserved[3]; |
|
u8 rx_seqnum[8]; /* Receive Sequence Counter */ |
|
} __packed aes_group; |
|
struct { |
|
u8 peer[6]; /* MAC address of the peer station */ |
|
u8 keyid; /* Key ID */ |
|
u8 reserved; |
|
u8 keydata[16]; /* WAPI key data */ |
|
u8 mic_key[16]; /* MIC key data */ |
|
} __packed wapi_pairwise; |
|
struct { |
|
u8 keydata[16]; /* WAPI key data */ |
|
u8 mic_key[16]; /* MIC key data */ |
|
u8 keyid; /* Key ID */ |
|
u8 reserved[3]; |
|
} __packed wapi_group; |
|
} __packed; |
|
} __packed; |
|
|
|
int wsm_add_key(struct cw1200_common *priv, const struct wsm_add_key *arg); |
|
|
|
/* 3.32 */ |
|
#define WSM_REMOVE_KEY_REQ_ID 0x000D |
|
#define WSM_REMOVE_KEY_RESP_ID 0x040D |
|
struct wsm_remove_key { |
|
u8 index; /* Key entry index : 0-10 */ |
|
}; |
|
|
|
int wsm_remove_key(struct cw1200_common *priv, |
|
const struct wsm_remove_key *arg); |
|
|
|
/* 3.34 */ |
|
struct wsm_set_tx_queue_params { |
|
/* WSM_ACK_POLICY_... */ |
|
u8 ackPolicy; |
|
|
|
/* Medium Time of TSPEC (in 32us units) allowed per */ |
|
/* One Second Averaging Period for this queue. */ |
|
u16 allowedMediumTime; |
|
|
|
/* dot11MaxTransmitMsduLifetime to be used for the */ |
|
/* specified queue. */ |
|
u32 maxTransmitLifetime; |
|
}; |
|
|
|
struct wsm_tx_queue_params { |
|
/* NOTE: index is a linux queue id. */ |
|
struct wsm_set_tx_queue_params params[4]; |
|
}; |
|
|
|
|
|
#define WSM_TX_QUEUE_SET(queue_params, queue, ack_policy, allowed_time,\ |
|
max_life_time) \ |
|
do { \ |
|
struct wsm_set_tx_queue_params *p = &(queue_params)->params[queue]; \ |
|
p->ackPolicy = (ack_policy); \ |
|
p->allowedMediumTime = (allowed_time); \ |
|
p->maxTransmitLifetime = (max_life_time); \ |
|
} while (0) |
|
|
|
int wsm_set_tx_queue_params(struct cw1200_common *priv, |
|
const struct wsm_set_tx_queue_params *arg, u8 id); |
|
|
|
/* 3.36 */ |
|
#define WSM_EDCA_PARAMS_REQ_ID 0x0013 |
|
#define WSM_EDCA_PARAMS_RESP_ID 0x0413 |
|
struct wsm_edca_queue_params { |
|
/* CWmin (in slots) for the access class. */ |
|
u16 cwmin; |
|
|
|
/* CWmax (in slots) for the access class. */ |
|
u16 cwmax; |
|
|
|
/* AIFS (in slots) for the access class. */ |
|
u16 aifns; |
|
|
|
/* TX OP Limit (in microseconds) for the access class. */ |
|
u16 txop_limit; |
|
|
|
/* dot11MaxReceiveLifetime to be used for the specified */ |
|
/* the access class. Overrides the global */ |
|
/* dot11MaxReceiveLifetime value */ |
|
u32 max_rx_lifetime; |
|
}; |
|
|
|
struct wsm_edca_params { |
|
/* NOTE: index is a linux queue id. */ |
|
struct wsm_edca_queue_params params[4]; |
|
bool uapsd_enable[4]; |
|
}; |
|
|
|
#define TXOP_UNIT 32 |
|
#define WSM_EDCA_SET(__edca, __queue, __aifs, __cw_min, __cw_max, __txop, __lifetime,\ |
|
__uapsd) \ |
|
do { \ |
|
struct wsm_edca_queue_params *p = &(__edca)->params[__queue]; \ |
|
p->cwmin = __cw_min; \ |
|
p->cwmax = __cw_max; \ |
|
p->aifns = __aifs; \ |
|
p->txop_limit = ((__txop) * TXOP_UNIT); \ |
|
p->max_rx_lifetime = __lifetime; \ |
|
(__edca)->uapsd_enable[__queue] = (__uapsd); \ |
|
} while (0) |
|
|
|
int wsm_set_edca_params(struct cw1200_common *priv, |
|
const struct wsm_edca_params *arg); |
|
|
|
int wsm_set_uapsd_param(struct cw1200_common *priv, |
|
const struct wsm_edca_params *arg); |
|
|
|
/* 3.38 */ |
|
/* Set-System info. Skipped for now. Irrelevent. */ |
|
|
|
/* 3.40 */ |
|
#define WSM_SWITCH_CHANNEL_REQ_ID 0x0016 |
|
#define WSM_SWITCH_CHANNEL_RESP_ID 0x0416 |
|
|
|
struct wsm_switch_channel { |
|
/* 1 - means the STA shall not transmit any further */ |
|
/* frames until the channel switch has completed */ |
|
u8 mode; |
|
|
|
/* Number of TBTTs until channel switch occurs. */ |
|
/* 0 - indicates switch shall occur at any time */ |
|
/* 1 - occurs immediately before the next TBTT */ |
|
u8 switch_count; |
|
|
|
/* The new channel number to switch to. */ |
|
/* Note this is defined as per section 2.7. */ |
|
u16 channel_number; |
|
}; |
|
|
|
int wsm_switch_channel(struct cw1200_common *priv, |
|
const struct wsm_switch_channel *arg); |
|
|
|
#define WSM_START_REQ_ID 0x0017 |
|
#define WSM_START_RESP_ID 0x0417 |
|
|
|
struct wsm_start { |
|
/* WSM_START_MODE_... */ |
|
/* [in] */ u8 mode; |
|
|
|
/* WSM_PHY_BAND_... */ |
|
/* [in] */ u8 band; |
|
|
|
/* Channel number */ |
|
/* [in] */ u16 channel_number; |
|
|
|
/* Client Traffic window in units of TU */ |
|
/* Valid only when mode == ..._P2P */ |
|
/* [in] */ u32 ct_window; |
|
|
|
/* Interval between two consecutive */ |
|
/* beacon transmissions in TU. */ |
|
/* [in] */ u32 beacon_interval; |
|
|
|
/* DTIM period in terms of beacon intervals */ |
|
/* [in] */ u8 dtim_period; |
|
|
|
/* WSM_JOIN_PREAMBLE_... */ |
|
/* [in] */ u8 preamble; |
|
|
|
/* The delay time (in microseconds) period */ |
|
/* before sending a probe-request. */ |
|
/* [in] */ u8 probe_delay; |
|
|
|
/* Length of the SSID */ |
|
/* [in] */ u8 ssid_len; |
|
|
|
/* SSID of the BSS or P2P_GO to be started now. */ |
|
/* [in] */ u8 ssid[32]; |
|
|
|
/* The basic supported rates for the MiniAP. */ |
|
/* [in] */ u32 basic_rate_set; |
|
}; |
|
|
|
int wsm_start(struct cw1200_common *priv, const struct wsm_start *arg); |
|
|
|
#define WSM_BEACON_TRANSMIT_REQ_ID 0x0018 |
|
#define WSM_BEACON_TRANSMIT_RESP_ID 0x0418 |
|
|
|
struct wsm_beacon_transmit { |
|
/* 1: enable; 0: disable */ |
|
/* [in] */ u8 enable_beaconing; |
|
}; |
|
|
|
int wsm_beacon_transmit(struct cw1200_common *priv, |
|
const struct wsm_beacon_transmit *arg); |
|
|
|
int wsm_start_find(struct cw1200_common *priv); |
|
|
|
int wsm_stop_find(struct cw1200_common *priv); |
|
|
|
struct wsm_suspend_resume { |
|
/* See 3.52 */ |
|
/* Link ID */ |
|
/* [out] */ int link_id; |
|
/* Stop sending further Tx requests down to device for this link */ |
|
/* [out] */ bool stop; |
|
/* Transmit multicast Frames */ |
|
/* [out] */ bool multicast; |
|
/* The AC on which Tx to be suspended /resumed. */ |
|
/* This is applicable only for U-APSD */ |
|
/* WSM_QUEUE_... */ |
|
/* [out] */ int queue; |
|
}; |
|
|
|
/* 3.54 Update-IE request. */ |
|
struct wsm_update_ie { |
|
/* WSM_UPDATE_IE_... */ |
|
/* [in] */ u16 what; |
|
/* [in] */ u16 count; |
|
/* [in] */ u8 *ies; |
|
/* [in] */ size_t length; |
|
}; |
|
|
|
int wsm_update_ie(struct cw1200_common *priv, |
|
const struct wsm_update_ie *arg); |
|
|
|
/* 3.56 */ |
|
struct wsm_map_link { |
|
/* MAC address of the remote device */ |
|
/* [in] */ u8 mac_addr[6]; |
|
/* [in] */ u8 link_id; |
|
}; |
|
|
|
int wsm_map_link(struct cw1200_common *priv, const struct wsm_map_link *arg); |
|
|
|
/* ******************************************************************** */ |
|
/* MIB shortcats */ |
|
|
|
static inline int wsm_set_output_power(struct cw1200_common *priv, |
|
int power_level) |
|
{ |
|
__le32 val = __cpu_to_le32(power_level); |
|
return wsm_write_mib(priv, WSM_MIB_ID_DOT11_CURRENT_TX_POWER_LEVEL, |
|
&val, sizeof(val)); |
|
} |
|
|
|
static inline int wsm_set_beacon_wakeup_period(struct cw1200_common *priv, |
|
unsigned dtim_interval, |
|
unsigned listen_interval) |
|
{ |
|
struct { |
|
u8 numBeaconPeriods; |
|
u8 reserved; |
|
__le16 listenInterval; |
|
} val = { |
|
dtim_interval, 0, __cpu_to_le16(listen_interval) |
|
}; |
|
|
|
if (dtim_interval > 0xFF || listen_interval > 0xFFFF) |
|
return -EINVAL; |
|
else |
|
return wsm_write_mib(priv, WSM_MIB_ID_BEACON_WAKEUP_PERIOD, |
|
&val, sizeof(val)); |
|
} |
|
|
|
struct wsm_rcpi_rssi_threshold { |
|
u8 rssiRcpiMode; /* WSM_RCPI_RSSI_... */ |
|
u8 lowerThreshold; |
|
u8 upperThreshold; |
|
u8 rollingAverageCount; |
|
}; |
|
|
|
static inline int wsm_set_rcpi_rssi_threshold(struct cw1200_common *priv, |
|
struct wsm_rcpi_rssi_threshold *arg) |
|
{ |
|
return wsm_write_mib(priv, WSM_MIB_ID_RCPI_RSSI_THRESHOLD, arg, |
|
sizeof(*arg)); |
|
} |
|
|
|
struct wsm_mib_counters_table { |
|
__le32 plcp_errors; |
|
__le32 fcs_errors; |
|
__le32 tx_packets; |
|
__le32 rx_packets; |
|
__le32 rx_packet_errors; |
|
__le32 rx_decryption_failures; |
|
__le32 rx_mic_failures; |
|
__le32 rx_no_key_failures; |
|
__le32 tx_multicast_frames; |
|
__le32 tx_frames_success; |
|
__le32 tx_frame_failures; |
|
__le32 tx_frames_retried; |
|
__le32 tx_frames_multi_retried; |
|
__le32 rx_frame_duplicates; |
|
__le32 rts_success; |
|
__le32 rts_failures; |
|
__le32 ack_failures; |
|
__le32 rx_multicast_frames; |
|
__le32 rx_frames_success; |
|
__le32 rx_cmac_icv_errors; |
|
__le32 rx_cmac_replays; |
|
__le32 rx_mgmt_ccmp_replays; |
|
} __packed; |
|
|
|
static inline int wsm_get_counters_table(struct cw1200_common *priv, |
|
struct wsm_mib_counters_table *arg) |
|
{ |
|
return wsm_read_mib(priv, WSM_MIB_ID_COUNTERS_TABLE, |
|
arg, sizeof(*arg)); |
|
} |
|
|
|
static inline int wsm_get_station_id(struct cw1200_common *priv, u8 *mac) |
|
{ |
|
return wsm_read_mib(priv, WSM_MIB_ID_DOT11_STATION_ID, mac, ETH_ALEN); |
|
} |
|
|
|
struct wsm_rx_filter { |
|
bool promiscuous; |
|
bool bssid; |
|
bool fcs; |
|
bool probeResponder; |
|
}; |
|
|
|
static inline int wsm_set_rx_filter(struct cw1200_common *priv, |
|
const struct wsm_rx_filter *arg) |
|
{ |
|
__le32 val = 0; |
|
if (arg->promiscuous) |
|
val |= __cpu_to_le32(BIT(0)); |
|
if (arg->bssid) |
|
val |= __cpu_to_le32(BIT(1)); |
|
if (arg->fcs) |
|
val |= __cpu_to_le32(BIT(2)); |
|
if (arg->probeResponder) |
|
val |= __cpu_to_le32(BIT(3)); |
|
return wsm_write_mib(priv, WSM_MIB_ID_RX_FILTER, &val, sizeof(val)); |
|
} |
|
|
|
int wsm_set_probe_responder(struct cw1200_common *priv, bool enable); |
|
|
|
#define WSM_BEACON_FILTER_IE_HAS_CHANGED BIT(0) |
|
#define WSM_BEACON_FILTER_IE_NO_LONGER_PRESENT BIT(1) |
|
#define WSM_BEACON_FILTER_IE_HAS_APPEARED BIT(2) |
|
|
|
struct wsm_beacon_filter_table_entry { |
|
u8 ie_id; |
|
u8 flags; |
|
u8 oui[3]; |
|
u8 match_data[3]; |
|
} __packed; |
|
|
|
struct wsm_mib_beacon_filter_table { |
|
__le32 num; |
|
struct wsm_beacon_filter_table_entry entry[10]; |
|
} __packed; |
|
|
|
static inline int wsm_set_beacon_filter_table(struct cw1200_common *priv, |
|
struct wsm_mib_beacon_filter_table *ft) |
|
{ |
|
size_t size = __le32_to_cpu(ft->num) * |
|
sizeof(struct wsm_beacon_filter_table_entry) + |
|
sizeof(__le32); |
|
|
|
return wsm_write_mib(priv, WSM_MIB_ID_BEACON_FILTER_TABLE, ft, size); |
|
} |
|
|
|
#define WSM_BEACON_FILTER_ENABLE BIT(0) /* Enable/disable beacon filtering */ |
|
#define WSM_BEACON_FILTER_AUTO_ERP BIT(1) /* If 1 FW will handle ERP IE changes internally */ |
|
|
|
struct wsm_beacon_filter_control { |
|
int enabled; |
|
int bcn_count; |
|
}; |
|
|
|
static inline int wsm_beacon_filter_control(struct cw1200_common *priv, |
|
struct wsm_beacon_filter_control *arg) |
|
{ |
|
struct { |
|
__le32 enabled; |
|
__le32 bcn_count; |
|
} val; |
|
val.enabled = __cpu_to_le32(arg->enabled); |
|
val.bcn_count = __cpu_to_le32(arg->bcn_count); |
|
return wsm_write_mib(priv, WSM_MIB_ID_BEACON_FILTER_ENABLE, &val, |
|
sizeof(val)); |
|
} |
|
|
|
enum wsm_power_mode { |
|
wsm_power_mode_active = 0, |
|
wsm_power_mode_doze = 1, |
|
wsm_power_mode_quiescent = 2, |
|
}; |
|
|
|
struct wsm_operational_mode { |
|
enum wsm_power_mode power_mode; |
|
int disable_more_flag_usage; |
|
int perform_ant_diversity; |
|
}; |
|
|
|
static inline int wsm_set_operational_mode(struct cw1200_common *priv, |
|
const struct wsm_operational_mode *arg) |
|
{ |
|
u8 val = arg->power_mode; |
|
if (arg->disable_more_flag_usage) |
|
val |= BIT(4); |
|
if (arg->perform_ant_diversity) |
|
val |= BIT(5); |
|
return wsm_write_mib(priv, WSM_MIB_ID_OPERATIONAL_POWER_MODE, &val, |
|
sizeof(val)); |
|
} |
|
|
|
struct wsm_template_frame { |
|
u8 frame_type; |
|
u8 rate; |
|
struct sk_buff *skb; |
|
}; |
|
|
|
static inline int wsm_set_template_frame(struct cw1200_common *priv, |
|
struct wsm_template_frame *arg) |
|
{ |
|
int ret; |
|
u8 *p = skb_push(arg->skb, 4); |
|
p[0] = arg->frame_type; |
|
p[1] = arg->rate; |
|
((__le16 *)p)[1] = __cpu_to_le16(arg->skb->len - 4); |
|
ret = wsm_write_mib(priv, WSM_MIB_ID_TEMPLATE_FRAME, p, arg->skb->len); |
|
skb_pull(arg->skb, 4); |
|
return ret; |
|
} |
|
|
|
|
|
struct wsm_protected_mgmt_policy { |
|
bool protectedMgmtEnable; |
|
bool unprotectedMgmtFramesAllowed; |
|
bool encryptionForAuthFrame; |
|
}; |
|
|
|
static inline int wsm_set_protected_mgmt_policy(struct cw1200_common *priv, |
|
struct wsm_protected_mgmt_policy *arg) |
|
{ |
|
__le32 val = 0; |
|
int ret; |
|
if (arg->protectedMgmtEnable) |
|
val |= __cpu_to_le32(BIT(0)); |
|
if (arg->unprotectedMgmtFramesAllowed) |
|
val |= __cpu_to_le32(BIT(1)); |
|
if (arg->encryptionForAuthFrame) |
|
val |= __cpu_to_le32(BIT(2)); |
|
ret = wsm_write_mib(priv, WSM_MIB_ID_PROTECTED_MGMT_POLICY, |
|
&val, sizeof(val)); |
|
return ret; |
|
} |
|
|
|
struct wsm_mib_block_ack_policy { |
|
u8 tx_tid; |
|
u8 reserved1; |
|
u8 rx_tid; |
|
u8 reserved2; |
|
} __packed; |
|
|
|
static inline int wsm_set_block_ack_policy(struct cw1200_common *priv, |
|
u8 tx_tid_policy, |
|
u8 rx_tid_policy) |
|
{ |
|
struct wsm_mib_block_ack_policy val = { |
|
.tx_tid = tx_tid_policy, |
|
.rx_tid = rx_tid_policy, |
|
}; |
|
return wsm_write_mib(priv, WSM_MIB_ID_BLOCK_ACK_POLICY, &val, |
|
sizeof(val)); |
|
} |
|
|
|
struct wsm_mib_association_mode { |
|
u8 flags; /* WSM_ASSOCIATION_MODE_... */ |
|
u8 preamble; /* WSM_JOIN_PREAMBLE_... */ |
|
u8 greenfield; /* 1 for greenfield */ |
|
u8 mpdu_start_spacing; |
|
__le32 basic_rate_set; |
|
} __packed; |
|
|
|
static inline int wsm_set_association_mode(struct cw1200_common *priv, |
|
struct wsm_mib_association_mode *arg) |
|
{ |
|
return wsm_write_mib(priv, WSM_MIB_ID_SET_ASSOCIATION_MODE, arg, |
|
sizeof(*arg)); |
|
} |
|
|
|
#define WSM_TX_RATE_POLICY_FLAG_TERMINATE_WHEN_FINISHED BIT(2) |
|
#define WSM_TX_RATE_POLICY_FLAG_COUNT_INITIAL_TRANSMIT BIT(3) |
|
struct wsm_tx_rate_retry_policy { |
|
u8 index; |
|
u8 short_retries; |
|
u8 long_retries; |
|
/* BIT(2) - Terminate retries when Tx rate retry policy |
|
* finishes. |
|
* BIT(3) - Count initial frame transmission as part of |
|
* rate retry counting but not as a retry |
|
* attempt |
|
*/ |
|
u8 flags; |
|
u8 rate_recoveries; |
|
u8 reserved[3]; |
|
__le32 rate_count_indices[3]; |
|
} __packed; |
|
|
|
struct wsm_set_tx_rate_retry_policy { |
|
u8 num; |
|
u8 reserved[3]; |
|
struct wsm_tx_rate_retry_policy tbl[8]; |
|
} __packed; |
|
|
|
static inline int wsm_set_tx_rate_retry_policy(struct cw1200_common *priv, |
|
struct wsm_set_tx_rate_retry_policy *arg) |
|
{ |
|
size_t size = 4 + arg->num * sizeof(struct wsm_tx_rate_retry_policy); |
|
return wsm_write_mib(priv, WSM_MIB_ID_SET_TX_RATE_RETRY_POLICY, arg, |
|
size); |
|
} |
|
|
|
/* 4.32 SetEtherTypeDataFrameFilter */ |
|
struct wsm_ether_type_filter_hdr { |
|
u8 num; /* Up to WSM_MAX_FILTER_ELEMENTS */ |
|
u8 reserved[3]; |
|
} __packed; |
|
|
|
struct wsm_ether_type_filter { |
|
u8 action; /* WSM_FILTER_ACTION_XXX */ |
|
u8 reserved; |
|
__le16 type; /* Type of ethernet frame */ |
|
} __packed; |
|
|
|
static inline int wsm_set_ether_type_filter(struct cw1200_common *priv, |
|
struct wsm_ether_type_filter_hdr *arg) |
|
{ |
|
size_t size = sizeof(struct wsm_ether_type_filter_hdr) + |
|
arg->num * sizeof(struct wsm_ether_type_filter); |
|
return wsm_write_mib(priv, WSM_MIB_ID_SET_ETHERTYPE_DATAFRAME_FILTER, |
|
arg, size); |
|
} |
|
|
|
/* 4.33 SetUDPPortDataFrameFilter */ |
|
struct wsm_udp_port_filter_hdr { |
|
u8 num; /* Up to WSM_MAX_FILTER_ELEMENTS */ |
|
u8 reserved[3]; |
|
} __packed; |
|
|
|
struct wsm_udp_port_filter { |
|
u8 action; /* WSM_FILTER_ACTION_XXX */ |
|
u8 type; /* WSM_FILTER_PORT_TYPE_XXX */ |
|
__le16 port; /* Port number */ |
|
} __packed; |
|
|
|
static inline int wsm_set_udp_port_filter(struct cw1200_common *priv, |
|
struct wsm_udp_port_filter_hdr *arg) |
|
{ |
|
size_t size = sizeof(struct wsm_udp_port_filter_hdr) + |
|
arg->num * sizeof(struct wsm_udp_port_filter); |
|
return wsm_write_mib(priv, WSM_MIB_ID_SET_UDPPORT_DATAFRAME_FILTER, |
|
arg, size); |
|
} |
|
|
|
/* Undocumented MIBs: */ |
|
/* 4.35 P2PDeviceInfo */ |
|
#define D11_MAX_SSID_LEN (32) |
|
|
|
struct wsm_p2p_device_type { |
|
__le16 category_id; |
|
u8 oui[4]; |
|
__le16 subcategory_id; |
|
} __packed; |
|
|
|
struct wsm_p2p_device_info { |
|
struct wsm_p2p_device_type primaryDevice; |
|
u8 reserved1[3]; |
|
u8 devname_size; |
|
u8 local_devname[D11_MAX_SSID_LEN]; |
|
u8 reserved2[3]; |
|
u8 num_secdev_supported; |
|
struct wsm_p2p_device_type secdevs[]; |
|
} __packed; |
|
|
|
/* 4.36 SetWCDMABand - WO */ |
|
struct wsm_cdma_band { |
|
u8 wcdma_band; |
|
u8 reserved[3]; |
|
} __packed; |
|
|
|
/* 4.37 GroupTxSequenceCounter - RO */ |
|
struct wsm_group_tx_seq { |
|
__le32 bits_47_16; |
|
__le16 bits_15_00; |
|
__le16 reserved; |
|
} __packed; |
|
|
|
/* 4.39 SetHtProtection - WO */ |
|
#define WSM_DUAL_CTS_PROT_ENB (1 << 0) |
|
#define WSM_NON_GREENFIELD_STA_PRESENT (1 << 1) |
|
#define WSM_HT_PROT_MODE__NO_PROT (0 << 2) |
|
#define WSM_HT_PROT_MODE__NON_MEMBER (1 << 2) |
|
#define WSM_HT_PROT_MODE__20_MHZ (2 << 2) |
|
#define WSM_HT_PROT_MODE__NON_HT_MIXED (3 << 2) |
|
#define WSM_LSIG_TXOP_PROT_FULL (1 << 4) |
|
#define WSM_LARGE_L_LENGTH_PROT (1 << 5) |
|
|
|
struct wsm_ht_protection { |
|
__le32 flags; |
|
} __packed; |
|
|
|
/* 4.40 GPIO Command - R/W */ |
|
#define WSM_GPIO_COMMAND_SETUP 0 |
|
#define WSM_GPIO_COMMAND_READ 1 |
|
#define WSM_GPIO_COMMAND_WRITE 2 |
|
#define WSM_GPIO_COMMAND_RESET 3 |
|
#define WSM_GPIO_ALL_PINS 0xFF |
|
|
|
struct wsm_gpio_command { |
|
u8 command; |
|
u8 pin; |
|
__le16 config; |
|
} __packed; |
|
|
|
/* 4.41 TSFCounter - RO */ |
|
struct wsm_tsf_counter { |
|
__le64 tsf_counter; |
|
} __packed; |
|
|
|
/* 4.43 Keep alive period */ |
|
struct wsm_keep_alive_period { |
|
__le16 period; |
|
u8 reserved[2]; |
|
} __packed; |
|
|
|
static inline int wsm_keep_alive_period(struct cw1200_common *priv, |
|
int period) |
|
{ |
|
struct wsm_keep_alive_period arg = { |
|
.period = __cpu_to_le16(period), |
|
}; |
|
return wsm_write_mib(priv, WSM_MIB_ID_KEEP_ALIVE_PERIOD, |
|
&arg, sizeof(arg)); |
|
}; |
|
|
|
/* BSSID filtering */ |
|
struct wsm_set_bssid_filtering { |
|
u8 filter; |
|
u8 reserved[3]; |
|
} __packed; |
|
|
|
static inline int wsm_set_bssid_filtering(struct cw1200_common *priv, |
|
bool enabled) |
|
{ |
|
struct wsm_set_bssid_filtering arg = { |
|
.filter = !enabled, |
|
}; |
|
return wsm_write_mib(priv, WSM_MIB_ID_DISABLE_BSSID_FILTER, |
|
&arg, sizeof(arg)); |
|
} |
|
|
|
/* Multicast filtering - 4.5 */ |
|
struct wsm_mib_multicast_filter { |
|
__le32 enable; |
|
__le32 num_addrs; |
|
u8 macaddrs[WSM_MAX_GRP_ADDRTABLE_ENTRIES][ETH_ALEN]; |
|
} __packed; |
|
|
|
static inline int wsm_set_multicast_filter(struct cw1200_common *priv, |
|
struct wsm_mib_multicast_filter *fp) |
|
{ |
|
return wsm_write_mib(priv, WSM_MIB_ID_DOT11_GROUP_ADDRESSES_TABLE, |
|
fp, sizeof(*fp)); |
|
} |
|
|
|
/* ARP IPv4 filtering - 4.10 */ |
|
struct wsm_mib_arp_ipv4_filter { |
|
__le32 enable; |
|
__be32 ipv4addrs[WSM_MAX_ARP_IP_ADDRTABLE_ENTRIES]; |
|
} __packed; |
|
|
|
static inline int wsm_set_arp_ipv4_filter(struct cw1200_common *priv, |
|
struct wsm_mib_arp_ipv4_filter *fp) |
|
{ |
|
return wsm_write_mib(priv, WSM_MIB_ID_ARP_IP_ADDRESSES_TABLE, |
|
fp, sizeof(*fp)); |
|
} |
|
|
|
/* P2P Power Save Mode Info - 4.31 */ |
|
struct wsm_p2p_ps_modeinfo { |
|
u8 opp_ps_ct_window; |
|
u8 count; |
|
u8 reserved; |
|
u8 dtim_count; |
|
__le32 duration; |
|
__le32 interval; |
|
__le32 start_time; |
|
} __packed; |
|
|
|
static inline int wsm_set_p2p_ps_modeinfo(struct cw1200_common *priv, |
|
struct wsm_p2p_ps_modeinfo *mi) |
|
{ |
|
return wsm_write_mib(priv, WSM_MIB_ID_P2P_PS_MODE_INFO, |
|
mi, sizeof(*mi)); |
|
} |
|
|
|
static inline int wsm_get_p2p_ps_modeinfo(struct cw1200_common *priv, |
|
struct wsm_p2p_ps_modeinfo *mi) |
|
{ |
|
return wsm_read_mib(priv, WSM_MIB_ID_P2P_PS_MODE_INFO, |
|
mi, sizeof(*mi)); |
|
} |
|
|
|
/* UseMultiTxConfMessage */ |
|
|
|
static inline int wsm_use_multi_tx_conf(struct cw1200_common *priv, |
|
bool enabled) |
|
{ |
|
__le32 arg = enabled ? __cpu_to_le32(1) : 0; |
|
|
|
return wsm_write_mib(priv, WSM_MIB_USE_MULTI_TX_CONF, |
|
&arg, sizeof(arg)); |
|
} |
|
|
|
|
|
/* 4.26 SetUpasdInformation */ |
|
struct wsm_uapsd_info { |
|
__le16 uapsd_flags; |
|
__le16 min_auto_trigger_interval; |
|
__le16 max_auto_trigger_interval; |
|
__le16 auto_trigger_step; |
|
}; |
|
|
|
static inline int wsm_set_uapsd_info(struct cw1200_common *priv, |
|
struct wsm_uapsd_info *arg) |
|
{ |
|
return wsm_write_mib(priv, WSM_MIB_ID_SET_UAPSD_INFORMATION, |
|
arg, sizeof(*arg)); |
|
} |
|
|
|
/* 4.22 OverrideInternalTxRate */ |
|
struct wsm_override_internal_txrate { |
|
u8 internalTxRate; |
|
u8 nonErpInternalTxRate; |
|
u8 reserved[2]; |
|
} __packed; |
|
|
|
static inline int wsm_set_override_internal_txrate(struct cw1200_common *priv, |
|
struct wsm_override_internal_txrate *arg) |
|
{ |
|
return wsm_write_mib(priv, WSM_MIB_ID_OVERRIDE_INTERNAL_TX_RATE, |
|
arg, sizeof(*arg)); |
|
} |
|
|
|
/* ******************************************************************** */ |
|
/* WSM TX port control */ |
|
|
|
void wsm_lock_tx(struct cw1200_common *priv); |
|
void wsm_lock_tx_async(struct cw1200_common *priv); |
|
bool wsm_flush_tx(struct cw1200_common *priv); |
|
void wsm_unlock_tx(struct cw1200_common *priv); |
|
|
|
/* ******************************************************************** */ |
|
/* WSM / BH API */ |
|
|
|
int wsm_handle_exception(struct cw1200_common *priv, u8 *data, size_t len); |
|
int wsm_handle_rx(struct cw1200_common *priv, u16 id, struct wsm_hdr *wsm, |
|
struct sk_buff **skb_p); |
|
|
|
/* ******************************************************************** */ |
|
/* wsm_buf API */ |
|
|
|
struct wsm_buf { |
|
u8 *begin; |
|
u8 *data; |
|
u8 *end; |
|
}; |
|
|
|
void wsm_buf_init(struct wsm_buf *buf); |
|
void wsm_buf_deinit(struct wsm_buf *buf); |
|
|
|
/* ******************************************************************** */ |
|
/* wsm_cmd API */ |
|
|
|
struct wsm_cmd { |
|
spinlock_t lock; /* Protect structure from multiple access */ |
|
int done; |
|
u8 *ptr; |
|
size_t len; |
|
void *arg; |
|
int ret; |
|
u16 cmd; |
|
}; |
|
|
|
/* ******************************************************************** */ |
|
/* WSM TX buffer access */ |
|
|
|
int wsm_get_tx(struct cw1200_common *priv, u8 **data, |
|
size_t *tx_len, int *burst); |
|
void wsm_txed(struct cw1200_common *priv, u8 *data); |
|
|
|
/* ******************************************************************** */ |
|
/* Queue mapping: WSM <---> linux */ |
|
/* Linux: VO VI BE BK */ |
|
/* WSM: BE BK VI VO */ |
|
|
|
static inline u8 wsm_queue_id_to_linux(u8 queue_id) |
|
{ |
|
static const u8 queue_mapping[] = { |
|
2, 3, 1, 0 |
|
}; |
|
return queue_mapping[queue_id]; |
|
} |
|
|
|
static inline u8 wsm_queue_id_to_wsm(u8 queue_id) |
|
{ |
|
static const u8 queue_mapping[] = { |
|
3, 2, 0, 1 |
|
}; |
|
return queue_mapping[queue_id]; |
|
} |
|
|
|
#endif /* CW1200_HWIO_H_INCLUDED */
|
|
|