drivers/net/wireless/ti/wlcore/boot.c

   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);