| /****************************************************************************** |
| * |
| * Copyright(c) 2010 - 2014 Intel Corporation. All rights reserved. |
| * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH |
| * Copyright(c) 2015 - 2017 Intel Deutschland GmbH |
| * Copyright(c) 2018 Intel Corporation |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in |
| * the documentation and/or other materials provided with the |
| * distribution. |
| * * Neither the name Intel Corporation nor the names of its |
| * contributors may be used to endorse or promote products derived |
| * from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| *****************************************************************************/ |
| #ifndef SRC_CONNECTIVITY_WLAN_DRIVERS_THIRD_PARTY_INTEL_IWLWIFI_IWL_TM_INFC_H_ |
| #define SRC_CONNECTIVITY_WLAN_DRIVERS_THIRD_PARTY_INTEL_IWLWIFI_IWL_TM_INFC_H_ |
| |
| #include <linux/if_ether.h> |
| #include <linux/types.h> |
| |
| /* |
| * Testmode GNL family command. |
| * There is only one NL command, not to be |
| * confused with testmode commands |
| */ |
| enum iwl_tm_gnl_cmd_t { |
| IWL_TM_GNL_CMD_EXECUTE = 0, |
| IWL_TM_GNL_CMD_SUBSCRIBE_EVENTS, |
| }; |
| |
| /* uCode trace buffer */ |
| #define TRACE_BUFF_SIZE_MAX 0x200000 |
| #define TRACE_BUFF_SIZE_MIN 0x1000 |
| #define TRACE_BUFF_SIZE_DEF 0x20000 |
| |
| #define TM_CMD_BASE 0x100 |
| #define TM_CMD_NOTIF_BASE 0x200 |
| #define XVT_CMD_BASE 0x300 |
| #define XVT_CMD_NOTIF_BASE 0x400 |
| #define XVT_BUS_TESTER_BASE 0x500 |
| |
| /** |
| * signifies iwl_tm_mod_tx_request is set to infinite mode, |
| * when iwl_tm_mod_tx_request.times == IWL_XVT_TX_MODULATED_INFINITE |
| */ |
| #define IWL_XVT_TX_MODULATED_INFINITE (0) |
| |
| #define IWL_XVT_MAX_MAC_HEADER_LENGTH (36) |
| #define IWL_XVT_MAX_NUM_OF_FRAMES (32) |
| |
| /* |
| * Periphery registers absolute lower bound. This is used in order to |
| * differentiate registery access through HBUS_TARG_PRPH_.* and |
| * HBUS_TARG_MEM_* accesses. |
| */ |
| #define IWL_ABS_PRPH_START (0xA00000) |
| |
| /* User-Driver interface commands */ |
| enum { |
| IWL_TM_USER_CMD_HCMD = TM_CMD_BASE, |
| IWL_TM_USER_CMD_REG_ACCESS, |
| IWL_TM_USER_CMD_SRAM_WRITE, |
| IWL_TM_USER_CMD_SRAM_READ, |
| IWL_TM_USER_CMD_GET_DEVICE_INFO, |
| IWL_TM_USER_CMD_GET_DEVICE_STATUS, |
| IWL_TM_USER_CMD_BEGIN_TRACE, |
| IWL_TM_USER_CMD_END_TRACE, |
| IWL_TM_USER_CMD_TRACE_DUMP, |
| IWL_TM_USER_CMD_NOTIFICATIONS, |
| IWL_TM_USER_CMD_SWITCH_OP_MODE, |
| IWL_TM_USER_CMD_GET_SIL_STEP, |
| IWL_TM_USER_CMD_GET_DRIVER_BUILD_INFO, |
| IWL_TM_USER_CMD_GET_FW_INFO, |
| IWL_TM_USER_CMD_BUS_DATA_ACCESS, |
| IWL_TM_USER_CMD_GET_SIL_TYPE, |
| IWL_TM_USER_CMD_GET_RFID, |
| |
| IWL_TM_USER_CMD_NOTIF_UCODE_RX_PKT = TM_CMD_NOTIF_BASE, |
| IWL_TM_USER_CMD_NOTIF_DRIVER, |
| IWL_TM_USER_CMD_NOTIF_RX_HDR, |
| IWL_TM_USER_CMD_NOTIF_COMMIT_STATISTICS, |
| IWL_TM_USER_CMD_NOTIF_PHY_DB, |
| IWL_TM_USER_CMD_NOTIF_DTS_MEASUREMENTS, |
| IWL_TM_USER_CMD_NOTIF_MONITOR_DATA, |
| IWL_TM_USER_CMD_NOTIF_UCODE_MSGS_DATA, |
| IWL_TM_USER_CMD_NOTIF_APMG_PD, |
| IWL_TM_USER_CMD_NOTIF_RETRIEVE_MONITOR, |
| IWL_TM_USER_CMD_NOTIF_CRASH_DATA, |
| IWL_TM_USER_CMD_NOTIF_BFE, |
| IWL_TM_USER_CMD_NOTIF_LOC_MCSI, |
| IWL_TM_USER_CMD_NOTIF_LOC_RANGE, |
| IWL_TM_USER_CMD_NOTIF_IQ_CALIB, |
| IWL_TM_USER_CMD_NOTIF_CT_KILL, |
| }; |
| |
| /* |
| * xVT commands indeces start where common |
| * testmode commands indeces end |
| */ |
| enum { |
| IWL_XVT_CMD_START = XVT_CMD_BASE, |
| IWL_XVT_CMD_STOP, |
| IWL_XVT_CMD_CONTINUE_INIT, |
| IWL_XVT_CMD_GET_PHY_DB_ENTRY, |
| IWL_XVT_CMD_SET_CONFIG, |
| IWL_XVT_CMD_GET_CONFIG, |
| IWL_XVT_CMD_MOD_TX, |
| IWL_XVT_CMD_RX_HDRS_MODE, |
| IWL_XVT_CMD_ALLOC_DMA, |
| IWL_XVT_CMD_GET_DMA, |
| IWL_XVT_CMD_FREE_DMA, |
| IWL_XVT_CMD_GET_CHIP_ID, |
| IWL_XVT_CMD_APMG_PD_MODE, |
| IWL_XVT_CMD_GET_MAC_ADDR_INFO, |
| IWL_XVT_CMD_MOD_TX_STOP, |
| IWL_XVT_CMD_TX_QUEUE_CFG, |
| IWL_XVT_CMD_DRIVER_CMD, |
| |
| /* Driver notifications */ |
| IWL_XVT_CMD_SEND_REPLY_ALIVE = XVT_CMD_NOTIF_BASE, |
| IWL_XVT_CMD_SEND_RFKILL, |
| IWL_XVT_CMD_SEND_NIC_ERROR, |
| IWL_XVT_CMD_SEND_NIC_UMAC_ERROR, |
| IWL_XVT_CMD_SEND_MOD_TX_DONE, |
| IWL_XVT_CMD_ENHANCED_TX_DONE, |
| IWL_XVT_CMD_TX_CMD_RESP, |
| IWL_XVT_CMD_ECHO_NOTIF, |
| |
| /* Bus Tester Commands*/ |
| IWL_TM_USER_CMD_SV_BUS_CONFIG = XVT_BUS_TESTER_BASE, |
| IWL_TM_USER_CMD_SV_BUS_RESET, |
| IWL_TM_USER_CMD_SV_IO_TOGGLE, |
| IWL_TM_USER_CMD_SV_GET_STATUS, |
| IWL_TM_USER_CMD_SV_RD_WR_UINT8, |
| IWL_TM_USER_CMD_SV_RD_WR_UINT32, |
| IWL_TM_USER_CMD_SV_RD_WR_BUFFER, |
| }; |
| |
| /** |
| * User space - driver interface command. These commands will be sent as |
| * sub-commands through IWL_XVT_CMD_DRIVER_CMD. |
| */ |
| enum { |
| IWL_DRV_CMD_CONFIG_TX_QUEUE = 0, |
| IWL_DRV_CMD_SET_TX_PAYLOAD, |
| IWL_DRV_CMD_TX_START, |
| IWL_DRV_CMD_TX_STOP, |
| IWL_DRV_CMD_GET_RX_AGG_STATS, |
| IWL_DRV_CMD_CONFIG_RX_MPDU, |
| IWL_DRV_CMD_ECHO_NOTIF, |
| }; |
| |
| enum { |
| NOTIFICATIONS_DISABLE = 0, |
| NOTIFICATIONS_ENABLE = 1, |
| }; |
| |
| /** |
| * struct iwl_tm_cmd_request - Host command request |
| * @id: Command ID |
| * @want_resp: True value if response is required, else false (0) |
| * @len: Data length |
| * @data: For command in, casted to iwl_host_cmd |
| * rx packet when structure is used for command response. |
| */ |
| struct iwl_tm_cmd_request { |
| __u32 id; |
| __u32 want_resp; |
| __u32 len; |
| __u8 data[]; |
| } __packed __aligned(4); |
| |
| /** |
| * struct iwl_svt_sdio_enable - SV Tester SDIO bus enable command |
| * @enable: Function enable/disable 1/0 |
| */ |
| struct iwl_tm_sdio_io_toggle { |
| __u32 enable; |
| } __packed __aligned(4); |
| |
| /* Register operations - Operation type */ |
| enum { IWL_TM_REG_OP_READ = 0, IWL_TM_REG_OP_WRITE, IWL_TM_REG_OP_MAX }; |
| |
| /** |
| * struct iwl_tm_reg_op - Single register operation data |
| * @op_type: READ/WRITE |
| * @address: Register address |
| * @value: Write value, or read result |
| */ |
| struct iwl_tm_reg_op { |
| __u32 op_type; |
| __u32 address; |
| __u32 value; |
| } __packed __aligned(4); |
| |
| /** |
| * struct iwl_tm_regs_request - Register operation request data |
| * @num: number of operations in struct |
| * @reg_ops: Array of register operations |
| */ |
| struct iwl_tm_regs_request { |
| __u32 num; |
| struct iwl_tm_reg_op reg_ops[]; |
| } __packed __aligned(4); |
| |
| /** |
| * struct iwl_tm_trace_request - Data for trace begin requests |
| * @size: Requested size of trace buffer |
| * @addr: Resulting DMA address of trace buffer LSB |
| */ |
| struct iwl_tm_trace_request { |
| __u64 addr; |
| __u32 size; |
| } __packed __aligned(4); |
| |
| /** |
| * struct iwl_tm_sram_write_request |
| * @offest: Address offset |
| * @length: input data length |
| * @buffer: input data |
| */ |
| struct iwl_tm_sram_write_request { |
| __u32 offset; |
| __u32 len; |
| __u8 buffer[]; |
| } __packed __aligned(4); |
| |
| /** |
| * struct iwl_tm_sram_read_request |
| * @offest: Address offset |
| * @length: data length |
| */ |
| struct iwl_tm_sram_read_request { |
| __u32 offset; |
| __u32 length; |
| } __packed __aligned(4); |
| |
| /** |
| * struct iwl_tm_dev_info_req - Request data for get info request |
| * @read_sv: rather or not read sv_srop |
| */ |
| struct iwl_tm_dev_info_req { |
| __u32 read_sv; |
| } __packed __aligned(4); |
| |
| /** |
| * struct iwl_tm_dev_info - Result data for get info request |
| * @dev_id: |
| * @vendor_id: |
| * @silicon: |
| * @fw_ver: |
| * @driver_ver: |
| * @build_ver: |
| */ |
| struct iwl_tm_dev_info { |
| __u32 dev_id; |
| __u32 vendor_id; |
| __u32 silicon_step; |
| __u32 fw_ver; |
| __u32 build_ver; |
| __u8 driver_ver[]; |
| } __packed __aligned(4); |
| |
| /* |
| * struct iwl_tm_thrshld_md - tx packet metadata that crosses a thrshld |
| * |
| * @monitor_collec_wind: the size of the window to collect the logs |
| * @seq: packet sequence |
| * @pkt_start: start time of triggering pkt |
| * @pkt_end: end time of triggering pkt |
| * @msrmnt: the tx latency of the pkt |
| * @tid: tid of the pkt |
| * @mode: recording mode (internal buffer or continuous recording). |
| */ |
| struct iwl_tm_thrshld_md { |
| __u16 monitor_collec_wind; |
| __u16 seq; |
| __u32 pkt_start; |
| __u32 pkt_end; |
| __u32 msrmnt; |
| __u16 tid; |
| __u8 mode; |
| } __packed __aligned(4); |
| |
| #define MAX_OP_MODE_LENGTH 16 |
| /** |
| * struct iwl_switch_op_mode - switch op_mode |
| * @new_op_mode: size of data |
| */ |
| struct iwl_switch_op_mode { |
| __u8 new_op_mode[MAX_OP_MODE_LENGTH]; |
| } __packed __aligned(4); |
| |
| /** |
| * struct iwl_sil_step - holds the silicon step |
| * @silicon_step: the device silicon step |
| */ |
| struct iwl_sil_step { |
| __u32 silicon_step; |
| } __packed __aligned(4); |
| |
| /** |
| * struct iwl_sil_type - holds the silicon type |
| * @silicon_type: the device silicon type |
| */ |
| struct iwl_tm_sil_type { |
| __u32 silicon_type; |
| } __packed __aligned(4); |
| |
| /** |
| * struct iwl_tm_rfid - Currently connected RF device info |
| * @flavor: - RFID flavor |
| * @dash: - RFID dash |
| * @step: - RFID step |
| * @type: - RFID type |
| */ |
| struct iwl_tm_rfid { |
| __u32 flavor; |
| __u32 dash; |
| __u32 step; |
| __u32 type; |
| } __packed __aligned(4); |
| |
| #define MAX_DRIVER_VERSION_LEN 256 |
| #define MAX_BUILD_DATE_LEN 32 |
| /** |
| * struct iwl_tm_build_info - Result data for get driver build info request |
| * @driver_version: driver version in tree:branch:build:sha1 |
| * @branch_time: branch creation time |
| * @build_time: build time |
| */ |
| struct iwl_tm_build_info { |
| __u8 driver_version[MAX_DRIVER_VERSION_LEN]; |
| __u8 branch_time[MAX_BUILD_DATE_LEN]; |
| __u8 build_time[MAX_BUILD_DATE_LEN]; |
| } __packed __aligned(4); |
| |
| /** |
| * struct iwl_tm_get_fw_info - get the FW info |
| * @fw_major_ver: the fw major version |
| * @fw_minor_ver: the fw minor version |
| * @fw_capa_flags: the fw capabilities flags |
| * @fw_capa_api_len: the fw capabilities api length in data |
| * @fw_capa_len: the fw capabilities length in data |
| * @data: fw_capa_api and fa_capa data (length defined by fw_capa_api_len |
| * + fw_capa_len) |
| */ |
| struct iwl_tm_get_fw_info { |
| __u32 fw_major_ver; |
| __u32 fw_minor_ver; |
| __u32 fw_capa_flags; |
| __u32 fw_capa_api_len; |
| __u32 fw_capa_len; |
| __u8 data[]; |
| } __packed __aligned(4); |
| |
| /* xVT definitions */ |
| |
| #define IWL_XVT_RFKILL_OFF 0 |
| #define IWL_XVT_RFKILL_ON 1 |
| |
| struct iwl_xvt_user_calib_ctrl { |
| __u32 flow_trigger; |
| __u32 event_trigger; |
| } __packed __aligned(4); |
| |
| #define IWL_USER_FW_IMAGE_IDX_INIT 0 |
| #define IWL_USER_FW_IMAGE_IDX_REGULAR 1 |
| #define IWL_USER_FW_IMAGE_IDX_WOWLAN 2 |
| #define IWL_USER_FW_IMAGE_IDX_TYPE_MAX 3 |
| |
| /** |
| * iwl_xvt_sw_cfg_request - Data for set SW stack configuration request |
| * @load_mask: bit[0] = Init FW |
| * bit[1] = Runtime FW |
| * @cfg_mask: Mask for which calibrations to regard |
| * @phy_config: PHY_CONFIGURATION command paramter |
| * Used only for "Get SW CFG" |
| * @get_calib_type: Used only in "Get SW CFG" |
| * 0: Get FW original calib ctrl |
| * 1: Get actual calib ctrl |
| * @calib_ctrl: Calibration control for each FW |
| */ |
| enum { IWL_XVT_GET_CALIB_TYPE_DEF = 0, IWL_XVT_GET_CALIB_TYPE_RUNTIME }; |
| |
| struct iwl_xvt_sw_cfg_request { |
| __u32 load_mask; |
| __u32 cfg_mask; |
| __u32 phy_config; |
| __u32 get_calib_type; |
| __u32 dbg_flags; |
| struct iwl_xvt_user_calib_ctrl calib_ctrl[IWL_UCODE_TYPE_MAX]; |
| } __packed __aligned(4); |
| |
| /** |
| * iwl_xvt_sw_cfg_request - Data for set SW stack configuration request |
| * @type: Type of DB section |
| * @chg_id: Channel Group ID, relevant only when |
| * type is CHG PAPD or CHG TXP calibrations |
| * @size: Size of result data, in bytes |
| * @data: Result entry data |
| */ |
| struct iwl_xvt_phy_db_request { |
| __u32 type; |
| __u32 chg_id; |
| __u32 size; |
| __u8 data[]; |
| } __packed __aligned(4); |
| |
| #define IWL_TM_STATION_COUNT 16 |
| |
| /** |
| * struct iwl_tm_tx_request - Data transmission request |
| * @times: Number of times to transmit the data. |
| * @delay_us: Delay between frames |
| * @pa_detect_en: Flag. When True, enable PA detector |
| * @trigger_led: Flag. When true, light led when transmitting |
| * @len: Size of data buffer |
| * @rate_flags: Tx Configuration rate flags |
| * @no_ack: Flag. When true, FW will not send ack |
| * @sta_id: Station ID |
| * @data: Data to transmit |
| */ |
| struct iwl_tm_mod_tx_request { |
| __u32 times; |
| __u32 delay_us; |
| __u32 pa_detect_en; |
| __u32 trigger_led; |
| __u32 len; |
| __u32 rate_flags; |
| __u32 no_ack; |
| __u8 sta_id; |
| __u8 data[]; |
| } __packed __aligned(4); |
| |
| /** |
| * struct iwl_xvt_tx_mod_task_data - Data for modulated tx task handler |
| * @lmac_id: lmac index |
| * @xvt: pointer to the xvt op mode |
| * @tx_req: pointer to data of transmission request |
| */ |
| struct iwl_xvt_tx_mod_task_data { |
| __u32 lmac_id; |
| struct iwl_xvt* xvt; |
| struct iwl_tm_mod_tx_request tx_req; |
| } __packed __aligned(4); |
| |
| /** |
| * error status for status parameter in struct iwl_xvt_tx_mod_done |
| */ |
| enum { |
| XVT_TX_DRIVER_SUCCESSFUL = 0, |
| XVT_TX_DRIVER_QUEUE_FULL, |
| XVT_TX_DRIVER_TIMEOUT, |
| XVT_TX_DRIVER_ABORTED |
| }; |
| |
| /** |
| * struct iwl_xvt_tx_mod_done - Notification data for modulated tx |
| * @num_of_packets: number of sent packets |
| * @status: tx task handler error status |
| * @lmac_id: lmac index |
| */ |
| struct iwl_xvt_tx_mod_done { |
| __u64 num_of_packets; |
| __u32 status; |
| __u32 lmac_id; |
| } __packed __aligned(4); |
| |
| /** |
| * struct iwl_xvt_tx_mod_stop - input for stop modulated tx |
| * @lmac_id: which lmac id to stop |
| */ |
| struct iwl_xvt_tx_mod_stop { |
| __u32 lmac_id; |
| } __packed __aligned(4); |
| |
| /** |
| * struct iwl_xvt_rx_hdrs_mode_request - Start/Stop gathering headers info. |
| * @mode: 0 - stop |
| * 1 - start |
| */ |
| struct iwl_xvt_rx_hdrs_mode_request { |
| __u32 mode; |
| } __packed __aligned(4); |
| |
| /** |
| * struct iwl_xvt_apmg_pd_mode_request - Start/Stop gathering apmg_pd info. |
| * @mode: 0 - stop |
| * 1 - start |
| */ |
| struct iwl_xvt_apmg_pd_mode_request { |
| __u32 mode; |
| } __packed __aligned(4); |
| |
| /** |
| * struct iwl_xvt_alloc_dma - Data for alloc dma requests |
| * @addr: Resulting DMA address of trace buffer LSB |
| * @size: Requested size of dma buffer |
| */ |
| struct iwl_xvt_alloc_dma { |
| __u64 addr; |
| __u32 size; |
| } __packed __aligned(4); |
| |
| /** |
| * struct iwl_xvt_alloc_dma - Data for alloc dma requests |
| * @size: size of data |
| * @data: Data to transmit |
| */ |
| struct iwl_xvt_get_dma { |
| __u32 size; |
| __u8 data[]; |
| } __packed __aligned(4); |
| |
| /** |
| * struct iwl_xvt_chip_id - get the chip id from SCU |
| * @registers: an array of registers to hold the chip id data |
| */ |
| struct iwl_xvt_chip_id { |
| __u32 registers[3]; |
| } __packed __aligned(4); |
| |
| /** |
| * struct iwl_tm_crash_data - Notifications containing crash data |
| * @data_type: type of the data |
| * @size: data size |
| * @data: data |
| */ |
| struct iwl_tm_crash_data { |
| __u32 size; |
| __u8 data[]; |
| } __packed __aligned(4); |
| |
| /** |
| * struct iwl_xvt_curr_mac_addr_info - Current mac address data |
| * @curr_mac_addr: the current mac address |
| */ |
| struct iwl_xvt_mac_addr_info { |
| __u8 mac_addr[ETH_ALEN]; |
| } __packed __aligned(4); |
| |
| enum { |
| TX_QUEUE_CFG_REMOVE, |
| TX_QUEUE_CFG_ADD, |
| }; |
| |
| /** |
| * iwl_xvt_tx_queue_cfg - add/remove tx queue |
| * @ sta_id: station ID associated with queue |
| * @ flags: 0 - remove queue, 1 - add queue |
| */ |
| struct iwl_xvt_tx_queue_cfg { |
| __u8 sta_id; |
| __u8 operation; |
| } __packed __aligned(4); |
| |
| /** |
| * iwl_xvt_driver_command_req - wrapper for general driver command that are sent |
| * by IWL_XVT_CMD_DRIVER_CMD |
| * @ command_id: sub comamnd ID |
| * @ max_out_length: max size in bytes of the sub command's expected response |
| * @ input_data: place holder for the sub command's input structure |
| */ |
| struct iwl_xvt_driver_command_req { |
| __u32 command_id; |
| __u32 max_out_length; |
| __u8 input_data[0]; |
| } __packed __aligned(4); |
| |
| /** |
| * iwl_xvt_driver_command_resp - response of IWL_XVT_CMD_DRIVER_CMD |
| * @ command_id: sub command ID |
| * @ length: resp_data length in bytes |
| * @ resp_data: place holder for the sub command's rseponse data |
| */ |
| struct iwl_xvt_driver_command_resp { |
| __u32 command_id; |
| __u32 length; |
| __u8 resp_data[0]; |
| } __packed __aligned(4); |
| |
| /** |
| * iwl_xvt_txq_config - add/remove tx queue. IWL_DRV_CMD_CONFIG_TX_QUEUE input. |
| * @sta_id: station id |
| * @tid: TID |
| * @scd_queue: scheduler queue to configure |
| * @action: 1 queue enable, 0 queue disable, 2 change txq's tid owner |
| * Value is one of &enum iwl_scd_cfg_actions options |
| * @aggregate: 1 aggregated queue, 0 otherwise |
| * @tx_fifo: &enum iwl_mvm_tx_fifo |
| * @window: BA window size |
| * @reserved: reserved |
| * @ssn: SSN for the BA agreement |
| * @flags: flags for iwl_tx_queue_cfg_cmd. see &enum iwl_tx_queue_cfg_actions |
| * @reserved2: reserved |
| * @queue_size: size of configured queue |
| */ |
| struct iwl_xvt_txq_config { |
| uint8_t sta_id; |
| uint8_t tid; |
| uint8_t scd_queue; |
| uint8_t action; |
| uint8_t aggregate; |
| uint8_t tx_fifo; |
| uint8_t window; |
| uint8_t reserved; |
| uint16_t ssn; |
| uint16_t flags; |
| uint16_t reserved2; |
| int queue_size; |
| } __packed __aligned(4); |
| |
| /** |
| * iwl_xvt_txq_config_resp - response from IWL_DRV_CMD_CONFIG_TX_QUEUE |
| * @sta_id: taken from command |
| * @tid: taken from command |
| * @scd_queue: queue number assigned to this RA -TID |
| * @reserved: for alignment |
| */ |
| struct iwl_xvt_txq_config_resp { |
| uint8_t sta_id; |
| uint8_t tid; |
| uint8_t scd_queue; |
| uint8_t reserved; |
| } __packed __aligned(4); |
| |
| /** |
| * struct iwl_xvt_set_tx_payload - input for TX payload configuration |
| * @index: payload's index in 'payloads' array in struct iwl_xvt |
| * @length: payload length in bytes |
| * @payload: buffer containing payload |
| */ |
| struct iwl_xvt_set_tx_payload { |
| uint16_t index; |
| uint16_t length; |
| uint8_t payload[]; |
| } __packed __aligned(4); |
| |
| /** |
| * struct tx_cmd_commom_data - Data shared between all queues for TX |
| * command configuration |
| * @rate_flags: Tx Configuration rate flags |
| * @tx_flags: TX flags configuration |
| * @initial_rate_index: Start index in TLC table |
| * @rts_retry_limit: Max retry for RTS transmit |
| * @data_retry_limit: Max retry for data transmit |
| * @fragment_size: 0 - no fragnentation else - max fragment size |
| * @frag_num: Array of fragments numbers |
| */ |
| struct tx_cmd_commom_data { |
| uint32_t rate_flags; |
| uint32_t tx_flags; |
| uint8_t initial_rate_index; |
| uint8_t rts_retry_limit; |
| uint8_t data_retry_limit; |
| uint8_t fragment_size; |
| uint8_t frag_num[32]; |
| } __packed __aligned(4); |
| |
| /** |
| * struct tx_cmd_frame - frame specific transmission data |
| * @times: Number of subsequent times to transmit tx command to queue |
| * @sta_id: Station index |
| * @queue: Transmission queue |
| * @tid_tspec: TID tspec |
| * @sec_ctl: security control |
| * @payload_index: payload buffer index in 'payloads' array in struct iwl_xvt |
| * @key: security key |
| * @header: MAC header |
| */ |
| struct tx_cmd_frame_data { |
| uint16_t times; |
| uint8_t sta_id; |
| uint8_t queue; |
| uint8_t tid_tspec; |
| uint8_t sec_ctl; |
| uint8_t payload_index; |
| uint8_t reserved; |
| uint8_t key[16]; |
| uint8_t header[IWL_XVT_MAX_MAC_HEADER_LENGTH]; |
| } __packed __aligned(4); |
| |
| /** |
| * struct iwl_xvt_tx_start - Data for transmission. IWL_DRV_CMD_TX_START input. |
| * @num_of_cycles: Number of times to go over frames_data. When set to zero - |
| * infinite transmit (max amount is ULLONG_MAX) - go over frames_data and sent |
| * tx until stop command is received. |
| * @num_of_different_frames: actual number of entries in frames_data |
| * @send_tx_resp: Whether to send FW's tx response to user |
| * @reserved1: for alignment |
| * @reserved2: for alignment |
| * @tx_data: Tx command configuration shared data |
| * @frames_data: array of specific frame data for each queue |
| */ |
| struct iwl_xvt_tx_start { |
| uint16_t num_of_cycles; |
| uint16_t num_of_different_frames; |
| uint8_t send_tx_resp; |
| uint8_t reserved1; |
| uint16_t reserved2; |
| struct tx_cmd_commom_data tx_data; |
| struct tx_cmd_frame_data frames_data[IWL_XVT_MAX_NUM_OF_FRAMES]; |
| } __packed __aligned(4); |
| |
| /** |
| * struct iwl_xvt_enhanced_tx_data - Data for enhanced TX task |
| * @xvt: pointer to the xvt op mode |
| * @tx_start_data: IWL_DRV_CMD_TX_START command's input |
| */ |
| struct iwl_xvt_enhanced_tx_data { |
| struct iwl_xvt* xvt; |
| struct iwl_xvt_tx_start tx_start_data; |
| } __packed __aligned(4); |
| |
| /** |
| * struct iwl_xvt_post_tx_data - transmission data per queue |
| * @num_of_packets: number of sent packets |
| * @queue: queue packets were sent on |
| */ |
| struct iwl_xvt_post_tx_data { |
| uint64_t num_of_packets; |
| uint16_t queue; |
| uint16_t reserved; |
| } __packed __aligned(4); |
| |
| /** |
| * struct iwl_xvt_tx_done - Notification data for sent tx |
| * @status: tx task handler error status |
| * @num_of_queues: total number of queues tx was sent from. Equals to number of |
| * entries in tx_data |
| * @tx_data: data of sent frames for each queue |
| */ |
| struct iwl_xvt_tx_done { |
| uint32_t status; |
| uint32_t num_of_queues; |
| struct iwl_xvt_post_tx_data tx_data[]; |
| } __packed __aligned(4); |
| |
| /* |
| * struct iwl_xvt_get_rx_agg_stats - get rx aggregation statistics |
| * @sta_id: station id of relevant ba |
| * @tid: tid of relevant ba |
| * @reserved: reserved |
| */ |
| struct iwl_xvt_get_rx_agg_stats { |
| uint8_t sta_id; |
| uint8_t tid; |
| uint16_t reserved; |
| } __packed __aligned(4); |
| |
| /* |
| * struct iwl_xvt_get_rx_agg_stats_resp - rx aggregation statistics response |
| * @dropped: number of frames dropped (e.g. too old) |
| * @released: total number of frames released (either in-order or |
| * out of order (after passing the reorder buffer) |
| * @skipped: number of frames skipped the reorder buffer (in-order) |
| * @reordered: number of frames gone through the reorder buffer (unordered) |
| */ |
| struct iwl_xvt_get_rx_agg_stats_resp { |
| uint32_t dropped; |
| uint32_t released; |
| uint32_t skipped; |
| uint32_t reordered; |
| } __packed __aligned(4); |
| |
| /* struct iwl_xvt_config_rx_mpdu - Whether to send RX MPDU notifications to user |
| * @enable: 0 - disable. don't send rx mpdu to user 1 - send rx mpdu to user. |
| * @reserved: reserved |
| */ |
| struct iwl_xvt_config_rx_mpdu_req { |
| uint8_t enable; |
| uint8_t reserved[3]; |
| } __packed __aligned(4); |
| |
| #endif // SRC_CONNECTIVITY_WLAN_DRIVERS_THIRD_PARTY_INTEL_IWLWIFI_IWL_TM_INFC_H_ |