| 1 |
/* SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause */ |
| 2 |
/* |
| 3 |
* Copyright (C) 2005-2014, 2018-2024 Intel Corporation |
| 4 |
* Copyright (C) 2013-2015 Intel Mobile Communications GmbH |
| 5 |
* Copyright (C) 2016 Intel Deutschland GmbH |
| 6 |
*/ |
| 7 |
#ifndef __iwl_fw_img_h__ |
| 8 |
#define __iwl_fw_img_h__ |
| 9 |
#include <linux/types.h> |
| 10 |
|
| 11 |
#include "api/dbg-tlv.h" |
| 12 |
|
| 13 |
#include "file.h" |
| 14 |
#include "error-dump.h" |
| 15 |
|
| 16 |
/** |
| 17 |
* enum iwl_ucode_type - type of ucode |
| 18 |
* |
| 19 |
* @IWL_UCODE_REGULAR: Normal runtime ucode |
| 20 |
* @IWL_UCODE_INIT: Initial ucode |
| 21 |
* @IWL_UCODE_WOWLAN: Wake on Wireless enabled ucode |
| 22 |
* @IWL_UCODE_REGULAR_USNIFFER: Normal runtime ucode when using usniffer image |
| 23 |
* @IWL_UCODE_TYPE_MAX: (internal value) |
| 24 |
*/ |
| 25 |
enum iwl_ucode_type { |
| 26 |
IWL_UCODE_REGULAR, |
| 27 |
IWL_UCODE_INIT, |
| 28 |
IWL_UCODE_WOWLAN, |
| 29 |
IWL_UCODE_REGULAR_USNIFFER, |
| 30 |
IWL_UCODE_TYPE_MAX, |
| 31 |
}; |
| 32 |
|
| 33 |
/* |
| 34 |
* enumeration of ucode section. |
| 35 |
* This enumeration is used directly for older firmware (before 16.0). |
| 36 |
* For new firmware, there can be up to 4 sections (see below) but the |
| 37 |
* first one packaged into the firmware file is the DATA section and |
| 38 |
* some debugging code accesses that. |
| 39 |
*/ |
| 40 |
enum iwl_ucode_sec { |
| 41 |
IWL_UCODE_SECTION_DATA, |
| 42 |
IWL_UCODE_SECTION_INST, |
| 43 |
}; |
| 44 |
|
| 45 |
struct iwl_ucode_capabilities { |
| 46 |
u32 max_probe_length; |
| 47 |
u32 n_scan_channels; |
| 48 |
u32 standard_phy_calibration_size; |
| 49 |
u32 flags; |
| 50 |
u32 error_log_addr; |
| 51 |
u32 error_log_size; |
| 52 |
u32 num_stations; |
| 53 |
u32 num_links; |
| 54 |
u32 num_beacons; |
| 55 |
DECLARE_BITMAP(_api, NUM_IWL_UCODE_TLV_API); |
| 56 |
DECLARE_BITMAP(_capa, NUM_IWL_UCODE_TLV_CAPA); |
| 57 |
|
| 58 |
const struct iwl_fw_cmd_version *cmd_versions; |
| 59 |
u32 n_cmd_versions; |
| 60 |
}; |
| 61 |
|
| 62 |
static inline bool |
| 63 |
fw_has_api(const struct iwl_ucode_capabilities *capabilities, |
| 64 |
iwl_ucode_tlv_api_t api) |
| 65 |
{ |
| 66 |
return test_bit((__force long)api, capabilities->_api); |
| 67 |
} |
| 68 |
|
| 69 |
static inline bool |
| 70 |
fw_has_capa(const struct iwl_ucode_capabilities *capabilities, |
| 71 |
iwl_ucode_tlv_capa_t capa) |
| 72 |
{ |
| 73 |
return test_bit((__force long)capa, capabilities->_capa); |
| 74 |
} |
| 75 |
|
| 76 |
/* one for each uCode image (inst/data, init/runtime/wowlan) */ |
| 77 |
struct fw_desc { |
| 78 |
const void *data; /* vmalloc'ed data */ |
| 79 |
u32 len; /* size in bytes */ |
| 80 |
u32 offset; /* offset in the device */ |
| 81 |
}; |
| 82 |
|
| 83 |
struct fw_img { |
| 84 |
struct fw_desc *sec; |
| 85 |
int num_sec; |
| 86 |
bool is_dual_cpus; |
| 87 |
u32 paging_mem_size; |
| 88 |
}; |
| 89 |
|
| 90 |
/* |
| 91 |
* Block paging calculations |
| 92 |
*/ |
| 93 |
#define PAGE_2_EXP_SIZE 12 /* 4K == 2^12 */ |
| 94 |
#define FW_PAGING_SIZE BIT(PAGE_2_EXP_SIZE) /* page size is 4KB */ |
| 95 |
#define PAGE_PER_GROUP_2_EXP_SIZE 3 |
| 96 |
/* 8 pages per group */ |
| 97 |
#define NUM_OF_PAGE_PER_GROUP BIT(PAGE_PER_GROUP_2_EXP_SIZE) |
| 98 |
/* don't change, support only 32KB size */ |
| 99 |
#define PAGING_BLOCK_SIZE (NUM_OF_PAGE_PER_GROUP * FW_PAGING_SIZE) |
| 100 |
/* 32K == 2^15 */ |
| 101 |
#define BLOCK_2_EXP_SIZE (PAGE_2_EXP_SIZE + PAGE_PER_GROUP_2_EXP_SIZE) |
| 102 |
|
| 103 |
/* |
| 104 |
* Image paging calculations |
| 105 |
*/ |
| 106 |
#define BLOCK_PER_IMAGE_2_EXP_SIZE 5 |
| 107 |
/* 2^5 == 32 blocks per image */ |
| 108 |
#define NUM_OF_BLOCK_PER_IMAGE BIT(BLOCK_PER_IMAGE_2_EXP_SIZE) |
| 109 |
/* maximum image size 1024KB */ |
| 110 |
#define MAX_PAGING_IMAGE_SIZE (NUM_OF_BLOCK_PER_IMAGE * PAGING_BLOCK_SIZE) |
| 111 |
|
| 112 |
/* Virtual address signature */ |
| 113 |
#define PAGING_ADDR_SIG 0xAA000000 |
| 114 |
|
| 115 |
#define PAGING_CMD_IS_SECURED BIT(9) |
| 116 |
#define PAGING_CMD_IS_ENABLED BIT(8) |
| 117 |
#define PAGING_CMD_NUM_OF_PAGES_IN_LAST_GRP_POS 0 |
| 118 |
#define PAGING_TLV_SECURE_MASK 1 |
| 119 |
|
| 120 |
/* FW MSB Mask for regions/cache_control */ |
| 121 |
#define FW_ADDR_CACHE_CONTROL 0xC0000000UL |
| 122 |
|
| 123 |
/** |
| 124 |
* struct iwl_fw_paging - FW paging descriptor |
| 125 |
* @fw_paging_phys: page phy pointer |
| 126 |
* @fw_paging_block: pointer to the allocated block |
| 127 |
* @fw_paging_size: page size |
| 128 |
* @fw_offs: offset in the device |
| 129 |
*/ |
| 130 |
struct iwl_fw_paging { |
| 131 |
dma_addr_t fw_paging_phys; |
| 132 |
struct page *fw_paging_block; |
| 133 |
u32 fw_paging_size; |
| 134 |
u32 fw_offs; |
| 135 |
}; |
| 136 |
|
| 137 |
/** |
| 138 |
* enum iwl_fw_type - iwlwifi firmware type |
| 139 |
* @IWL_FW_DVM: DVM firmware |
| 140 |
* @IWL_FW_MVM: MVM firmware |
| 141 |
*/ |
| 142 |
enum iwl_fw_type { |
| 143 |
IWL_FW_DVM, |
| 144 |
IWL_FW_MVM, |
| 145 |
}; |
| 146 |
|
| 147 |
/** |
| 148 |
* struct iwl_fw_dbg - debug data |
| 149 |
* |
| 150 |
* @dest_tlv: points to debug destination TLV (typically SRAM or DRAM) |
| 151 |
* @n_dest_reg: num of reg_ops in dest_tlv |
| 152 |
* @conf_tlv: array of pointers to configuration HCMDs |
| 153 |
* @trigger_tlv: array of pointers to triggers TLVs |
| 154 |
* @trigger_tlv_len: lengths of the @dbg_trigger_tlv entries |
| 155 |
* @mem_tlv: Runtime addresses to dump |
| 156 |
* @n_mem_tlv: number of runtime addresses |
| 157 |
* @dump_mask: bitmask of dump regions |
| 158 |
*/ |
| 159 |
struct iwl_fw_dbg { |
| 160 |
struct iwl_fw_dbg_dest_tlv_v1 *dest_tlv; |
| 161 |
u8 n_dest_reg; |
| 162 |
struct iwl_fw_dbg_conf_tlv *conf_tlv[FW_DBG_CONF_MAX]; |
| 163 |
struct iwl_fw_dbg_trigger_tlv *trigger_tlv[FW_DBG_TRIGGER_MAX]; |
| 164 |
size_t trigger_tlv_len[FW_DBG_TRIGGER_MAX]; |
| 165 |
struct iwl_fw_dbg_mem_seg_tlv *mem_tlv; |
| 166 |
size_t n_mem_tlv; |
| 167 |
u32 dump_mask; |
| 168 |
}; |
| 169 |
|
| 170 |
struct iwl_dump_exclude { |
| 171 |
u32 addr, size; |
| 172 |
}; |
| 173 |
|
| 174 |
/** |
| 175 |
* struct iwl_fw - variables associated with the firmware |
| 176 |
* |
| 177 |
* @ucode_ver: ucode version from the ucode file |
| 178 |
* @fw_version: firmware version string |
| 179 |
* @img: ucode image like ucode_rt, ucode_init, ucode_wowlan. |
| 180 |
* @iml_len: length of the image loader image |
| 181 |
* @iml: image loader fw image |
| 182 |
* @ucode_capa: capabilities parsed from the ucode file. |
| 183 |
* @enhance_sensitivity_table: device can do enhanced sensitivity. |
| 184 |
* @init_evtlog_ptr: event log offset for init ucode. |
| 185 |
* @init_evtlog_size: event log size for init ucode. |
| 186 |
* @init_errlog_ptr: error log offset for init ucode. |
| 187 |
* @inst_evtlog_ptr: event log offset for runtime ucode. |
| 188 |
* @inst_evtlog_size: event log size for runtime ucode. |
| 189 |
* @inst_errlog_ptr: error log offset for runtime ucode. |
| 190 |
* @type: firmware type (&enum iwl_fw_type) |
| 191 |
* @human_readable: human readable version |
| 192 |
* we get the ALIVE from the uCode |
| 193 |
* @phy_integration_ver: PHY integration version string |
| 194 |
* @phy_integration_ver_len: length of @phy_integration_ver |
| 195 |
* @dump_excl: image dump exclusion areas for RT image |
| 196 |
* @dump_excl_wowlan: image dump exclusion areas for WoWLAN image |
| 197 |
* @pnvm_data: PNVM data embedded in the .ucode file, if any |
| 198 |
* @pnvm_size: size of the embedded PNVM data |
| 199 |
* @dbg: debug data, see &struct iwl_fw_dbg |
| 200 |
* @default_calib: default calibration data |
| 201 |
* @phy_config: PHY configuration flags |
| 202 |
* @valid_rx_ant: valid RX antenna bitmap |
| 203 |
* @valid_tx_ant: valid TX antenna bitmap |
| 204 |
*/ |
| 205 |
struct iwl_fw { |
| 206 |
u32 ucode_ver; |
| 207 |
|
| 208 |
char fw_version[128]; |
| 209 |
|
| 210 |
/* ucode images */ |
| 211 |
struct fw_img img[IWL_UCODE_TYPE_MAX]; |
| 212 |
size_t iml_len; |
| 213 |
u8 *iml; |
| 214 |
|
| 215 |
struct iwl_ucode_capabilities ucode_capa; |
| 216 |
bool enhance_sensitivity_table; |
| 217 |
|
| 218 |
u32 init_evtlog_ptr, init_evtlog_size, init_errlog_ptr; |
| 219 |
u32 inst_evtlog_ptr, inst_evtlog_size, inst_errlog_ptr; |
| 220 |
|
| 221 |
struct iwl_tlv_calib_ctrl default_calib[IWL_UCODE_TYPE_MAX]; |
| 222 |
u32 phy_config; |
| 223 |
u8 valid_tx_ant; |
| 224 |
u8 valid_rx_ant; |
| 225 |
|
| 226 |
enum iwl_fw_type type; |
| 227 |
|
| 228 |
u8 human_readable[FW_VER_HUMAN_READABLE_SZ]; |
| 229 |
|
| 230 |
struct iwl_fw_dbg dbg; |
| 231 |
|
| 232 |
u8 *phy_integration_ver; |
| 233 |
u32 phy_integration_ver_len; |
| 234 |
|
| 235 |
struct iwl_dump_exclude dump_excl[2], dump_excl_wowlan[2]; |
| 236 |
|
| 237 |
const void *pnvm_data; |
| 238 |
u32 pnvm_size; |
| 239 |
}; |
| 240 |
|
| 241 |
static inline const char *get_fw_dbg_mode_string(int mode) |
| 242 |
{ |
| 243 |
switch (mode) { |
| 244 |
case SMEM_MODE: |
| 245 |
return "SMEM"; |
| 246 |
case EXTERNAL_MODE: |
| 247 |
return "EXTERNAL_DRAM"; |
| 248 |
case MARBH_MODE: |
| 249 |
return "MARBH"; |
| 250 |
case MIPI_MODE: |
| 251 |
return "MIPI"; |
| 252 |
default: |
| 253 |
return "UNKNOWN"; |
| 254 |
} |
| 255 |
} |
| 256 |
|
| 257 |
static inline bool |
| 258 |
iwl_fw_dbg_conf_usniffer(const struct iwl_fw *fw, u8 id) |
| 259 |
{ |
| 260 |
const struct iwl_fw_dbg_conf_tlv *conf_tlv = fw->dbg.conf_tlv[id]; |
| 261 |
|
| 262 |
if (!conf_tlv) |
| 263 |
return false; |
| 264 |
|
| 265 |
return conf_tlv->usniffer; |
| 266 |
} |
| 267 |
|
| 268 |
static inline const struct fw_img * |
| 269 |
iwl_get_ucode_image(const struct iwl_fw *fw, enum iwl_ucode_type ucode_type) |
| 270 |
{ |
| 271 |
if (ucode_type >= IWL_UCODE_TYPE_MAX) |
| 272 |
return NULL; |
| 273 |
|
| 274 |
return &fw->img[ucode_type]; |
| 275 |
} |
| 276 |
|
| 277 |
u8 iwl_fw_lookup_cmd_ver(const struct iwl_fw *fw, u32 cmd_id, u8 def); |
| 278 |
|
| 279 |
u8 iwl_fw_lookup_notif_ver(const struct iwl_fw *fw, u8 grp, u8 cmd, u8 def); |
| 280 |
const char *iwl_fw_lookup_assert_desc(u32 num); |
| 281 |
|
| 282 |
#define FW_SYSASSERT_CPU_MASK 0xf0000000 |
| 283 |
#define FW_SYSASSERT_PNVM_MISSING 0x0010070d |
| 284 |
|
| 285 |
#endif /* __iwl_fw_img_h__ */ |