drivers/net/wireless/iwmc3200wifi/fw.c

   1 /*
   2  * Intel Wireless Multicomm 3200 WiFi driver
   3  *
   4  * Copyright (C) 2009 Intel Corporation. All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  *   * Redistributions of source code must retain the above copyright
  11  *     notice, this list of conditions and the following disclaimer.
  12  *   * Redistributions in binary form must reproduce the above copyright
  13  *     notice, this list of conditions and the following disclaimer in
  14  *     the documentation and/or other materials provided with the
  15  *     distribution.
  16  *   * Neither the name of Intel Corporation nor the names of its
  17  *     contributors may be used to endorse or promote products derived
  18  *     from this software without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  23  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  24  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  25  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  26  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  27  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  28  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  30  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  *
  32  *
  33  * Intel Corporation <ilw@linux.intel.com>
  34  * Samuel Ortiz <samuel.ortiz@intel.com>
  35  * Zhu Yi <yi.zhu@intel.com>
  36  *
  37  */
  38
  39 #include <linux/kernel.h>
  40 #include <linux/firmware.h>
  41
  42 #include "iwm.h"
  43 #include "bus.h"
  44 #include "hal.h"
  45 #include "umac.h"
  46 #include "debug.h"
  47 #include "fw.h"
  48 #include "commands.h"
  49
  50 static const char fw_barker[] = "*WESTOPFORNOONE*";
  51
  52 /*
  53  * @op_code: Op code we're looking for.
  54  * @index: There can be several instances of the same opcode within
  55  *         the firmware. Index specifies which one we're looking for.
  56  */
  57 static int iwm_fw_op_offset(struct iwm_priv *iwm, const struct firmware *fw,
  58                             u16 op_code, u32 index)
  59 {
  60         int offset = -EINVAL, fw_offset;
  61         u32 op_index = 0;
  62         const u8 *fw_ptr;
  63         struct iwm_fw_hdr_rec *rec;
  64
  65         fw_offset = 0;
  66         fw_ptr = fw->data;
  67
  68         /* We first need to look for the firmware barker */
  69         if (memcmp(fw_ptr, fw_barker, IWM_HDR_BARKER_LEN)) {
  70                 IWM_ERR(iwm, "No barker string in this FW\n");
  71                 return -EINVAL;
  72         }
  73
  74         if (fw->size < IWM_HDR_LEN) {
  75                 IWM_ERR(iwm, "FW is too small (%zu)\n", fw->size);
  76                 return -EINVAL;
  77         }
  78
  79         fw_offset += IWM_HDR_BARKER_LEN;
  80
  81         while (fw_offset < fw->size) {
  82                 rec = (struct iwm_fw_hdr_rec *)(fw_ptr + fw_offset);
  83
  84                 IWM_DBG_FW(iwm, DBG, "FW: op_code: 0x%x, len: %d @ 0x%x\n",
  85                            rec->op_code, rec->len, fw_offset);
  86
  87                 if (rec->op_code == IWM_HDR_REC_OP_INVALID) {
  88                         IWM_DBG_FW(iwm, DBG, "Reached INVALID op code\n");
  89                         break;
  90                 }
  91
  92                 if (rec->op_code == op_code) {
  93                         if (op_index == index) {
  94                                 fw_offset += sizeof(struct iwm_fw_hdr_rec);
  95                                 offset = fw_offset;
  96                                 goto out;
  97                         }
  98                         op_index++;
  99                 }
 100
 101                 fw_offset += sizeof(struct iwm_fw_hdr_rec) + rec->len;
 102         }
 103
 104  out:
 105         return offset;
 106 }
 107
 108 static int iwm_load_firmware_chunk(struct iwm_priv *iwm,
 109                                    const struct firmware *fw,
 110                                    struct iwm_fw_img_desc *img_desc)
 111 {
 112         struct iwm_udma_nonwifi_cmd target_cmd;
 113         u32 chunk_size;
 114         const u8 *chunk_ptr;
 115         int ret = 0;
 116
 117         IWM_DBG_FW(iwm, INFO, "Loading FW chunk: %d bytes @ 0x%x\n",
 118                    img_desc->length, img_desc->address);
 119
 120         target_cmd.opcode = UMAC_HDI_OUT_OPCODE_WRITE;
 121         target_cmd.handle_by_hw = 1;
 122         target_cmd.op2 = 0;
 123         target_cmd.resp = 0;
 124         target_cmd.eop = 1;
 125
 126         chunk_size = img_desc->length;
 127         chunk_ptr = fw->data + img_desc->offset;
 128
 129         while (chunk_size > 0) {
 130                 u32 tmp_chunk_size;
 131
 132                 tmp_chunk_size = min_t(u32, chunk_size,
 133                                        IWM_MAX_NONWIFI_CMD_BUFF_SIZE);
 134
 135                 target_cmd.addr = cpu_to_le32(img_desc->address +
 136                                     (chunk_ptr - fw->data - img_desc->offset));
 137                 target_cmd.op1_sz = cpu_to_le32(tmp_chunk_size);
 138
 139                 IWM_DBG_FW(iwm, DBG, "\t%d bytes @ 0x%x\n",
 140                            tmp_chunk_size, target_cmd.addr);
 141
 142                 ret = iwm_hal_send_target_cmd(iwm, &target_cmd, chunk_ptr);
 143                 if (ret < 0) {
 144                         IWM_ERR(iwm, "Couldn't load FW chunk\n");
 145                         break;
 146                 }
 147
 148                 chunk_size -= tmp_chunk_size;
 149                 chunk_ptr += tmp_chunk_size;
 150         }
 151
 152         return ret;
 153 }
 154 /*
 155  * To load a fw image to the target, we basically go through the
 156  * fw, looking for OP_MEM_DESC records. Once we found one, we
 157  * pass it to iwm_load_firmware_chunk().
 158  * The OP_MEM_DESC records contain the actuall memory chunk to be
 159  * sent, but also the destination address.
 160  */
 161 static int iwm_load_img(struct iwm_priv *iwm, const char *img_name)
 162 {
 163         const struct firmware *fw;
 164         struct iwm_fw_img_desc *img_desc;
 165         struct iwm_fw_img_ver *ver;
 166         int ret = 0, fw_offset;
 167         u32 opcode_idx = 0, build_date;
 168         char *build_tag;
 169
 170         ret = request_firmware(&fw, img_name, iwm_to_dev(iwm));
 171         if (ret) {
 172                 IWM_ERR(iwm, "Request firmware failed");
 173                 return ret;
 174         }
 175
 176         IWM_DBG_FW(iwm, INFO, "Start to load FW %s\n", img_name);
 177
 178         while (1) {
 179                 fw_offset = iwm_fw_op_offset(iwm, fw,
 180                                              IWM_HDR_REC_OP_MEM_DESC,
 181                                              opcode_idx);
 182                 if (fw_offset < 0)
 183                         break;
 184
 185                 img_desc = (struct iwm_fw_img_desc *)(fw->data + fw_offset);
 186                 ret = iwm_load_firmware_chunk(iwm, fw, img_desc);
 187                 if (ret < 0)
 188                         goto err_release_fw;
 189                 opcode_idx++;
 190         }
 191
 192         /* Read firmware version */
 193         fw_offset = iwm_fw_op_offset(iwm, fw, IWM_HDR_REC_OP_SW_VER, 0);
 194         if (fw_offset < 0)
 195                 goto err_release_fw;
 196
 197         ver = (struct iwm_fw_img_ver *)(fw->data + fw_offset);
 198
 199         /* Read build tag */
 200         fw_offset = iwm_fw_op_offset(iwm, fw, IWM_HDR_REC_OP_BUILD_TAG, 0);
 201         if (fw_offset < 0)
 202                 goto err_release_fw;
 203
 204         build_tag = (char *)(fw->data + fw_offset);
 205
 206         /* Read build date */
 207         fw_offset = iwm_fw_op_offset(iwm, fw, IWM_HDR_REC_OP_BUILD_DATE, 0);
 208         if (fw_offset < 0)
 209                 goto err_release_fw;
 210
 211         build_date = *(u32 *)(fw->data + fw_offset);
 212
 213         IWM_INFO(iwm, "%s:\n", img_name);
 214         IWM_INFO(iwm, "\tVersion:    %02X.%02X\n", ver->major, ver->minor);
 215         IWM_INFO(iwm, "\tBuild tag:  %s\n", build_tag);
 216         IWM_INFO(iwm, "\tBuild date: %x-%x-%x\n",
 217                  IWM_BUILD_YEAR(build_date), IWM_BUILD_MONTH(build_date),
 218                  IWM_BUILD_DAY(build_date));
 219
 220         if (!strcmp(img_name, iwm->bus_ops->umac_name))
 221                 sprintf(iwm->umac_version, "%02X.%02X",
 222                         ver->major, ver->minor);
 223
 224         if (!strcmp(img_name, iwm->bus_ops->lmac_name))
 225                 sprintf(iwm->lmac_version, "%02X.%02X",
 226                         ver->major, ver->minor);
 227
 228  err_release_fw:
 229         release_firmware(fw);
 230
 231         return ret;
 232 }
 233
 234 static int iwm_load_umac(struct iwm_priv *iwm)
 235 {
 236         struct iwm_udma_nonwifi_cmd target_cmd;
 237         int ret;
 238
 239         ret = iwm_load_img(iwm, iwm->bus_ops->umac_name);
 240         if (ret < 0)
 241                 return ret;
 242
 243         /* We've loaded the UMAC, we can tell the target to jump there */
 244         target_cmd.opcode = UMAC_HDI_OUT_OPCODE_JUMP;
 245         target_cmd.addr = cpu_to_le32(UMAC_MU_FW_INST_DATA_12_ADDR);
 246         target_cmd.op1_sz = 0;
 247         target_cmd.op2 = 0;
 248         target_cmd.handle_by_hw = 0;
 249         target_cmd.resp = 1 ;
 250         target_cmd.eop = 1;
 251
 252         ret = iwm_hal_send_target_cmd(iwm, &target_cmd, NULL);
 253         if (ret < 0)
 254                 IWM_ERR(iwm, "Couldn't send JMP command\n");
 255
 256         return ret;
 257 }
 258
 259 static int iwm_load_lmac(struct iwm_priv *iwm, const char *img_name)
 260 {
 261         int ret;
 262
 263         ret = iwm_load_img(iwm, img_name);
 264         if (ret < 0)
 265                 return ret;
 266
 267         return iwm_send_umac_reset(iwm,
 268                         cpu_to_le32(UMAC_RST_CTRL_FLG_LARC_CLK_EN), 0);
 269 }
 270
 271 static int iwm_init_calib(struct iwm_priv *iwm, unsigned long cfg_bitmap,
 272                           unsigned long expected_bitmap, u8 rx_iq_cmd)
 273 {
 274         /* Read RX IQ calibration result from EEPROM */
 275         if (test_bit(rx_iq_cmd, &cfg_bitmap)) {
 276                 iwm_store_rxiq_calib_result(iwm);
 277                 set_bit(PHY_CALIBRATE_RX_IQ_CMD, &iwm->calib_done_map);
 278         }
 279
 280         iwm_send_prio_table(iwm);
 281         iwm_send_init_calib_cfg(iwm, cfg_bitmap);
 282
 283         while (iwm->calib_done_map != expected_bitmap) {
 284                 if (iwm_notif_handle(iwm, CALIBRATION_RES_NOTIFICATION,
 285                                      IWM_SRC_LMAC, WAIT_NOTIF_TIMEOUT)) {
 286                         IWM_DBG_FW(iwm, DBG, "Initial calibration timeout\n");
 287                         return -ETIMEDOUT;
 288                 }
 289
 290                 IWM_DBG_FW(iwm, DBG, "Got calibration result. calib_done_map: "
 291                            "0x%lx, expected calibrations: 0x%lx\n",
 292                            iwm->calib_done_map, expected_bitmap);
 293         }
 294
 295         return 0;
 296 }
 297
 298 /*
 299  * We currently have to load 3 FWs:
 300  * 1) The UMAC (Upper MAC).
 301  * 2) The calibration LMAC (Lower MAC).
 302  *    We then send the calibration init command, so that the device can
 303  *    run a first calibration round.
 304  * 3) The operational LMAC, which replaces the calibration one when it's
 305  *    done with the first calibration round.
 306  *
 307  * Once those 3 FWs have been loaded, we send the periodic calibration
 308  * command, and then the device is available for regular 802.11 operations.
 309  */
 310 int iwm_load_fw(struct iwm_priv *iwm)
 311 {
 312         unsigned long init_calib_map, periodic_calib_map;
 313         unsigned long expected_calib_map;
 314         int ret;
 315
 316         /* We first start downloading the UMAC */
 317         ret = iwm_load_umac(iwm);
 318         if (ret < 0) {
 319                 IWM_ERR(iwm, "UMAC loading failed\n");
 320                 return ret;
 321         }
 322
 323         /* Handle UMAC_ALIVE notification */
 324         ret = iwm_notif_handle(iwm, UMAC_NOTIFY_OPCODE_ALIVE, IWM_SRC_UMAC,
 325                                WAIT_NOTIF_TIMEOUT);
 326         if (ret) {
 327                 IWM_ERR(iwm, "Handle UMAC_ALIVE failed: %d\n", ret);
 328                 return ret;
 329         }
 330
 331         /* UMAC is alive, we can download the calibration LMAC */
 332         ret = iwm_load_lmac(iwm, iwm->bus_ops->calib_lmac_name);
 333         if (ret) {
 334                 IWM_ERR(iwm, "Calibration LMAC loading failed\n");
 335                 return ret;
 336         }
 337
 338         /* Handle UMAC_INIT_COMPLETE notification */
 339         ret = iwm_notif_handle(iwm, UMAC_NOTIFY_OPCODE_INIT_COMPLETE,
 340                                IWM_SRC_UMAC, WAIT_NOTIF_TIMEOUT);
 341         if (ret) {
 342                 IWM_ERR(iwm, "Handle INIT_COMPLETE failed for calibration "
 343                         "LMAC: %d\n", ret);
 344                 return ret;
 345         }
 346
 347         /* Read EEPROM data */
 348         ret = iwm_eeprom_init(iwm);
 349         if (ret < 0) {
 350                 IWM_ERR(iwm, "Couldn't init eeprom array\n");
 351                 return ret;
 352         }
 353
 354         init_calib_map = iwm->conf.calib_map & IWM_CALIB_MAP_INIT_MSK;
 355         expected_calib_map = iwm->conf.expected_calib_map &
 356                 IWM_CALIB_MAP_INIT_MSK;
 357         periodic_calib_map = IWM_CALIB_MAP_PER_LMAC(iwm->conf.calib_map);
 358
 359         ret = iwm_init_calib(iwm, init_calib_map, expected_calib_map,
 360                              CALIB_CFG_RX_IQ_IDX);
 361         if (ret < 0) {
 362                 /* Let's try the old way */
 363                 ret = iwm_init_calib(iwm, expected_calib_map,
 364                                      expected_calib_map,
 365                                      PHY_CALIBRATE_RX_IQ_CMD);
 366                 if (ret < 0) {
 367                         IWM_ERR(iwm, "Calibration result timeout\n");
 368                         goto out;
 369                 }
 370         }
 371
 372         /* Handle LMAC CALIBRATION_COMPLETE notification */
 373         ret = iwm_notif_handle(iwm, CALIBRATION_COMPLETE_NOTIFICATION,
 374                                IWM_SRC_LMAC, WAIT_NOTIF_TIMEOUT);
 375         if (ret) {
 376                 IWM_ERR(iwm, "Wait for CALIBRATION_COMPLETE timeout\n");
 377                 goto out;
 378         }
 379
 380         IWM_INFO(iwm, "LMAC calibration done: 0x%lx\n", iwm->calib_done_map);
 381
 382         iwm_send_umac_reset(iwm, cpu_to_le32(UMAC_RST_CTRL_FLG_LARC_RESET), 1);
 383
 384         ret = iwm_notif_handle(iwm, UMAC_CMD_OPCODE_RESET, IWM_SRC_UMAC,
 385                                WAIT_NOTIF_TIMEOUT);
 386         if (ret) {
 387                 IWM_ERR(iwm, "Wait for UMAC RESET timeout\n");
 388                 goto out;
 389         }
 390
 391         /* Download the operational LMAC */
 392         ret = iwm_load_lmac(iwm, iwm->bus_ops->lmac_name);
 393         if (ret) {
 394                 IWM_ERR(iwm, "LMAC loading failed\n");
 395                 goto out;
 396         }
 397
 398         ret = iwm_notif_handle(iwm, UMAC_NOTIFY_OPCODE_INIT_COMPLETE,
 399                                IWM_SRC_UMAC, WAIT_NOTIF_TIMEOUT);
 400         if (ret) {
 401                 IWM_ERR(iwm, "Handle INIT_COMPLETE failed for LMAC: %d\n", ret);
 402                 goto out;
 403         }
 404
 405         iwm_send_prio_table(iwm);
 406         iwm_send_calib_results(iwm);
 407         iwm_send_periodic_calib_cfg(iwm, periodic_calib_map);
 408         iwm_send_ct_kill_cfg(iwm, iwm->conf.ct_kill_entry,
 409                              iwm->conf.ct_kill_exit);
 410
 411         return 0;
 412
 413  out:
 414         iwm_eeprom_exit(iwm);
 415         return ret;
 416 }