OSCL-LXR linux-6.0.1/​drivers/​net/​wireless/​st/​cw1200/​wsm.h	Source navigation Diff markup Identifier search General search
	Version: linux-6.0.1 spark-3.0.0 hadoop-3.2.0-src hadoop-3.3.0-src spark-2.4.7 linux-4.15.13 hadoop-2.7.4-src Revert   Change

 /* 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 <dmitry.tarnyagin@lockless.no>
  *
  * Based on CW1200 UMAC WSM API, which is
  * Copyright (C) ST-Ericsson SA 2010
  * Author: Stewart Mathers <stewart.mathers@stericsson.com>
  */
 
 #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 */

This page was automatically generated by the 2.1.0 LXR engine. The LXR team