1 /* 2 * This file is part of wl1271 3 * 4 * Copyright (C) 2008-2010 Nokia Corporation 5 * 6 * Contact: Luciano Coelho <luciano.coelho@nokia.com> 7 * 8 * This program is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU General Public License 10 * version 2 as published by the Free Software Foundation. 11 * 12 * This program is distributed in the hope that it will be useful, but 13 * WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 20 * 02110-1301 USA 21 * 22 */ 23 24 #include <linux/slab.h> 25 #include <linux/export.h> 26 27 #include "debug.h" 28 #include "acx.h" 29 #include "boot.h" 30 #include "io.h" 31 #include "event.h" 32 #include "rx.h" 33 #include "hw_ops.h" 34 35 static int wl1271_boot_set_ecpu_ctrl(struct wl1271 *wl, u32 flag) 36 { 37 u32 cpu_ctrl; 38 int ret; 39 40 /* 10.5.0 run the firmware (I) */ 41 ret = wlcore_read_reg(wl, REG_ECPU_CONTROL, &cpu_ctrl); 42 if (ret < 0) 43 goto out; 44 45 /* 10.5.1 run the firmware (II) */ 46 cpu_ctrl |= flag; 47 ret = wlcore_write_reg(wl, REG_ECPU_CONTROL, cpu_ctrl); 48 49 out: 50 return ret; 51 } 52 53 static int wlcore_boot_parse_fw_ver(struct wl1271 *wl, 54 struct wl1271_static_data *static_data) 55 { 56 int ret; 57 58 strncpy(wl->chip.fw_ver_str, static_data->fw_version, 59 sizeof(wl->chip.fw_ver_str)); 60 61 /* make sure the string is NULL-terminated */ 62 wl->chip.fw_ver_str[sizeof(wl->chip.fw_ver_str) - 1] = '\0'; 63 64 ret = sscanf(wl->chip.fw_ver_str + 4, "%u.%u.%u.%u.%u", 65 &wl->chip.fw_ver[0], &wl->chip.fw_ver[1], 66 &wl->chip.fw_ver[2], &wl->chip.fw_ver[3], 67 &wl->chip.fw_ver[4]); 68 69 if (ret != 5) { 70 wl1271_warning("fw version incorrect value"); 71 memset(wl->chip.fw_ver, 0, sizeof(wl->chip.fw_ver)); 72 ret = -EINVAL; 73 goto out; 74 } 75 76 ret = wlcore_identify_fw(wl); 77 if (ret < 0) 78 goto out; 79 out: 80 return ret; 81 } 82 83 static int wlcore_validate_fw_ver(struct wl1271 *wl) 84 { 85 unsigned int *fw_ver = wl->chip.fw_ver; 86 unsigned int *min_ver = (wl->fw_type == WL12XX_FW_TYPE_MULTI) ? 87 wl->min_mr_fw_ver : wl->min_sr_fw_ver; 88 char min_fw_str[32] = ""; 89 int i; 90 91 /* the chip must be exactly equal */ 92 if ((min_ver[FW_VER_CHIP] != WLCORE_FW_VER_IGNORE) && 93 (min_ver[FW_VER_CHIP] != fw_ver[FW_VER_CHIP])) 94 goto fail; 95 96 /* the firmware type must be equal */ 97 if ((min_ver[FW_VER_IF_TYPE] != WLCORE_FW_VER_IGNORE) && 98 (min_ver[FW_VER_IF_TYPE] != fw_ver[FW_VER_IF_TYPE])) 99 goto fail; 100 101 /* the project number must be equal */ 102 if ((min_ver[FW_VER_SUBTYPE] != WLCORE_FW_VER_IGNORE) && 103 (min_ver[FW_VER_SUBTYPE] != fw_ver[FW_VER_SUBTYPE])) 104 goto fail; 105 106 /* the API version must be greater or equal */ 107 if ((min_ver[FW_VER_MAJOR] != WLCORE_FW_VER_IGNORE) && 108 (min_ver[FW_VER_MAJOR] > fw_ver[FW_VER_MAJOR])) 109 goto fail; 110 111 /* if the API version is equal... */ 112 if (((min_ver[FW_VER_MAJOR] == WLCORE_FW_VER_IGNORE) || 113 (min_ver[FW_VER_MAJOR] == fw_ver[FW_VER_MAJOR])) && 114 /* ...the minor must be greater or equal */ 115 ((min_ver[FW_VER_MINOR] != WLCORE_FW_VER_IGNORE) && 116 (min_ver[FW_VER_MINOR] > fw_ver[FW_VER_MINOR]))) 117 goto fail; 118 119 return 0; 120 121 fail: 122 for (i = 0; i < NUM_FW_VER; i++) 123 if (min_ver[i] == WLCORE_FW_VER_IGNORE) 124 snprintf(min_fw_str, sizeof(min_fw_str), 125 "%s*.", min_fw_str); 126 else 127 snprintf(min_fw_str, sizeof(min_fw_str), 128 "%s%u.", min_fw_str, min_ver[i]); 129 130 wl1271_error("Your WiFi FW version (%u.%u.%u.%u.%u) is invalid.\n" 131 "Please use at least FW %s\n" 132 "You can get the latest firmwares at:\n" 133 "git://github.com/TI-OpenLink/firmwares.git", 134 fw_ver[FW_VER_CHIP], fw_ver[FW_VER_IF_TYPE], 135 fw_ver[FW_VER_MAJOR], fw_ver[FW_VER_SUBTYPE], 136 fw_ver[FW_VER_MINOR], min_fw_str); 137 return -EINVAL; 138 } 139 140 static int wlcore_boot_static_data(struct wl1271 *wl) 141 { 142 struct wl1271_static_data *static_data; 143 size_t len = sizeof(*static_data) + wl->static_data_priv_len; 144 int ret; 145 146 static_data = kmalloc(len, GFP_KERNEL); 147 if (!static_data) { 148 ret = -ENOMEM; 149 goto out; 150 } 151 152 ret = wlcore_read(wl, wl->cmd_box_addr, static_data, len, false); 153 if (ret < 0) 154 goto out_free; 155 156 ret = wlcore_boot_parse_fw_ver(wl, static_data); 157 if (ret < 0) 158 goto out_free; 159 160 ret = wlcore_validate_fw_ver(wl); 161 if (ret < 0) 162 goto out_free; 163 164 ret = wlcore_handle_static_data(wl, static_data); 165 if (ret < 0) 166 goto out_free; 167 168 out_free: 169 kfree(static_data); 170 out: 171 return ret; 172 } 173 174 static int wl1271_boot_upload_firmware_chunk(struct wl1271 *wl, void *buf, 175 size_t fw_data_len, u32 dest) 176 { 177 struct wlcore_partition_set partition; 178 int addr, chunk_num, partition_limit; 179 u8 *p, *chunk; 180 int ret; 181 182 /* whal_FwCtrl_LoadFwImageSm() */ 183 184 wl1271_debug(DEBUG_BOOT, "starting firmware upload"); 185 186 wl1271_debug(DEBUG_BOOT, "fw_data_len %zd chunk_size %d", 187 fw_data_len, CHUNK_SIZE); 188 189 if ((fw_data_len % 4) != 0) { 190 wl1271_error("firmware length not multiple of four"); 191 return -EIO; 192 } 193 194 chunk = kmalloc(CHUNK_SIZE, GFP_KERNEL); 195 if (!chunk) { 196 wl1271_error("allocation for firmware upload chunk failed"); 197 return -ENOMEM; 198 } 199 200 memcpy(&partition, &wl->ptable[PART_DOWN], sizeof(partition)); 201 partition.mem.start = dest; 202 ret = wlcore_set_partition(wl, &partition); 203 if (ret < 0) 204 goto out; 205 206 /* 10.1 set partition limit and chunk num */ 207 chunk_num = 0; 208 partition_limit = wl->ptable[PART_DOWN].mem.size; 209 210 while (chunk_num < fw_data_len / CHUNK_SIZE) { 211 /* 10.2 update partition, if needed */ 212 addr = dest + (chunk_num + 2) * CHUNK_SIZE; 213 if (addr > partition_limit) { 214 addr = dest + chunk_num * CHUNK_SIZE; 215 partition_limit = chunk_num * CHUNK_SIZE + 216 wl->ptable[PART_DOWN].mem.size; 217 partition.mem.start = addr; 218 ret = wlcore_set_partition(wl, &partition); 219 if (ret < 0) 220 goto out; 221 } 222 223 /* 10.3 upload the chunk */ 224 addr = dest + chunk_num * CHUNK_SIZE; 225 p = buf + chunk_num * CHUNK_SIZE; 226 memcpy(chunk, p, CHUNK_SIZE); 227 wl1271_debug(DEBUG_BOOT, "uploading fw chunk 0x%p to 0x%x", 228 p, addr); 229 ret = wlcore_write(wl, addr, chunk, CHUNK_SIZE, false); 230 if (ret < 0) 231 goto out; 232 233 chunk_num++; 234 } 235 236 /* 10.4 upload the last chunk */ 237 addr = dest + chunk_num * CHUNK_SIZE; 238 p = buf + chunk_num * CHUNK_SIZE; 239 memcpy(chunk, p, fw_data_len % CHUNK_SIZE); 240 wl1271_debug(DEBUG_BOOT, "uploading fw last chunk (%zd B) 0x%p to 0x%x", 241 fw_data_len % CHUNK_SIZE, p, addr); 242 ret = wlcore_write(wl, addr, chunk, fw_data_len % CHUNK_SIZE, false); 243 244 out: 245 kfree(chunk); 246 return ret; 247 } 248 249 int wlcore_boot_upload_firmware(struct wl1271 *wl) 250 { 251 u32 chunks, addr, len; 252 int ret = 0; 253 u8 *fw; 254 255 fw = wl->fw; 256 chunks = be32_to_cpup((__be32 *) fw); 257 fw += sizeof(u32); 258 259 wl1271_debug(DEBUG_BOOT, "firmware chunks to be uploaded: %u", chunks); 260 261 while (chunks--) { 262 addr = be32_to_cpup((__be32 *) fw); 263 fw += sizeof(u32); 264 len = be32_to_cpup((__be32 *) fw); 265 fw += sizeof(u32); 266 267 if (len > 300000) { 268 wl1271_info("firmware chunk too long: %u", len); 269 return -EINVAL; 270 } 271 wl1271_debug(DEBUG_BOOT, "chunk %d addr 0x%x len %u", 272 chunks, addr, len); 273 ret = wl1271_boot_upload_firmware_chunk(wl, fw, len, addr); 274 if (ret != 0) 275 break; 276 fw += len; 277 } 278 279 return ret; 280 } 281 EXPORT_SYMBOL_GPL(wlcore_boot_upload_firmware); 282 283 int wlcore_boot_upload_nvs(struct wl1271 *wl) 284 { 285 size_t nvs_len, burst_len; 286 int i; 287 u32 dest_addr, val; 288 u8 *nvs_ptr, *nvs_aligned; 289 int ret; 290 291 if (wl->nvs == NULL) { 292 wl1271_error("NVS file is needed during boot"); 293 return -ENODEV; 294 } 295 296 if (wl->quirks & WLCORE_QUIRK_LEGACY_NVS) { 297 struct wl1271_nvs_file *nvs = 298 (struct wl1271_nvs_file *)wl->nvs; 299 /* 300 * FIXME: the LEGACY NVS image support (NVS's missing the 5GHz 301 * band configurations) can be removed when those NVS files stop 302 * floating around. 303 */ 304 if (wl->nvs_len == sizeof(struct wl1271_nvs_file) || 305 wl->nvs_len == WL1271_INI_LEGACY_NVS_FILE_SIZE) { 306 if (nvs->general_params.dual_mode_select) 307 wl->enable_11a = true; 308 } 309 310 if (wl->nvs_len != sizeof(struct wl1271_nvs_file) && 311 (wl->nvs_len != WL1271_INI_LEGACY_NVS_FILE_SIZE || 312 wl->enable_11a)) { 313 wl1271_error("nvs size is not as expected: %zu != %zu", 314 wl->nvs_len, sizeof(struct wl1271_nvs_file)); 315 kfree(wl->nvs); 316 wl->nvs = NULL; 317 wl->nvs_len = 0; 318 return -EILSEQ; 319 } 320 321 /* only the first part of the NVS needs to be uploaded */ 322 nvs_len = sizeof(nvs->nvs); 323 nvs_ptr = (u8 *) nvs->nvs; 324 } else { 325 struct wl128x_nvs_file *nvs = (struct wl128x_nvs_file *)wl->nvs; 326 327 if (wl->nvs_len == sizeof(struct wl128x_nvs_file)) { 328 if (nvs->general_params.dual_mode_select) 329 wl->enable_11a = true; 330 } else { 331 wl1271_error("nvs size is not as expected: %zu != %zu", 332 wl->nvs_len, 333 sizeof(struct wl128x_nvs_file)); 334 kfree(wl->nvs); 335 wl->nvs = NULL; 336 wl->nvs_len = 0; 337 return -EILSEQ; 338 } 339 340 /* only the first part of the NVS needs to be uploaded */ 341 nvs_len = sizeof(nvs->nvs); 342 nvs_ptr = (u8 *)nvs->nvs; 343 } 344 345 /* update current MAC address to NVS */ 346 nvs_ptr[11] = wl->addresses[0].addr[0]; 347 nvs_ptr[10] = wl->addresses[0].addr[1]; 348 nvs_ptr[6] = wl->addresses[0].addr[2]; 349 nvs_ptr[5] = wl->addresses[0].addr[3]; 350 nvs_ptr[4] = wl->addresses[0].addr[4]; 351 nvs_ptr[3] = wl->addresses[0].addr[5]; 352 353 /* 354 * Layout before the actual NVS tables: 355 * 1 byte : burst length. 356 * 2 bytes: destination address. 357 * n bytes: data to burst copy. 358 * 359 * This is ended by a 0 length, then the NVS tables. 360 */ 361 362 /* FIXME: Do we need to check here whether the LSB is 1? */ 363 while (nvs_ptr[0]) { 364 burst_len = nvs_ptr[0]; 365 dest_addr = (nvs_ptr[1] & 0xfe) | ((u32)(nvs_ptr[2] << 8)); 366 367 /* 368 * Due to our new wl1271_translate_reg_addr function, 369 * we need to add the register partition start address 370 * to the destination 371 */ 372 dest_addr += wl->curr_part.reg.start; 373 374 /* We move our pointer to the data */ 375 nvs_ptr += 3; 376 377 for (i = 0; i < burst_len; i++) { 378 if (nvs_ptr + 3 >= (u8 *) wl->nvs + nvs_len) 379 goto out_badnvs; 380 381 val = (nvs_ptr[0] | (nvs_ptr[1] << 8) 382 | (nvs_ptr[2] << 16) | (nvs_ptr[3] << 24)); 383 384 wl1271_debug(DEBUG_BOOT, 385 "nvs burst write 0x%x: 0x%x", 386 dest_addr, val); 387 ret = wlcore_write32(wl, dest_addr, val); 388 if (ret < 0) 389 return ret; 390 391 nvs_ptr += 4; 392 dest_addr += 4; 393 } 394 395 if (nvs_ptr >= (u8 *) wl->nvs + nvs_len) 396 goto out_badnvs; 397 } 398 399 /* 400 * We've reached the first zero length, the first NVS table 401 * is located at an aligned offset which is at least 7 bytes further. 402 * NOTE: The wl->nvs->nvs element must be first, in order to 403 * simplify the casting, we assume it is at the beginning of 404 * the wl->nvs structure. 405 */ 406 nvs_ptr = (u8 *)wl->nvs + 407 ALIGN(nvs_ptr - (u8 *)wl->nvs + 7, 4); 408 409 if (nvs_ptr >= (u8 *) wl->nvs + nvs_len) 410 goto out_badnvs; 411 412 nvs_len -= nvs_ptr - (u8 *)wl->nvs; 413 414 /* Now we must set the partition correctly */ 415 ret = wlcore_set_partition(wl, &wl->ptable[PART_WORK]); 416 if (ret < 0) 417 return ret; 418 419 /* Copy the NVS tables to a new block to ensure alignment */ 420 nvs_aligned = kmemdup(nvs_ptr, nvs_len, GFP_KERNEL); 421 if (!nvs_aligned) 422 return -ENOMEM; 423 424 /* And finally we upload the NVS tables */ 425 ret = wlcore_write_data(wl, REG_CMD_MBOX_ADDRESS, nvs_aligned, nvs_len, 426 false); 427 428 kfree(nvs_aligned); 429 return ret; 430 431 out_badnvs: 432 wl1271_error("nvs data is malformed"); 433 return -EILSEQ; 434 } 435 EXPORT_SYMBOL_GPL(wlcore_boot_upload_nvs); 436 437 int wlcore_boot_run_firmware(struct wl1271 *wl) 438 { 439 int loop, ret; 440 u32 chip_id, intr; 441 442 /* Make sure we have the boot partition */ 443 ret = wlcore_set_partition(wl, &wl->ptable[PART_BOOT]); 444 if (ret < 0) 445 return ret; 446 447 ret = wl1271_boot_set_ecpu_ctrl(wl, ECPU_CONTROL_HALT); 448 if (ret < 0) 449 return ret; 450 451 ret = wlcore_read_reg(wl, REG_CHIP_ID_B, &chip_id); 452 if (ret < 0) 453 return ret; 454 455 wl1271_debug(DEBUG_BOOT, "chip id after firmware boot: 0x%x", chip_id); 456 457 if (chip_id != wl->chip.id) { 458 wl1271_error("chip id doesn't match after firmware boot"); 459 return -EIO; 460 } 461 462 /* wait for init to complete */ 463 loop = 0; 464 while (loop++ < INIT_LOOP) { 465 udelay(INIT_LOOP_DELAY); 466 ret = wlcore_read_reg(wl, REG_INTERRUPT_NO_CLEAR, &intr); 467 if (ret < 0) 468 return ret; 469 470 if (intr == 0xffffffff) { 471 wl1271_error("error reading hardware complete " 472 "init indication"); 473 return -EIO; 474 } 475 /* check that ACX_INTR_INIT_COMPLETE is enabled */ 476 else if (intr & WL1271_ACX_INTR_INIT_COMPLETE) { 477 ret = wlcore_write_reg(wl, REG_INTERRUPT_ACK, 478 WL1271_ACX_INTR_INIT_COMPLETE); 479 if (ret < 0) 480 return ret; 481 break; 482 } 483 } 484 485 if (loop > INIT_LOOP) { 486 wl1271_error("timeout waiting for the hardware to " 487 "complete initialization"); 488 return -EIO; 489 } 490 491 /* get hardware config command mail box */ 492 ret = wlcore_read_reg(wl, REG_COMMAND_MAILBOX_PTR, &wl->cmd_box_addr); 493 if (ret < 0) 494 return ret; 495 496 wl1271_debug(DEBUG_MAILBOX, "cmd_box_addr 0x%x", wl->cmd_box_addr); 497 498 /* get hardware config event mail box */ 499 ret = wlcore_read_reg(wl, REG_EVENT_MAILBOX_PTR, &wl->mbox_ptr[0]); 500 if (ret < 0) 501 return ret; 502 503 wl->mbox_ptr[1] = wl->mbox_ptr[0] + wl->mbox_size; 504 505 wl1271_debug(DEBUG_MAILBOX, "MBOX ptrs: 0x%x 0x%x", 506 wl->mbox_ptr[0], wl->mbox_ptr[1]); 507 508 ret = wlcore_boot_static_data(wl); 509 if (ret < 0) { 510 wl1271_error("error getting static data"); 511 return ret; 512 } 513 514 /* 515 * in case of full asynchronous mode the firmware event must be 516 * ready to receive event from the command mailbox 517 */ 518 519 /* unmask required mbox events */ 520 ret = wl1271_event_unmask(wl); 521 if (ret < 0) { 522 wl1271_error("EVENT mask setting failed"); 523 return ret; 524 } 525 526 /* set the working partition to its "running" mode offset */ 527 ret = wlcore_set_partition(wl, &wl->ptable[PART_WORK]); 528 529 /* firmware startup completed */ 530 return ret; 531 } 532 EXPORT_SYMBOL_GPL(wlcore_boot_run_firmware); 533