1 /* SPDX-License-Identifier: ISC */ 2 /* 3 * Copyright (c) 2014,2016 Qualcomm Atheros, Inc. 4 * Copyright (c) 2018-2019, The Linux Foundation. All rights reserved. 5 */ 6 #ifndef __WIL_FW_H__ 7 #define __WIL_FW_H__ 8 9 #define WIL_FW_SIGNATURE (0x36323130) /* '0126' */ 10 #define WIL_FW_FMT_VERSION (1) /* format version driver supports */ 11 12 enum wil_fw_record_type { 13 wil_fw_type_comment = 1, 14 wil_fw_type_data = 2, 15 wil_fw_type_fill = 3, 16 wil_fw_type_action = 4, 17 wil_fw_type_verify = 5, 18 wil_fw_type_file_header = 6, 19 wil_fw_type_direct_write = 7, 20 wil_fw_type_gateway_data = 8, 21 wil_fw_type_gateway_data4 = 9, 22 }; 23 24 struct wil_fw_record_head { 25 __le16 type; /* enum wil_fw_record_type */ 26 __le16 flags; /* to be defined */ 27 __le32 size; /* whole record, bytes after head */ 28 } __packed; 29 30 /* data block. write starting from @addr 31 * data_size inferred from the @head.size. For this case, 32 * data_size = @head.size - offsetof(struct wil_fw_record_data, data) 33 */ 34 struct wil_fw_record_data { /* type == wil_fw_type_data */ 35 __le32 addr; 36 __le32 data[0]; /* [data_size], see above */ 37 } __packed; 38 39 /* fill with constant @value, @size bytes starting from @addr */ 40 struct wil_fw_record_fill { /* type == wil_fw_type_fill */ 41 __le32 addr; 42 __le32 value; 43 __le32 size; 44 } __packed; 45 46 /* free-form comment 47 * for informational purpose, data_size is @head.size from record header 48 */ 49 struct wil_fw_record_comment { /* type == wil_fw_type_comment */ 50 u8 data[0]; /* free-form data [data_size], see above */ 51 } __packed; 52 53 /* Comment header - common for all comment record types */ 54 struct wil_fw_record_comment_hdr { 55 __le32 magic; 56 }; 57 58 /* FW capabilities encoded inside a comment record */ 59 #define WIL_FW_CAPABILITIES_MAGIC (0xabcddcba) 60 struct wil_fw_record_capabilities { /* type == wil_fw_type_comment */ 61 /* identifies capabilities record */ 62 struct wil_fw_record_comment_hdr hdr; 63 /* capabilities (variable size), see enum wmi_fw_capability */ 64 u8 capabilities[0]; 65 } __packed; 66 67 /* FW VIF concurrency encoded inside a comment record 68 * Format is similar to wiphy->iface_combinations 69 */ 70 #define WIL_FW_CONCURRENCY_MAGIC (0xfedccdef) 71 #define WIL_FW_CONCURRENCY_REC_VER 1 72 struct wil_fw_concurrency_limit { 73 __le16 max; /* maximum number of interfaces of these types */ 74 __le16 types; /* interface types (bit mask of enum nl80211_iftype) */ 75 } __packed; 76 77 struct wil_fw_concurrency_combo { 78 u8 n_limits; /* number of wil_fw_concurrency_limit entries */ 79 u8 max_interfaces; /* max number of concurrent interfaces allowed */ 80 u8 n_diff_channels; /* total number of different channels allowed */ 81 u8 same_bi; /* for APs, 1 if all APs must have same BI */ 82 /* keep last - concurrency limits, variable size by n_limits */ 83 struct wil_fw_concurrency_limit limits[0]; 84 } __packed; 85 86 struct wil_fw_record_concurrency { /* type == wil_fw_type_comment */ 87 /* identifies concurrency record */ 88 __le32 magic; 89 /* structure version, currently always 1 */ 90 u8 version; 91 /* maximum number of supported MIDs _in addition_ to MID 0 */ 92 u8 n_mids; 93 /* number of concurrency combinations that follow */ 94 __le16 n_combos; 95 /* keep last - combinations, variable size by n_combos */ 96 struct wil_fw_concurrency_combo combos[0]; 97 } __packed; 98 99 /* brd file info encoded inside a comment record */ 100 #define WIL_BRD_FILE_MAGIC (0xabcddcbb) 101 102 struct brd_info { 103 __le32 base_addr; 104 __le32 max_size_bytes; 105 } __packed; 106 107 struct wil_fw_record_brd_file { /* type == wil_fw_type_comment */ 108 /* identifies brd file record */ 109 struct wil_fw_record_comment_hdr hdr; 110 __le32 version; 111 struct brd_info brd_info[0]; 112 } __packed; 113 114 /* perform action 115 * data_size = @head.size - offsetof(struct wil_fw_record_action, data) 116 */ 117 struct wil_fw_record_action { /* type == wil_fw_type_action */ 118 __le32 action; /* action to perform: reset, wait for fw ready etc. */ 119 __le32 data[0]; /* action specific, [data_size], see above */ 120 } __packed; 121 122 /* data block for struct wil_fw_record_direct_write */ 123 struct wil_fw_data_dwrite { 124 __le32 addr; 125 __le32 value; 126 __le32 mask; 127 } __packed; 128 129 /* write @value to the @addr, 130 * preserve original bits accordingly to the @mask 131 * data_size is @head.size where @head is record header 132 */ 133 struct wil_fw_record_direct_write { /* type == wil_fw_type_direct_write */ 134 struct wil_fw_data_dwrite data[0]; 135 } __packed; 136 137 /* verify condition: [@addr] & @mask == @value 138 * if condition not met, firmware download fails 139 */ 140 struct wil_fw_record_verify { /* type == wil_fw_verify */ 141 __le32 addr; /* read from this address */ 142 __le32 value; /* reference value */ 143 __le32 mask; /* mask for verification */ 144 } __packed; 145 146 /* file header 147 * First record of every file 148 */ 149 /* the FW version prefix in the comment */ 150 #define WIL_FW_VERSION_PREFIX "FW version: " 151 #define WIL_FW_VERSION_PREFIX_LEN (sizeof(WIL_FW_VERSION_PREFIX) - 1) 152 struct wil_fw_record_file_header { 153 __le32 signature ; /* Wilocity signature */ 154 __le32 reserved; 155 __le32 crc; /* crc32 of the following data */ 156 __le32 version; /* format version */ 157 __le32 data_len; /* total data in file, including this record */ 158 u8 comment[32]; /* short description */ 159 } __packed; 160 161 /* 1-dword gateway */ 162 /* data block for the struct wil_fw_record_gateway_data */ 163 struct wil_fw_data_gw { 164 __le32 addr; 165 __le32 value; 166 } __packed; 167 168 /* gateway write block. 169 * write starting address and values from the data buffer 170 * through the gateway 171 * data_size inferred from the @head.size. For this case, 172 * data_size = @head.size - offsetof(struct wil_fw_record_gateway_data, data) 173 */ 174 struct wil_fw_record_gateway_data { /* type == wil_fw_type_gateway_data */ 175 __le32 gateway_addr_addr; 176 __le32 gateway_value_addr; 177 __le32 gateway_cmd_addr; 178 __le32 gateway_ctrl_address; 179 #define WIL_FW_GW_CTL_BUSY BIT(29) /* gateway busy performing operation */ 180 #define WIL_FW_GW_CTL_RUN BIT(30) /* start gateway operation */ 181 __le32 command; 182 struct wil_fw_data_gw data[0]; /* total size [data_size], see above */ 183 } __packed; 184 185 /* 4-dword gateway */ 186 /* data block for the struct wil_fw_record_gateway_data4 */ 187 struct wil_fw_data_gw4 { 188 __le32 addr; 189 __le32 value[4]; 190 } __packed; 191 192 /* gateway write block. 193 * write starting address and values from the data buffer 194 * through the gateway 195 * data_size inferred from the @head.size. For this case, 196 * data_size = @head.size - offsetof(struct wil_fw_record_gateway_data4, data) 197 */ 198 struct wil_fw_record_gateway_data4 { /* type == wil_fw_type_gateway_data4 */ 199 __le32 gateway_addr_addr; 200 __le32 gateway_value_addr[4]; 201 __le32 gateway_cmd_addr; 202 __le32 gateway_ctrl_address; /* same logic as for 1-dword gw */ 203 __le32 command; 204 struct wil_fw_data_gw4 data[0]; /* total size [data_size], see above */ 205 } __packed; 206 207 #endif /* __WIL_FW_H__ */ 208