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 "carl9170.h" 27 #include "fwcmd.h" 28 #include "version.h" 29 30 #define MAKE_STR(symbol) #symbol 31 #define TO_STR(symbol) MAKE_STR(symbol) 32 #define CARL9170FW_API_VER_STR TO_STR(CARL9170FW_API_MAX_VER) 33 MODULE_VERSION(CARL9170FW_API_VER_STR ":" CARL9170FW_VERSION_GIT); 34 35 static const u8 otus_magic[4] = { OTUS_MAGIC }; 36 37 static const void *carl9170_fw_find_desc(struct ar9170 *ar, const u8 descid[4], 38 const unsigned int len, const u8 compatible_revision) 39 { 40 const struct carl9170fw_desc_head *iter; 41 42 carl9170fw_for_each_hdr(iter, ar->fw.desc) { 43 if (carl9170fw_desc_cmp(iter, descid, len, 44 compatible_revision)) 45 return (void *)iter; 46 } 47 48 /* needed to find the LAST desc */ 49 if (carl9170fw_desc_cmp(iter, descid, len, 50 compatible_revision)) 51 return (void *)iter; 52 53 return NULL; 54 } 55 56 static int carl9170_fw_verify_descs(struct ar9170 *ar, 57 const struct carl9170fw_desc_head *head, unsigned int max_len) 58 { 59 const struct carl9170fw_desc_head *pos; 60 unsigned long pos_addr, end_addr; 61 unsigned int pos_length; 62 63 if (max_len < sizeof(*pos)) 64 return -ENODATA; 65 66 max_len = min_t(unsigned int, CARL9170FW_DESC_MAX_LENGTH, max_len); 67 68 pos = head; 69 pos_addr = (unsigned long) pos; 70 end_addr = pos_addr + max_len; 71 72 while (pos_addr < end_addr) { 73 if (pos_addr + sizeof(*head) > end_addr) 74 return -E2BIG; 75 76 pos_length = le16_to_cpu(pos->length); 77 78 if (pos_length < sizeof(*head)) 79 return -EBADMSG; 80 81 if (pos_length > max_len) 82 return -EOVERFLOW; 83 84 if (pos_addr + pos_length > end_addr) 85 return -EMSGSIZE; 86 87 if (carl9170fw_desc_cmp(pos, LAST_MAGIC, 88 CARL9170FW_LAST_DESC_SIZE, 89 CARL9170FW_LAST_DESC_CUR_VER)) 90 return 0; 91 92 pos_addr += pos_length; 93 pos = (void *)pos_addr; 94 max_len -= pos_length; 95 } 96 return -EINVAL; 97 } 98 99 static void carl9170_fw_info(struct ar9170 *ar) 100 { 101 const struct carl9170fw_motd_desc *motd_desc; 102 unsigned int str_ver_len; 103 u32 fw_date; 104 105 dev_info(&ar->udev->dev, "driver API: %s 2%03d-%02d-%02d [%d-%d]\n", 106 CARL9170FW_VERSION_GIT, CARL9170FW_VERSION_YEAR, 107 CARL9170FW_VERSION_MONTH, CARL9170FW_VERSION_DAY, 108 CARL9170FW_API_MIN_VER, CARL9170FW_API_MAX_VER); 109 110 motd_desc = carl9170_fw_find_desc(ar, MOTD_MAGIC, 111 sizeof(*motd_desc), CARL9170FW_MOTD_DESC_CUR_VER); 112 113 if (motd_desc) { 114 str_ver_len = strnlen(motd_desc->release, 115 CARL9170FW_MOTD_RELEASE_LEN); 116 117 fw_date = le32_to_cpu(motd_desc->fw_year_month_day); 118 119 dev_info(&ar->udev->dev, "firmware API: %.*s 2%03d-%02d-%02d\n", 120 str_ver_len, motd_desc->release, 121 CARL9170FW_GET_YEAR(fw_date), 122 CARL9170FW_GET_MONTH(fw_date), 123 CARL9170FW_GET_DAY(fw_date)); 124 125 strlcpy(ar->hw->wiphy->fw_version, motd_desc->release, 126 sizeof(ar->hw->wiphy->fw_version)); 127 } 128 } 129 130 static bool valid_dma_addr(const u32 address) 131 { 132 if (address >= AR9170_SRAM_OFFSET && 133 address < (AR9170_SRAM_OFFSET + AR9170_SRAM_SIZE)) 134 return true; 135 136 return false; 137 } 138 139 static bool valid_cpu_addr(const u32 address) 140 { 141 if (valid_dma_addr(address) || (address >= AR9170_PRAM_OFFSET && 142 address < (AR9170_PRAM_OFFSET + AR9170_PRAM_SIZE))) 143 return true; 144 145 return false; 146 } 147 148 static int carl9170_fw(struct ar9170 *ar, const __u8 *data, size_t len) 149 { 150 const struct carl9170fw_otus_desc *otus_desc; 151 const struct carl9170fw_chk_desc *chk_desc; 152 const struct carl9170fw_last_desc *last_desc; 153 const struct carl9170fw_txsq_desc *txsq_desc; 154 155 last_desc = carl9170_fw_find_desc(ar, LAST_MAGIC, 156 sizeof(*last_desc), CARL9170FW_LAST_DESC_CUR_VER); 157 if (!last_desc) 158 return -EINVAL; 159 160 otus_desc = carl9170_fw_find_desc(ar, OTUS_MAGIC, 161 sizeof(*otus_desc), CARL9170FW_OTUS_DESC_CUR_VER); 162 if (!otus_desc) { 163 dev_err(&ar->udev->dev, "failed to find compatible firmware " 164 "descriptor.\n"); 165 return -ENODATA; 166 } 167 168 chk_desc = carl9170_fw_find_desc(ar, CHK_MAGIC, 169 sizeof(*chk_desc), CARL9170FW_CHK_DESC_CUR_VER); 170 171 if (chk_desc) { 172 unsigned long fin, diff; 173 unsigned int dsc_len; 174 u32 crc32; 175 176 dsc_len = min_t(unsigned int, len, 177 (unsigned long)chk_desc - (unsigned long)otus_desc); 178 179 fin = (unsigned long) last_desc + sizeof(*last_desc); 180 diff = fin - (unsigned long) otus_desc; 181 182 if (diff < len) 183 len -= diff; 184 185 if (len < 256) 186 return -EIO; 187 188 crc32 = crc32_le(~0, data, len); 189 if (cpu_to_le32(crc32) != chk_desc->fw_crc32) { 190 dev_err(&ar->udev->dev, "fw checksum test failed.\n"); 191 return -ENOEXEC; 192 } 193 194 crc32 = crc32_le(crc32, (void *)otus_desc, dsc_len); 195 if (cpu_to_le32(crc32) != chk_desc->hdr_crc32) { 196 dev_err(&ar->udev->dev, "descriptor check failed.\n"); 197 return -EINVAL; 198 } 199 } else { 200 dev_warn(&ar->udev->dev, "Unprotected firmware image.\n"); 201 } 202 203 #define SUPP(feat) \ 204 (carl9170fw_supports(otus_desc->feature_set, feat)) 205 206 if (!SUPP(CARL9170FW_DUMMY_FEATURE)) { 207 dev_err(&ar->udev->dev, "invalid firmware descriptor " 208 "format detected.\n"); 209 return -EINVAL; 210 } 211 212 ar->fw.api_version = otus_desc->api_ver; 213 214 if (ar->fw.api_version < CARL9170FW_API_MIN_VER || 215 ar->fw.api_version > CARL9170FW_API_MAX_VER) { 216 dev_err(&ar->udev->dev, "unsupported firmware api version.\n"); 217 return -EINVAL; 218 } 219 220 if (!SUPP(CARL9170FW_COMMAND_PHY) || SUPP(CARL9170FW_UNUSABLE) || 221 !SUPP(CARL9170FW_HANDLE_BACK_REQ)) { 222 dev_err(&ar->udev->dev, "firmware does support " 223 "mandatory features.\n"); 224 return -ECANCELED; 225 } 226 227 if (ilog2(le32_to_cpu(otus_desc->feature_set)) >= 228 __CARL9170FW_FEATURE_NUM) { 229 dev_warn(&ar->udev->dev, "driver does not support all " 230 "firmware features.\n"); 231 } 232 233 if (!SUPP(CARL9170FW_COMMAND_CAM)) { 234 dev_info(&ar->udev->dev, "crypto offloading is disabled " 235 "by firmware.\n"); 236 ar->disable_offload = true; 237 } 238 239 if (SUPP(CARL9170FW_PSM)) 240 ar->hw->flags |= IEEE80211_HW_SUPPORTS_PS; 241 242 if (!SUPP(CARL9170FW_USB_INIT_FIRMWARE)) { 243 dev_err(&ar->udev->dev, "firmware does not provide " 244 "mandatory interfaces.\n"); 245 return -EINVAL; 246 } 247 248 if (SUPP(CARL9170FW_MINIBOOT)) 249 ar->fw.offset = le16_to_cpu(otus_desc->miniboot_size); 250 else 251 ar->fw.offset = 0; 252 253 if (SUPP(CARL9170FW_USB_DOWN_STREAM)) { 254 ar->hw->extra_tx_headroom += sizeof(struct ar9170_stream); 255 ar->fw.tx_stream = true; 256 } 257 258 if (SUPP(CARL9170FW_USB_UP_STREAM)) 259 ar->fw.rx_stream = true; 260 261 if (SUPP(CARL9170FW_RX_FILTER)) { 262 ar->fw.rx_filter = true; 263 ar->rx_filter_caps = FIF_FCSFAIL | FIF_PLCPFAIL | 264 FIF_CONTROL | FIF_PSPOLL | FIF_OTHER_BSS | 265 FIF_PROMISC_IN_BSS; 266 } 267 268 if (SUPP(CARL9170FW_WOL)) 269 device_set_wakeup_enable(&ar->udev->dev, true); 270 271 ar->fw.vif_num = otus_desc->vif_num; 272 ar->fw.cmd_bufs = otus_desc->cmd_bufs; 273 ar->fw.address = le32_to_cpu(otus_desc->fw_address); 274 ar->fw.rx_size = le16_to_cpu(otus_desc->rx_max_frame_len); 275 ar->fw.mem_blocks = min_t(unsigned int, otus_desc->tx_descs, 0xfe); 276 atomic_set(&ar->mem_free_blocks, ar->fw.mem_blocks); 277 ar->fw.mem_block_size = le16_to_cpu(otus_desc->tx_frag_len); 278 279 if (ar->fw.vif_num >= AR9170_MAX_VIRTUAL_MAC || !ar->fw.vif_num || 280 ar->fw.mem_blocks < 16 || !ar->fw.cmd_bufs || 281 ar->fw.mem_block_size < 64 || ar->fw.mem_block_size > 512 || 282 ar->fw.rx_size > 32768 || ar->fw.rx_size < 4096 || 283 !valid_cpu_addr(ar->fw.address)) { 284 dev_err(&ar->udev->dev, "firmware shows obvious signs of " 285 "malicious tampering.\n"); 286 return -EINVAL; 287 } 288 289 ar->fw.beacon_addr = le32_to_cpu(otus_desc->bcn_addr); 290 ar->fw.beacon_max_len = le16_to_cpu(otus_desc->bcn_len); 291 292 if (valid_dma_addr(ar->fw.beacon_addr) && ar->fw.beacon_max_len >= 293 AR9170_MAC_BCN_LENGTH_MAX) { 294 ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC); 295 296 if (SUPP(CARL9170FW_WLANTX_CAB)) { 297 ar->hw->wiphy->interface_modes |= 298 BIT(NL80211_IFTYPE_AP) | 299 BIT(NL80211_IFTYPE_P2P_GO); 300 } 301 } 302 303 txsq_desc = carl9170_fw_find_desc(ar, TXSQ_MAGIC, 304 sizeof(*txsq_desc), CARL9170FW_TXSQ_DESC_CUR_VER); 305 306 if (txsq_desc) { 307 ar->fw.tx_seq_table = le32_to_cpu(txsq_desc->seq_table_addr); 308 if (!valid_cpu_addr(ar->fw.tx_seq_table)) 309 return -EINVAL; 310 } else { 311 ar->fw.tx_seq_table = 0; 312 } 313 314 #undef SUPPORTED 315 return 0; 316 } 317 318 static struct carl9170fw_desc_head * 319 carl9170_find_fw_desc(struct ar9170 *ar, const __u8 *fw_data, const size_t len) 320 321 { 322 int scan = 0, found = 0; 323 324 if (!carl9170fw_size_check(len)) { 325 dev_err(&ar->udev->dev, "firmware size is out of bound.\n"); 326 return NULL; 327 } 328 329 while (scan < len - sizeof(struct carl9170fw_desc_head)) { 330 if (fw_data[scan++] == otus_magic[found]) 331 found++; 332 else 333 found = 0; 334 335 if (scan >= len) 336 break; 337 338 if (found == sizeof(otus_magic)) 339 break; 340 } 341 342 if (found != sizeof(otus_magic)) 343 return NULL; 344 345 return (void *)&fw_data[scan - found]; 346 } 347 348 int carl9170_fw_fix_eeprom(struct ar9170 *ar) 349 { 350 const struct carl9170fw_fix_desc *fix_desc = NULL; 351 unsigned int i, n, off; 352 u32 *data = (void *)&ar->eeprom; 353 354 fix_desc = carl9170_fw_find_desc(ar, FIX_MAGIC, 355 sizeof(*fix_desc), CARL9170FW_FIX_DESC_CUR_VER); 356 357 if (!fix_desc) 358 return 0; 359 360 n = (le16_to_cpu(fix_desc->head.length) - sizeof(*fix_desc)) / 361 sizeof(struct carl9170fw_fix_entry); 362 363 for (i = 0; i < n; i++) { 364 off = le32_to_cpu(fix_desc->data[i].address) - 365 AR9170_EEPROM_START; 366 367 if (off >= sizeof(struct ar9170_eeprom) || (off & 3)) { 368 dev_err(&ar->udev->dev, "Skip invalid entry %d\n", i); 369 continue; 370 } 371 372 data[off / sizeof(*data)] &= 373 le32_to_cpu(fix_desc->data[i].mask); 374 data[off / sizeof(*data)] |= 375 le32_to_cpu(fix_desc->data[i].value); 376 } 377 378 return 0; 379 } 380 381 int carl9170_parse_firmware(struct ar9170 *ar) 382 { 383 const struct carl9170fw_desc_head *fw_desc = NULL; 384 const struct firmware *fw = ar->fw.fw; 385 unsigned long header_offset = 0; 386 int err; 387 388 if (WARN_ON(!fw)) 389 return -EINVAL; 390 391 fw_desc = carl9170_find_fw_desc(ar, fw->data, fw->size); 392 393 if (!fw_desc) { 394 dev_err(&ar->udev->dev, "unsupported firmware.\n"); 395 return -ENODATA; 396 } 397 398 header_offset = (unsigned long)fw_desc - (unsigned long)fw->data; 399 400 err = carl9170_fw_verify_descs(ar, fw_desc, fw->size - header_offset); 401 if (err) { 402 dev_err(&ar->udev->dev, "damaged firmware (%d).\n", err); 403 return err; 404 } 405 406 ar->fw.desc = fw_desc; 407 408 carl9170_fw_info(ar); 409 410 err = carl9170_fw(ar, fw->data, fw->size); 411 if (err) { 412 dev_err(&ar->udev->dev, "failed to parse firmware (%d).\n", 413 err); 414 return err; 415 } 416 417 return 0; 418 } 419