1 /* 2 * Atheros CARL9170 driver 3 * 4 * firmware parser 5 * 6 * Copyright 2009, 2010, Christian Lamparter <chunkeey@googlemail.com> 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; see the file COPYING. If not, see 20 * http://www.gnu.org/licenses/. 21 */ 22 23 #include <linux/kernel.h> 24 #include <linux/firmware.h> 25 #include <linux/crc32.h> 26 #include <linux/module.h> 27 #include "carl9170.h" 28 #include "fwcmd.h" 29 #include "version.h" 30 31 static const u8 otus_magic[4] = { OTUS_MAGIC }; 32 33 static const void *carl9170_fw_find_desc(struct ar9170 *ar, const u8 descid[4], 34 const unsigned int len, const u8 compatible_revision) 35 { 36 const struct carl9170fw_desc_head *iter; 37 38 carl9170fw_for_each_hdr(iter, ar->fw.desc) { 39 if (carl9170fw_desc_cmp(iter, descid, len, 40 compatible_revision)) 41 return (void *)iter; 42 } 43 44 /* needed to find the LAST desc */ 45 if (carl9170fw_desc_cmp(iter, descid, len, 46 compatible_revision)) 47 return (void *)iter; 48 49 return NULL; 50 } 51 52 static int carl9170_fw_verify_descs(struct ar9170 *ar, 53 const struct carl9170fw_desc_head *head, unsigned int max_len) 54 { 55 const struct carl9170fw_desc_head *pos; 56 unsigned long pos_addr, end_addr; 57 unsigned int pos_length; 58 59 if (max_len < sizeof(*pos)) 60 return -ENODATA; 61 62 max_len = min_t(unsigned int, CARL9170FW_DESC_MAX_LENGTH, max_len); 63 64 pos = head; 65 pos_addr = (unsigned long) pos; 66 end_addr = pos_addr + max_len; 67 68 while (pos_addr < end_addr) { 69 if (pos_addr + sizeof(*head) > end_addr) 70 return -E2BIG; 71 72 pos_length = le16_to_cpu(pos->length); 73 74 if (pos_length < sizeof(*head)) 75 return -EBADMSG; 76 77 if (pos_length > max_len) 78 return -EOVERFLOW; 79 80 if (pos_addr + pos_length > end_addr) 81 return -EMSGSIZE; 82 83 if (carl9170fw_desc_cmp(pos, LAST_MAGIC, 84 CARL9170FW_LAST_DESC_SIZE, 85 CARL9170FW_LAST_DESC_CUR_VER)) 86 return 0; 87 88 pos_addr += pos_length; 89 pos = (void *)pos_addr; 90 max_len -= pos_length; 91 } 92 return -EINVAL; 93 } 94 95 static void carl9170_fw_info(struct ar9170 *ar) 96 { 97 const struct carl9170fw_motd_desc *motd_desc; 98 unsigned int str_ver_len; 99 u32 fw_date; 100 101 dev_info(&ar->udev->dev, "driver API: %s 2%03d-%02d-%02d [%d-%d]\n", 102 CARL9170FW_VERSION_GIT, CARL9170FW_VERSION_YEAR, 103 CARL9170FW_VERSION_MONTH, CARL9170FW_VERSION_DAY, 104 CARL9170FW_API_MIN_VER, CARL9170FW_API_MAX_VER); 105 106 motd_desc = carl9170_fw_find_desc(ar, MOTD_MAGIC, 107 sizeof(*motd_desc), CARL9170FW_MOTD_DESC_CUR_VER); 108 109 if (motd_desc) { 110 str_ver_len = strnlen(motd_desc->release, 111 CARL9170FW_MOTD_RELEASE_LEN); 112 113 fw_date = le32_to_cpu(motd_desc->fw_year_month_day); 114 115 dev_info(&ar->udev->dev, "firmware API: %.*s 2%03d-%02d-%02d\n", 116 str_ver_len, motd_desc->release, 117 CARL9170FW_GET_YEAR(fw_date), 118 CARL9170FW_GET_MONTH(fw_date), 119 CARL9170FW_GET_DAY(fw_date)); 120 121 strlcpy(ar->hw->wiphy->fw_version, motd_desc->release, 122 sizeof(ar->hw->wiphy->fw_version)); 123 } 124 } 125 126 static bool valid_dma_addr(const u32 address) 127 { 128 if (address >= AR9170_SRAM_OFFSET && 129 address < (AR9170_SRAM_OFFSET + AR9170_SRAM_SIZE)) 130 return true; 131 132 return false; 133 } 134 135 static bool valid_cpu_addr(const u32 address) 136 { 137 if (valid_dma_addr(address) || (address >= AR9170_PRAM_OFFSET && 138 address < (AR9170_PRAM_OFFSET + AR9170_PRAM_SIZE))) 139 return true; 140 141 return false; 142 } 143 144 static int carl9170_fw_checksum(struct ar9170 *ar, const __u8 *data, 145 size_t len) 146 { 147 const struct carl9170fw_otus_desc *otus_desc; 148 const struct carl9170fw_last_desc *last_desc; 149 const struct carl9170fw_chk_desc *chk_desc; 150 unsigned long fin, diff; 151 unsigned int dsc_len; 152 u32 crc32; 153 154 last_desc = carl9170_fw_find_desc(ar, LAST_MAGIC, 155 sizeof(*last_desc), CARL9170FW_LAST_DESC_CUR_VER); 156 if (!last_desc) 157 return -EINVAL; 158 159 otus_desc = carl9170_fw_find_desc(ar, OTUS_MAGIC, 160 sizeof(*otus_desc), CARL9170FW_OTUS_DESC_CUR_VER); 161 if (!otus_desc) { 162 dev_err(&ar->udev->dev, "failed to find compatible firmware " 163 "descriptor.\n"); 164 return -ENODATA; 165 } 166 167 chk_desc = carl9170_fw_find_desc(ar, CHK_MAGIC, 168 sizeof(*chk_desc), CARL9170FW_CHK_DESC_CUR_VER); 169 170 if (!chk_desc) { 171 dev_warn(&ar->udev->dev, "Unprotected firmware image.\n"); 172 return 0; 173 } 174 175 dsc_len = min_t(unsigned int, len, 176 (unsigned long)chk_desc - (unsigned long)otus_desc); 177 178 fin = (unsigned long) last_desc + sizeof(*last_desc); 179 diff = fin - (unsigned long) otus_desc; 180 181 if (diff < len) 182 len -= diff; 183 184 if (len < 256) 185 return -EIO; 186 187 crc32 = crc32_le(~0, data, len); 188 if (cpu_to_le32(crc32) != chk_desc->fw_crc32) { 189 dev_err(&ar->udev->dev, "fw checksum test failed.\n"); 190 return -ENOEXEC; 191 } 192 193 crc32 = crc32_le(crc32, (void *)otus_desc, dsc_len); 194 if (cpu_to_le32(crc32) != chk_desc->hdr_crc32) { 195 dev_err(&ar->udev->dev, "descriptor check failed.\n"); 196 return -EINVAL; 197 } 198 return 0; 199 } 200 201 static int carl9170_fw_tx_sequence(struct ar9170 *ar) 202 { 203 const struct carl9170fw_txsq_desc *txsq_desc; 204 205 txsq_desc = carl9170_fw_find_desc(ar, TXSQ_MAGIC, sizeof(*txsq_desc), 206 CARL9170FW_TXSQ_DESC_CUR_VER); 207 if (txsq_desc) { 208 ar->fw.tx_seq_table = le32_to_cpu(txsq_desc->seq_table_addr); 209 if (!valid_cpu_addr(ar->fw.tx_seq_table)) 210 return -EINVAL; 211 } else { 212 ar->fw.tx_seq_table = 0; 213 } 214 215 return 0; 216 } 217 218 static void carl9170_fw_set_if_combinations(struct ar9170 *ar, 219 u16 if_comb_types) 220 { 221 if (ar->fw.vif_num < 2) 222 return; 223 224 ar->if_comb_limits[0].max = ar->fw.vif_num; 225 ar->if_comb_limits[0].types = if_comb_types; 226 227 ar->if_combs[0].num_different_channels = 1; 228 ar->if_combs[0].max_interfaces = ar->fw.vif_num; 229 ar->if_combs[0].limits = ar->if_comb_limits; 230 ar->if_combs[0].n_limits = ARRAY_SIZE(ar->if_comb_limits); 231 232 ar->hw->wiphy->iface_combinations = ar->if_combs; 233 ar->hw->wiphy->n_iface_combinations = ARRAY_SIZE(ar->if_combs); 234 } 235 236 static int carl9170_fw(struct ar9170 *ar, const __u8 *data, size_t len) 237 { 238 const struct carl9170fw_otus_desc *otus_desc; 239 int err; 240 u16 if_comb_types; 241 242 err = carl9170_fw_checksum(ar, data, len); 243 if (err) 244 return err; 245 246 otus_desc = carl9170_fw_find_desc(ar, OTUS_MAGIC, 247 sizeof(*otus_desc), CARL9170FW_OTUS_DESC_CUR_VER); 248 if (!otus_desc) { 249 return -ENODATA; 250 } 251 252 #define SUPP(feat) \ 253 (carl9170fw_supports(otus_desc->feature_set, feat)) 254 255 if (!SUPP(CARL9170FW_DUMMY_FEATURE)) { 256 dev_err(&ar->udev->dev, "invalid firmware descriptor " 257 "format detected.\n"); 258 return -EINVAL; 259 } 260 261 ar->fw.api_version = otus_desc->api_ver; 262 263 if (ar->fw.api_version < CARL9170FW_API_MIN_VER || 264 ar->fw.api_version > CARL9170FW_API_MAX_VER) { 265 dev_err(&ar->udev->dev, "unsupported firmware api version.\n"); 266 return -EINVAL; 267 } 268 269 if (!SUPP(CARL9170FW_COMMAND_PHY) || SUPP(CARL9170FW_UNUSABLE) || 270 !SUPP(CARL9170FW_HANDLE_BACK_REQ)) { 271 dev_err(&ar->udev->dev, "firmware does support " 272 "mandatory features.\n"); 273 return -ECANCELED; 274 } 275 276 if (ilog2(le32_to_cpu(otus_desc->feature_set)) >= 277 __CARL9170FW_FEATURE_NUM) { 278 dev_warn(&ar->udev->dev, "driver does not support all " 279 "firmware features.\n"); 280 } 281 282 if (!SUPP(CARL9170FW_COMMAND_CAM)) { 283 dev_info(&ar->udev->dev, "crypto offloading is disabled " 284 "by firmware.\n"); 285 ar->fw.disable_offload_fw = true; 286 } 287 288 if (SUPP(CARL9170FW_PSM) && SUPP(CARL9170FW_FIXED_5GHZ_PSM)) 289 ar->hw->flags |= IEEE80211_HW_SUPPORTS_PS; 290 291 if (!SUPP(CARL9170FW_USB_INIT_FIRMWARE)) { 292 dev_err(&ar->udev->dev, "firmware does not provide " 293 "mandatory interfaces.\n"); 294 return -EINVAL; 295 } 296 297 if (SUPP(CARL9170FW_MINIBOOT)) 298 ar->fw.offset = le16_to_cpu(otus_desc->miniboot_size); 299 else 300 ar->fw.offset = 0; 301 302 if (SUPP(CARL9170FW_USB_DOWN_STREAM)) { 303 ar->hw->extra_tx_headroom += sizeof(struct ar9170_stream); 304 ar->fw.tx_stream = true; 305 } 306 307 if (SUPP(CARL9170FW_USB_UP_STREAM)) 308 ar->fw.rx_stream = true; 309 310 if (SUPP(CARL9170FW_RX_FILTER)) { 311 ar->fw.rx_filter = true; 312 ar->rx_filter_caps = FIF_FCSFAIL | FIF_PLCPFAIL | 313 FIF_CONTROL | FIF_PSPOLL | FIF_OTHER_BSS | 314 FIF_PROMISC_IN_BSS; 315 } 316 317 if (SUPP(CARL9170FW_HW_COUNTERS)) 318 ar->fw.hw_counters = true; 319 320 if (SUPP(CARL9170FW_WOL)) 321 device_set_wakeup_enable(&ar->udev->dev, true); 322 323 if (SUPP(CARL9170FW_RX_BA_FILTER)) 324 ar->fw.ba_filter = true; 325 326 if_comb_types = BIT(NL80211_IFTYPE_STATION) | 327 BIT(NL80211_IFTYPE_P2P_CLIENT); 328 329 ar->fw.vif_num = otus_desc->vif_num; 330 ar->fw.cmd_bufs = otus_desc->cmd_bufs; 331 ar->fw.address = le32_to_cpu(otus_desc->fw_address); 332 ar->fw.rx_size = le16_to_cpu(otus_desc->rx_max_frame_len); 333 ar->fw.mem_blocks = min_t(unsigned int, otus_desc->tx_descs, 0xfe); 334 atomic_set(&ar->mem_free_blocks, ar->fw.mem_blocks); 335 ar->fw.mem_block_size = le16_to_cpu(otus_desc->tx_frag_len); 336 337 if (ar->fw.vif_num >= AR9170_MAX_VIRTUAL_MAC || !ar->fw.vif_num || 338 ar->fw.mem_blocks < 16 || !ar->fw.cmd_bufs || 339 ar->fw.mem_block_size < 64 || ar->fw.mem_block_size > 512 || 340 ar->fw.rx_size > 32768 || ar->fw.rx_size < 4096 || 341 !valid_cpu_addr(ar->fw.address)) { 342 dev_err(&ar->udev->dev, "firmware shows obvious signs of " 343 "malicious tampering.\n"); 344 return -EINVAL; 345 } 346 347 ar->fw.beacon_addr = le32_to_cpu(otus_desc->bcn_addr); 348 ar->fw.beacon_max_len = le16_to_cpu(otus_desc->bcn_len); 349 350 if (valid_dma_addr(ar->fw.beacon_addr) && ar->fw.beacon_max_len >= 351 AR9170_MAC_BCN_LENGTH_MAX) { 352 ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC); 353 354 if (SUPP(CARL9170FW_WLANTX_CAB)) { 355 if_comb_types |= 356 BIT(NL80211_IFTYPE_AP) | 357 BIT(NL80211_IFTYPE_P2P_GO); 358 359 #ifdef CONFIG_MAC80211_MESH 360 if_comb_types |= 361 BIT(NL80211_IFTYPE_MESH_POINT); 362 #endif /* CONFIG_MAC80211_MESH */ 363 } 364 } 365 366 carl9170_fw_set_if_combinations(ar, if_comb_types); 367 368 ar->hw->wiphy->interface_modes |= if_comb_types; 369 370 ar->hw->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT; 371 372 /* As IBSS Encryption is software-based, IBSS RSN is supported. */ 373 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL | 374 WIPHY_FLAG_IBSS_RSN | WIPHY_FLAG_SUPPORTS_TDLS; 375 376 #undef SUPPORTED 377 return carl9170_fw_tx_sequence(ar); 378 } 379 380 static struct carl9170fw_desc_head * 381 carl9170_find_fw_desc(struct ar9170 *ar, const __u8 *fw_data, const size_t len) 382 383 { 384 int scan = 0, found = 0; 385 386 if (!carl9170fw_size_check(len)) { 387 dev_err(&ar->udev->dev, "firmware size is out of bound.\n"); 388 return NULL; 389 } 390 391 while (scan < len - sizeof(struct carl9170fw_desc_head)) { 392 if (fw_data[scan++] == otus_magic[found]) 393 found++; 394 else 395 found = 0; 396 397 if (scan >= len) 398 break; 399 400 if (found == sizeof(otus_magic)) 401 break; 402 } 403 404 if (found != sizeof(otus_magic)) 405 return NULL; 406 407 return (void *)&fw_data[scan - found]; 408 } 409 410 int carl9170_parse_firmware(struct ar9170 *ar) 411 { 412 const struct carl9170fw_desc_head *fw_desc = NULL; 413 const struct firmware *fw = ar->fw.fw; 414 unsigned long header_offset = 0; 415 int err; 416 417 if (WARN_ON(!fw)) 418 return -EINVAL; 419 420 fw_desc = carl9170_find_fw_desc(ar, fw->data, fw->size); 421 422 if (!fw_desc) { 423 dev_err(&ar->udev->dev, "unsupported firmware.\n"); 424 return -ENODATA; 425 } 426 427 header_offset = (unsigned long)fw_desc - (unsigned long)fw->data; 428 429 err = carl9170_fw_verify_descs(ar, fw_desc, fw->size - header_offset); 430 if (err) { 431 dev_err(&ar->udev->dev, "damaged firmware (%d).\n", err); 432 return err; 433 } 434 435 ar->fw.desc = fw_desc; 436 437 carl9170_fw_info(ar); 438 439 err = carl9170_fw(ar, fw->data, fw->size); 440 if (err) { 441 dev_err(&ar->udev->dev, "failed to parse firmware (%d).\n", 442 err); 443 return err; 444 } 445 446 return 0; 447 } 448