drivers/net/wireless/iwlwifi/iwl-ucode.c

   1 /******************************************************************************
   2  *
   3  * GPL LICENSE SUMMARY
   4  *
   5  * Copyright(c) 2008 - 2012 Intel Corporation. All rights reserved.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of version 2 of the GNU General Public License as
   9  * published by the Free Software Foundation.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
  19  * USA
  20  *
  21  * The full GNU General Public License is included in this distribution
  22  * in the file called LICENSE.GPL.
  23  *
  24  * Contact Information:
  25  *  Intel Linux Wireless <ilw@linux.intel.com>
  26  * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  27  *
  28  *****************************************************************************/
  29
  30 #include <linux/kernel.h>
  31 #include <linux/init.h>
  32
  33 #include "iwl-dev.h"
  34 #include "iwl-io.h"
  35 #include "iwl-agn-hw.h"
  36 #include "iwl-agn.h"
  37 #include "iwl-agn-calib.h"
  38 #include "iwl-trans.h"
  39 #include "iwl-fh.h"
  40 #include "iwl-op-mode.h"
  41
  42 /******************************************************************************
  43  *
  44  * uCode download functions
  45  *
  46  ******************************************************************************/
  47
  48 static inline const struct fw_img *
  49 iwl_get_ucode_image(struct iwl_priv *priv, enum iwl_ucode_type ucode_type)
  50 {
  51         if (ucode_type >= IWL_UCODE_TYPE_MAX)
  52                 return NULL;
  53
  54         return &priv->fw->img[ucode_type];
  55 }
  56
  57 /*
  58  *  Calibration
  59  */
  60 static int iwl_set_Xtal_calib(struct iwl_priv *priv)
  61 {
  62         struct iwl_calib_xtal_freq_cmd cmd;
  63         __le16 *xtal_calib =
  64                 (__le16 *)iwl_eeprom_query_addr(priv, EEPROM_XTAL);
  65
  66         iwl_set_calib_hdr(&cmd.hdr, IWL_PHY_CALIBRATE_CRYSTAL_FRQ_CMD);
  67         cmd.cap_pin1 = le16_to_cpu(xtal_calib[0]);
  68         cmd.cap_pin2 = le16_to_cpu(xtal_calib[1]);
  69         return iwl_calib_set(priv, (void *)&cmd, sizeof(cmd));
  70 }
  71
  72 static int iwl_set_temperature_offset_calib(struct iwl_priv *priv)
  73 {
  74         struct iwl_calib_temperature_offset_cmd cmd;
  75         __le16 *offset_calib =
  76                 (__le16 *)iwl_eeprom_query_addr(priv, EEPROM_RAW_TEMPERATURE);
  77
  78         memset(&cmd, 0, sizeof(cmd));
  79         iwl_set_calib_hdr(&cmd.hdr, IWL_PHY_CALIBRATE_TEMP_OFFSET_CMD);
  80         memcpy(&cmd.radio_sensor_offset, offset_calib, sizeof(*offset_calib));
  81         if (!(cmd.radio_sensor_offset))
  82                 cmd.radio_sensor_offset = DEFAULT_RADIO_SENSOR_OFFSET;
  83
  84         IWL_DEBUG_CALIB(priv, "Radio sensor offset: %d\n",
  85                         le16_to_cpu(cmd.radio_sensor_offset));
  86         return iwl_calib_set(priv, (void *)&cmd, sizeof(cmd));
  87 }
  88
  89 static int iwl_set_temperature_offset_calib_v2(struct iwl_priv *priv)
  90 {
  91         struct iwl_calib_temperature_offset_v2_cmd cmd;
  92         __le16 *offset_calib_high = (__le16 *)iwl_eeprom_query_addr(priv,
  93                                      EEPROM_KELVIN_TEMPERATURE);
  94         __le16 *offset_calib_low =
  95                 (__le16 *)iwl_eeprom_query_addr(priv, EEPROM_RAW_TEMPERATURE);
  96         struct iwl_eeprom_calib_hdr *hdr;
  97
  98         memset(&cmd, 0, sizeof(cmd));
  99         iwl_set_calib_hdr(&cmd.hdr, IWL_PHY_CALIBRATE_TEMP_OFFSET_CMD);
 100         hdr = (struct iwl_eeprom_calib_hdr *)iwl_eeprom_query_addr(priv,
 101                                                         EEPROM_CALIB_ALL);
 102         memcpy(&cmd.radio_sensor_offset_high, offset_calib_high,
 103                 sizeof(*offset_calib_high));
 104         memcpy(&cmd.radio_sensor_offset_low, offset_calib_low,
 105                 sizeof(*offset_calib_low));
 106         if (!(cmd.radio_sensor_offset_low)) {
 107                 IWL_DEBUG_CALIB(priv, "no info in EEPROM, use default\n");
 108                 cmd.radio_sensor_offset_low = DEFAULT_RADIO_SENSOR_OFFSET;
 109                 cmd.radio_sensor_offset_high = DEFAULT_RADIO_SENSOR_OFFSET;
 110         }
 111         memcpy(&cmd.burntVoltageRef, &hdr->voltage,
 112                 sizeof(hdr->voltage));
 113
 114         IWL_DEBUG_CALIB(priv, "Radio sensor offset high: %d\n",
 115                         le16_to_cpu(cmd.radio_sensor_offset_high));
 116         IWL_DEBUG_CALIB(priv, "Radio sensor offset low: %d\n",
 117                         le16_to_cpu(cmd.radio_sensor_offset_low));
 118         IWL_DEBUG_CALIB(priv, "Voltage Ref: %d\n",
 119                         le16_to_cpu(cmd.burntVoltageRef));
 120
 121         return iwl_calib_set(priv, (void *)&cmd, sizeof(cmd));
 122 }
 123
 124 static int iwl_send_calib_cfg(struct iwl_priv *priv)
 125 {
 126         struct iwl_calib_cfg_cmd calib_cfg_cmd;
 127         struct iwl_host_cmd cmd = {
 128                 .id = CALIBRATION_CFG_CMD,
 129                 .len = { sizeof(struct iwl_calib_cfg_cmd), },
 130                 .data = { &calib_cfg_cmd, },
 131         };
 132
 133         memset(&calib_cfg_cmd, 0, sizeof(calib_cfg_cmd));
 134         calib_cfg_cmd.ucd_calib_cfg.once.is_enable = IWL_CALIB_INIT_CFG_ALL;
 135         calib_cfg_cmd.ucd_calib_cfg.once.start = IWL_CALIB_INIT_CFG_ALL;
 136         calib_cfg_cmd.ucd_calib_cfg.once.send_res = IWL_CALIB_INIT_CFG_ALL;
 137         calib_cfg_cmd.ucd_calib_cfg.flags =
 138                 IWL_CALIB_CFG_FLAG_SEND_COMPLETE_NTFY_MSK;
 139
 140         return iwl_dvm_send_cmd(priv, &cmd);
 141 }
 142
 143 int iwl_init_alive_start(struct iwl_priv *priv)
 144 {
 145         int ret;
 146
 147         if (priv->cfg->bt_params &&
 148             priv->cfg->bt_params->advanced_bt_coexist) {
 149                 /*
 150                  * Tell uCode we are ready to perform calibration
 151                  * need to perform this before any calibration
 152                  * no need to close the envlope since we are going
 153                  * to load the runtime uCode later.
 154                  */
 155                 ret = iwl_send_bt_env(priv, IWL_BT_COEX_ENV_OPEN,
 156                         BT_COEX_PRIO_TBL_EVT_INIT_CALIB2);
 157                 if (ret)
 158                         return ret;
 159
 160         }
 161
 162         ret = iwl_send_calib_cfg(priv);
 163         if (ret)
 164                 return ret;
 165
 166         /**
 167          * temperature offset calibration is only needed for runtime ucode,
 168          * so prepare the value now.
 169          */
 170         if (priv->cfg->need_temp_offset_calib) {
 171                 if (priv->cfg->temp_offset_v2)
 172                         return iwl_set_temperature_offset_calib_v2(priv);
 173                 else
 174                         return iwl_set_temperature_offset_calib(priv);
 175         }
 176
 177         return 0;
 178 }
 179
 180 int iwl_send_wimax_coex(struct iwl_priv *priv)
 181 {
 182         struct iwl_wimax_coex_cmd coex_cmd;
 183
 184         /* coexistence is disabled */
 185         memset(&coex_cmd, 0, sizeof(coex_cmd));
 186
 187         return iwl_dvm_send_cmd_pdu(priv,
 188                                 COEX_PRIORITY_TABLE_CMD, CMD_SYNC,
 189                                 sizeof(coex_cmd), &coex_cmd);
 190 }
 191
 192 static const u8 iwl_bt_prio_tbl[BT_COEX_PRIO_TBL_EVT_MAX] = {
 193         ((BT_COEX_PRIO_TBL_PRIO_BYPASS << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
 194                 (0 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
 195         ((BT_COEX_PRIO_TBL_PRIO_BYPASS << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
 196                 (1 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
 197         ((BT_COEX_PRIO_TBL_PRIO_LOW << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
 198                 (0 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
 199         ((BT_COEX_PRIO_TBL_PRIO_LOW << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
 200                 (1 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
 201         ((BT_COEX_PRIO_TBL_PRIO_HIGH << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
 202                 (0 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
 203         ((BT_COEX_PRIO_TBL_PRIO_HIGH << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
 204                 (1 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
 205         ((BT_COEX_PRIO_TBL_PRIO_BYPASS << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
 206                 (0 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
 207         ((BT_COEX_PRIO_TBL_PRIO_COEX_OFF << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
 208                 (0 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
 209         ((BT_COEX_PRIO_TBL_PRIO_COEX_ON << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
 210                 (0 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
 211         0, 0, 0, 0, 0, 0, 0
 212 };
 213
 214 void iwl_send_prio_tbl(struct iwl_priv *priv)
 215 {
 216         struct iwl_bt_coex_prio_table_cmd prio_tbl_cmd;
 217
 218         memcpy(prio_tbl_cmd.prio_tbl, iwl_bt_prio_tbl,
 219                 sizeof(iwl_bt_prio_tbl));
 220         if (iwl_dvm_send_cmd_pdu(priv,
 221                                 REPLY_BT_COEX_PRIO_TABLE, CMD_SYNC,
 222                                 sizeof(prio_tbl_cmd), &prio_tbl_cmd))
 223                 IWL_ERR(priv, "failed to send BT prio tbl command\n");
 224 }
 225
 226 int iwl_send_bt_env(struct iwl_priv *priv, u8 action, u8 type)
 227 {
 228         struct iwl_bt_coex_prot_env_cmd env_cmd;
 229         int ret;
 230
 231         env_cmd.action = action;
 232         env_cmd.type = type;
 233         ret = iwl_dvm_send_cmd_pdu(priv,
 234                                REPLY_BT_COEX_PROT_ENV, CMD_SYNC,
 235                                sizeof(env_cmd), &env_cmd);
 236         if (ret)
 237                 IWL_ERR(priv, "failed to send BT env command\n");
 238         return ret;
 239 }
 240
 241
 242 static int iwl_alive_notify(struct iwl_priv *priv)
 243 {
 244         int ret;
 245
 246         iwl_trans_fw_alive(priv->trans);
 247
 248         priv->passive_no_rx = false;
 249         priv->transport_queue_stop = 0;
 250
 251         ret = iwl_send_wimax_coex(priv);
 252         if (ret)
 253                 return ret;
 254
 255         if (!priv->cfg->no_xtal_calib) {
 256                 ret = iwl_set_Xtal_calib(priv);
 257                 if (ret)
 258                         return ret;
 259         }
 260
 261         return iwl_send_calib_results(priv);
 262 }
 263
 264
 265 /**
 266  * iwl_verify_inst_sparse - verify runtime uCode image in card vs. host,
 267  *   using sample data 100 bytes apart.  If these sample points are good,
 268  *   it's a pretty good bet that everything between them is good, too.
 269  */
 270 static int iwl_verify_sec_sparse(struct iwl_priv *priv,
 271                                   const struct fw_desc *fw_desc)
 272 {
 273         __le32 *image = (__le32 *)fw_desc->v_addr;
 274         u32 len = fw_desc->len;
 275         u32 val;
 276         u32 i;
 277
 278         IWL_DEBUG_FW(priv, "ucode inst image size is %u\n", len);
 279
 280         for (i = 0; i < len; i += 100, image += 100/sizeof(u32)) {
 281                 /* read data comes through single port, auto-incr addr */
 282                 /* NOTE: Use the debugless read so we don't flood kernel log
 283                  * if IWL_DL_IO is set */
 284                 iwl_write_direct32(priv->trans, HBUS_TARG_MEM_RADDR,
 285                         i + fw_desc->offset);
 286                 val = iwl_read32(priv->trans, HBUS_TARG_MEM_RDAT);
 287                 if (val != le32_to_cpu(*image))
 288                         return -EIO;
 289         }
 290
 291         return 0;
 292 }
 293
 294 static void iwl_print_mismatch_sec(struct iwl_priv *priv,
 295                                     const struct fw_desc *fw_desc)
 296 {
 297         __le32 *image = (__le32 *)fw_desc->v_addr;
 298         u32 len = fw_desc->len;
 299         u32 val;
 300         u32 offs;
 301         int errors = 0;
 302
 303         IWL_DEBUG_FW(priv, "ucode inst image size is %u\n", len);
 304
 305         iwl_write_direct32(priv->trans, HBUS_TARG_MEM_RADDR,
 306                                 fw_desc->offset);
 307
 308         for (offs = 0;
 309              offs < len && errors < 20;
 310              offs += sizeof(u32), image++) {
 311                 /* read data comes through single port, auto-incr addr */
 312                 val = iwl_read32(priv->trans, HBUS_TARG_MEM_RDAT);
 313                 if (val != le32_to_cpu(*image)) {
 314                         IWL_ERR(priv, "uCode INST section at "
 315                                 "offset 0x%x, is 0x%x, s/b 0x%x\n",
 316                                 offs, val, le32_to_cpu(*image));
 317                         errors++;
 318                 }
 319         }
 320 }
 321
 322 /**
 323  * iwl_verify_ucode - determine which instruction image is in SRAM,
 324  *    and verify its contents
 325  */
 326 static int iwl_verify_ucode(struct iwl_priv *priv,
 327                             enum iwl_ucode_type ucode_type)
 328 {
 329         const struct fw_img *img = iwl_get_ucode_image(priv, ucode_type);
 330
 331         if (!img) {
 332                 IWL_ERR(priv, "Invalid ucode requested (%d)\n", ucode_type);
 333                 return -EINVAL;
 334         }
 335
 336         if (!iwl_verify_sec_sparse(priv, &img->sec[IWL_UCODE_SECTION_INST])) {
 337                 IWL_DEBUG_FW(priv, "uCode is good in inst SRAM\n");
 338                 return 0;
 339         }
 340
 341         IWL_ERR(priv, "UCODE IMAGE IN INSTRUCTION SRAM NOT VALID!!\n");
 342
 343         iwl_print_mismatch_sec(priv, &img->sec[IWL_UCODE_SECTION_INST]);
 344         return -EIO;
 345 }
 346
 347 struct iwl_alive_data {
 348         bool valid;
 349         u8 subtype;
 350 };
 351
 352 static bool iwl_alive_fn(struct iwl_notif_wait_data *notif_wait,
 353                          struct iwl_rx_packet *pkt, void *data)
 354 {
 355         struct iwl_priv *priv =
 356                 container_of(notif_wait, struct iwl_priv, notif_wait);
 357         struct iwl_alive_data *alive_data = data;
 358         struct iwl_alive_resp *palive;
 359
 360         palive = (void *)pkt->data;
 361
 362         IWL_DEBUG_FW(priv, "Alive ucode status 0x%08X revision "
 363                        "0x%01X 0x%01X\n",
 364                        palive->is_valid, palive->ver_type,
 365                        palive->ver_subtype);
 366
 367         priv->device_pointers.error_event_table =
 368                 le32_to_cpu(palive->error_event_table_ptr);
 369         priv->device_pointers.log_event_table =
 370                 le32_to_cpu(palive->log_event_table_ptr);
 371
 372         alive_data->subtype = palive->ver_subtype;
 373         alive_data->valid = palive->is_valid == UCODE_VALID_OK;
 374
 375         return true;
 376 }
 377
 378 #define UCODE_ALIVE_TIMEOUT     HZ
 379 #define UCODE_CALIB_TIMEOUT     (2*HZ)
 380
 381 int iwl_load_ucode_wait_alive(struct iwl_priv *priv,
 382                                  enum iwl_ucode_type ucode_type)
 383 {
 384         struct iwl_notification_wait alive_wait;
 385         struct iwl_alive_data alive_data;
 386         const struct fw_img *fw;
 387         int ret;
 388         enum iwl_ucode_type old_type;
 389         static const u8 alive_cmd[] = { REPLY_ALIVE };
 390
 391         old_type = priv->cur_ucode;
 392         priv->cur_ucode = ucode_type;
 393         fw = iwl_get_ucode_image(priv, ucode_type);
 394
 395         priv->ucode_loaded = false;
 396
 397         if (!fw)
 398                 return -EINVAL;
 399
 400         iwl_init_notification_wait(&priv->notif_wait, &alive_wait,
 401                                    alive_cmd, ARRAY_SIZE(alive_cmd),
 402                                    iwl_alive_fn, &alive_data);
 403
 404         ret = iwl_trans_start_fw(priv->trans, fw);
 405         if (ret) {
 406                 priv->cur_ucode = old_type;
 407                 iwl_remove_notification(&priv->notif_wait, &alive_wait);
 408                 return ret;
 409         }
 410
 411         /*
 412          * Some things may run in the background now, but we
 413          * just wait for the ALIVE notification here.
 414          */
 415         ret = iwl_wait_notification(&priv->notif_wait, &alive_wait,
 416                                         UCODE_ALIVE_TIMEOUT);
 417         if (ret) {
 418                 priv->cur_ucode = old_type;
 419                 return ret;
 420         }
 421
 422         if (!alive_data.valid) {
 423                 IWL_ERR(priv, "Loaded ucode is not valid!\n");
 424                 priv->cur_ucode = old_type;
 425                 return -EIO;
 426         }
 427
 428         /*
 429          * This step takes a long time (60-80ms!!) and
 430          * WoWLAN image should be loaded quickly, so
 431          * skip it for WoWLAN.
 432          */
 433         if (ucode_type != IWL_UCODE_WOWLAN) {
 434                 ret = iwl_verify_ucode(priv, ucode_type);
 435                 if (ret) {
 436                         priv->cur_ucode = old_type;
 437                         return ret;
 438                 }
 439
 440                 /* delay a bit to give rfkill time to run */
 441                 msleep(5);
 442         }
 443
 444         ret = iwl_alive_notify(priv);
 445         if (ret) {
 446                 IWL_WARN(priv,
 447                         "Could not complete ALIVE transition: %d\n", ret);
 448                 priv->cur_ucode = old_type;
 449                 return ret;
 450         }
 451
 452         priv->ucode_loaded = true;
 453
 454         return 0;
 455 }
 456
 457 static bool iwlagn_wait_calib(struct iwl_notif_wait_data *notif_wait,
 458                               struct iwl_rx_packet *pkt, void *data)
 459 {
 460         struct iwl_priv *priv = data;
 461         struct iwl_calib_hdr *hdr;
 462         int len;
 463
 464         if (pkt->hdr.cmd != CALIBRATION_RES_NOTIFICATION) {
 465                 WARN_ON(pkt->hdr.cmd != CALIBRATION_COMPLETE_NOTIFICATION);
 466                 return true;
 467         }
 468
 469         hdr = (struct iwl_calib_hdr *)pkt->data;
 470         len = le32_to_cpu(pkt->len_n_flags) & FH_RSCSR_FRAME_SIZE_MSK;
 471
 472         /* reduce the size by the length field itself */
 473         len -= sizeof(__le32);
 474
 475         if (iwl_calib_set(priv, hdr, len))
 476                 IWL_ERR(priv, "Failed to record calibration data %d\n",
 477                         hdr->op_code);
 478
 479         return false;
 480 }
 481
 482 int iwl_run_init_ucode(struct iwl_priv *priv)
 483 {
 484         struct iwl_notification_wait calib_wait;
 485         static const u8 calib_complete[] = {
 486                 CALIBRATION_RES_NOTIFICATION,
 487                 CALIBRATION_COMPLETE_NOTIFICATION
 488         };
 489         int ret;
 490
 491         lockdep_assert_held(&priv->mutex);
 492
 493         /* No init ucode required? Curious, but maybe ok */
 494         if (!priv->fw->img[IWL_UCODE_INIT].sec[0].len)
 495                 return 0;
 496
 497         if (priv->init_ucode_run)
 498                 return 0;
 499
 500         iwl_init_notification_wait(&priv->notif_wait, &calib_wait,
 501                                    calib_complete, ARRAY_SIZE(calib_complete),
 502                                    iwlagn_wait_calib, priv);
 503
 504         /* Will also start the device */
 505         ret = iwl_load_ucode_wait_alive(priv, IWL_UCODE_INIT);
 506         if (ret)
 507                 goto error;
 508
 509         ret = iwl_init_alive_start(priv);
 510         if (ret)
 511                 goto error;
 512
 513         /*
 514          * Some things may run in the background now, but we
 515          * just wait for the calibration complete notification.
 516          */
 517         ret = iwl_wait_notification(&priv->notif_wait, &calib_wait,
 518                                         UCODE_CALIB_TIMEOUT);
 519         if (!ret)
 520                 priv->init_ucode_run = true;
 521
 522         goto out;
 523
 524  error:
 525         iwl_remove_notification(&priv->notif_wait, &calib_wait);
 526  out:
 527         /* Whatever happened, stop the device */
 528         iwl_trans_stop_device(priv->trans);
 529         priv->ucode_loaded = false;
 530
 531         return ret;
 532 }