1/****************************************************************************** 2 * 3 * Copyright(c) 2003 - 2011 Intel Corporation. All rights reserved. 4 * 5 * Portions of this file are derived from the ipw3945 project, as well 6 * as portions of the ieee80211 subsystem header files. 7 * 8 * This program is free software; you can redistribute it and/or modify it 9 * under the terms of version 2 of the GNU General Public License as 10 * published by the Free Software Foundation. 11 * 12 * This program is distributed in the hope that it will be useful, but WITHOUT 13 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 14 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 15 * more details. 16 * 17 * You should have received a copy of the GNU General Public License along with 18 * this program; if not, write to the Free Software Foundation, Inc., 19 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA 20 * 21 * The full GNU General Public License is included in this distribution in the 22 * file called LICENSE. 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#include <linux/kernel.h> 30#include <linux/module.h> 31#include <linux/init.h> 32#include <linux/slab.h> 33#include <linux/delay.h> 34#include <linux/sched.h> 35#include <linux/skbuff.h> 36#include <linux/netdevice.h> 37#include <linux/firmware.h> 38#include <linux/etherdevice.h> 39#include <linux/if_arp.h> 40 41#include <net/mac80211.h> 42 43#include <asm/div64.h> 44 45#include "iwl-eeprom.h" 46#include "iwl-wifi.h" 47#include "iwl-dev.h" 48#include "iwl-core.h" 49#include "iwl-io.h" 50#include "iwl-agn-calib.h" 51#include "iwl-agn.h" 52#include "iwl-shared.h" 53#include "iwl-bus.h" 54#include "iwl-trans.h" 55 56/****************************************************************************** 57 * 58 * module boiler plate 59 * 60 ******************************************************************************/ 61 62/* 63 * module name, copyright, version, etc. 64 */ 65#define DRV_DESCRIPTION "Intel(R) Wireless WiFi Link AGN driver for Linux" 66 67#ifdef CONFIG_IWLWIFI_DEBUG 68#define VD "d" 69#else 70#define VD 71#endif 72 73#define DRV_VERSION IWLWIFI_VERSION VD 74 75 76MODULE_DESCRIPTION(DRV_DESCRIPTION); 77MODULE_VERSION(DRV_VERSION); 78MODULE_AUTHOR(DRV_COPYRIGHT " " DRV_AUTHOR); 79MODULE_LICENSE("GPL"); 80MODULE_ALIAS("iwlagn"); 81 82void iwl_update_chain_flags(struct iwl_priv *priv) 83{ 84 struct iwl_rxon_context *ctx; 85 86 for_each_context(priv, ctx) { 87 iwlagn_set_rxon_chain(priv, ctx); 88 if (ctx->active.rx_chain != ctx->staging.rx_chain) 89 iwlagn_commit_rxon(priv, ctx); 90 } 91} 92 93/* Parse the beacon frame to find the TIM element and set tim_idx & tim_size */ 94static void iwl_set_beacon_tim(struct iwl_priv *priv, 95 struct iwl_tx_beacon_cmd *tx_beacon_cmd, 96 u8 *beacon, u32 frame_size) 97{ 98 u16 tim_idx; 99 struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)beacon; 100 101 /* 102 * The index is relative to frame start but we start looking at the 103 * variable-length part of the beacon. 104 */ 105 tim_idx = mgmt->u.beacon.variable - beacon; 106 107 /* Parse variable-length elements of beacon to find WLAN_EID_TIM */ 108 while ((tim_idx < (frame_size - 2)) && 109 (beacon[tim_idx] != WLAN_EID_TIM)) 110 tim_idx += beacon[tim_idx+1] + 2; 111 112 /* If TIM field was found, set variables */ 113 if ((tim_idx < (frame_size - 1)) && (beacon[tim_idx] == WLAN_EID_TIM)) { 114 tx_beacon_cmd->tim_idx = cpu_to_le16(tim_idx); 115 tx_beacon_cmd->tim_size = beacon[tim_idx+1]; 116 } else 117 IWL_WARN(priv, "Unable to find TIM Element in beacon\n"); 118} 119 120int iwlagn_send_beacon_cmd(struct iwl_priv *priv) 121{ 122 struct iwl_tx_beacon_cmd *tx_beacon_cmd; 123 struct iwl_host_cmd cmd = { 124 .id = REPLY_TX_BEACON, 125 .flags = CMD_SYNC, 126 }; 127 struct ieee80211_tx_info *info; 128 u32 frame_size; 129 u32 rate_flags; 130 u32 rate; 131 132 /* 133 * We have to set up the TX command, the TX Beacon command, and the 134 * beacon contents. 135 */ 136 137 lockdep_assert_held(&priv->shrd->mutex); 138 139 if (!priv->beacon_ctx) { 140 IWL_ERR(priv, "trying to build beacon w/o beacon context!\n"); 141 return 0; 142 } 143 144 if (WARN_ON(!priv->beacon_skb)) 145 return -EINVAL; 146 147 /* Allocate beacon command */ 148 if (!priv->beacon_cmd) 149 priv->beacon_cmd = kzalloc(sizeof(*tx_beacon_cmd), GFP_KERNEL); 150 tx_beacon_cmd = priv->beacon_cmd; 151 if (!tx_beacon_cmd) 152 return -ENOMEM; 153 154 frame_size = priv->beacon_skb->len; 155 156 /* Set up TX command fields */ 157 tx_beacon_cmd->tx.len = cpu_to_le16((u16)frame_size); 158 tx_beacon_cmd->tx.sta_id = priv->beacon_ctx->bcast_sta_id; 159 tx_beacon_cmd->tx.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE; 160 tx_beacon_cmd->tx.tx_flags = TX_CMD_FLG_SEQ_CTL_MSK | 161 TX_CMD_FLG_TSF_MSK | TX_CMD_FLG_STA_RATE_MSK; 162 163 /* Set up TX beacon command fields */ 164 iwl_set_beacon_tim(priv, tx_beacon_cmd, priv->beacon_skb->data, 165 frame_size); 166 167 /* Set up packet rate and flags */ 168 info = IEEE80211_SKB_CB(priv->beacon_skb); 169 170 /* 171 * Let's set up the rate at least somewhat correctly; 172 * it will currently not actually be used by the uCode, 173 * it uses the broadcast station's rate instead. 174 */ 175 if (info->control.rates[0].idx < 0 || 176 info->control.rates[0].flags & IEEE80211_TX_RC_MCS) 177 rate = 0; 178 else 179 rate = info->control.rates[0].idx; 180 181 priv->mgmt_tx_ant = iwl_toggle_tx_ant(priv, priv->mgmt_tx_ant, 182 hw_params(priv).valid_tx_ant); 183 rate_flags = iwl_ant_idx_to_flags(priv->mgmt_tx_ant); 184 185 /* In mac80211, rates for 5 GHz start at 0 */ 186 if (info->band == IEEE80211_BAND_5GHZ) 187 rate += IWL_FIRST_OFDM_RATE; 188 else if (rate >= IWL_FIRST_CCK_RATE && rate <= IWL_LAST_CCK_RATE) 189 rate_flags |= RATE_MCS_CCK_MSK; 190 191 tx_beacon_cmd->tx.rate_n_flags = 192 iwl_hw_set_rate_n_flags(rate, rate_flags); 193 194 /* Submit command */ 195 cmd.len[0] = sizeof(*tx_beacon_cmd); 196 cmd.data[0] = tx_beacon_cmd; 197 cmd.dataflags[0] = IWL_HCMD_DFL_NOCOPY; 198 cmd.len[1] = frame_size; 199 cmd.data[1] = priv->beacon_skb->data; 200 cmd.dataflags[1] = IWL_HCMD_DFL_NOCOPY; 201 202 return iwl_trans_send_cmd(trans(priv), &cmd); 203} 204 205static void iwl_bg_beacon_update(struct work_struct *work) 206{ 207 struct iwl_priv *priv = 208 container_of(work, struct iwl_priv, beacon_update); 209 struct sk_buff *beacon; 210 211 mutex_lock(&priv->shrd->mutex); 212 if (!priv->beacon_ctx) { 213 IWL_ERR(priv, "updating beacon w/o beacon context!\n"); 214 goto out; 215 } 216 217 if (priv->beacon_ctx->vif->type != NL80211_IFTYPE_AP) { 218 /* 219 * The ucode will send beacon notifications even in 220 * IBSS mode, but we don't want to process them. But 221 * we need to defer the type check to here due to 222 * requiring locking around the beacon_ctx access. 223 */ 224 goto out; 225 } 226 227 /* Pull updated AP beacon from mac80211. will fail if not in AP mode */ 228 beacon = ieee80211_beacon_get(priv->hw, priv->beacon_ctx->vif); 229 if (!beacon) { 230 IWL_ERR(priv, "update beacon failed -- keeping old\n"); 231 goto out; 232 } 233 234 /* new beacon skb is allocated every time; dispose previous.*/ 235 dev_kfree_skb(priv->beacon_skb); 236 237 priv->beacon_skb = beacon; 238 239 iwlagn_send_beacon_cmd(priv); 240 out: 241 mutex_unlock(&priv->shrd->mutex); 242} 243 244static void iwl_bg_bt_runtime_config(struct work_struct *work) 245{ 246 struct iwl_priv *priv = 247 container_of(work, struct iwl_priv, bt_runtime_config); 248 249 if (test_bit(STATUS_EXIT_PENDING, &priv->shrd->status)) 250 return; 251 252 /* dont send host command if rf-kill is on */ 253 if (!iwl_is_ready_rf(priv->shrd)) 254 return; 255 iwlagn_send_advance_bt_config(priv); 256} 257 258static void iwl_bg_bt_full_concurrency(struct work_struct *work) 259{ 260 struct iwl_priv *priv = 261 container_of(work, struct iwl_priv, bt_full_concurrency); 262 struct iwl_rxon_context *ctx; 263 264 mutex_lock(&priv->shrd->mutex); 265 266 if (test_bit(STATUS_EXIT_PENDING, &priv->shrd->status)) 267 goto out; 268 269 /* dont send host command if rf-kill is on */ 270 if (!iwl_is_ready_rf(priv->shrd)) 271 goto out; 272 273 IWL_DEBUG_INFO(priv, "BT coex in %s mode\n", 274 priv->bt_full_concurrent ? 275 "full concurrency" : "3-wire"); 276 277 /* 278 * LQ & RXON updated cmds must be sent before BT Config cmd 279 * to avoid 3-wire collisions 280 */ 281 for_each_context(priv, ctx) { 282 iwlagn_set_rxon_chain(priv, ctx); 283 iwlagn_commit_rxon(priv, ctx); 284 } 285 286 iwlagn_send_advance_bt_config(priv); 287out: 288 mutex_unlock(&priv->shrd->mutex); 289} 290 291/** 292 * iwl_bg_statistics_periodic - Timer callback to queue statistics 293 * 294 * This callback is provided in order to send a statistics request. 295 * 296 * This timer function is continually reset to execute within 297 * REG_RECALIB_PERIOD seconds since the last STATISTICS_NOTIFICATION 298 * was received. We need to ensure we receive the statistics in order 299 * to update the temperature used for calibrating the TXPOWER. 300 */ 301static void iwl_bg_statistics_periodic(unsigned long data) 302{ 303 struct iwl_priv *priv = (struct iwl_priv *)data; 304 305 if (test_bit(STATUS_EXIT_PENDING, &priv->shrd->status)) 306 return; 307 308 /* dont send host command if rf-kill is on */ 309 if (!iwl_is_ready_rf(priv->shrd)) 310 return; 311 312 iwl_send_statistics_request(priv, CMD_ASYNC, false); 313} 314 315 316static void iwl_print_cont_event_trace(struct iwl_priv *priv, u32 base, 317 u32 start_idx, u32 num_events, 318 u32 mode) 319{ 320 u32 i; 321 u32 ptr; /* SRAM byte address of log data */ 322 u32 ev, time, data; /* event log data */ 323 unsigned long reg_flags; 324 325 if (mode == 0) 326 ptr = base + (4 * sizeof(u32)) + (start_idx * 2 * sizeof(u32)); 327 else 328 ptr = base + (4 * sizeof(u32)) + (start_idx * 3 * sizeof(u32)); 329 330 /* Make sure device is powered up for SRAM reads */ 331 spin_lock_irqsave(&bus(priv)->reg_lock, reg_flags); 332 if (iwl_grab_nic_access(bus(priv))) { 333 spin_unlock_irqrestore(&bus(priv)->reg_lock, reg_flags); 334 return; 335 } 336 337 /* Set starting address; reads will auto-increment */ 338 iwl_write32(bus(priv), HBUS_TARG_MEM_RADDR, ptr); 339 rmb(); 340 341 /* 342 * "time" is actually "data" for mode 0 (no timestamp). 343 * place event id # at far right for easier visual parsing. 344 */ 345 for (i = 0; i < num_events; i++) { 346 ev = iwl_read32(bus(priv), HBUS_TARG_MEM_RDAT); 347 time = iwl_read32(bus(priv), HBUS_TARG_MEM_RDAT); 348 if (mode == 0) { 349 trace_iwlwifi_dev_ucode_cont_event(priv, 350 0, time, ev); 351 } else { 352 data = iwl_read32(bus(priv), HBUS_TARG_MEM_RDAT); 353 trace_iwlwifi_dev_ucode_cont_event(priv, 354 time, data, ev); 355 } 356 } 357 /* Allow device to power down */ 358 iwl_release_nic_access(bus(priv)); 359 spin_unlock_irqrestore(&bus(priv)->reg_lock, reg_flags); 360} 361 362static void iwl_continuous_event_trace(struct iwl_priv *priv) 363{ 364 u32 capacity; /* event log capacity in # entries */ 365 u32 base; /* SRAM byte address of event log header */ 366 u32 mode; /* 0 - no timestamp, 1 - timestamp recorded */ 367 u32 num_wraps; /* # times uCode wrapped to top of log */ 368 u32 next_entry; /* index of next entry to be written by uCode */ 369 370 base = priv->shrd->device_pointers.error_event_table; 371 if (iwlagn_hw_valid_rtc_data_addr(base)) { 372 capacity = iwl_read_targ_mem(bus(priv), base); 373 num_wraps = iwl_read_targ_mem(bus(priv), 374 base + (2 * sizeof(u32))); 375 mode = iwl_read_targ_mem(bus(priv), base + (1 * sizeof(u32))); 376 next_entry = iwl_read_targ_mem(bus(priv), 377 base + (3 * sizeof(u32))); 378 } else 379 return; 380 381 if (num_wraps == priv->event_log.num_wraps) { 382 iwl_print_cont_event_trace(priv, 383 base, priv->event_log.next_entry, 384 next_entry - priv->event_log.next_entry, 385 mode); 386 priv->event_log.non_wraps_count++; 387 } else { 388 if ((num_wraps - priv->event_log.num_wraps) > 1) 389 priv->event_log.wraps_more_count++; 390 else 391 priv->event_log.wraps_once_count++; 392 trace_iwlwifi_dev_ucode_wrap_event(priv, 393 num_wraps - priv->event_log.num_wraps, 394 next_entry, priv->event_log.next_entry); 395 if (next_entry < priv->event_log.next_entry) { 396 iwl_print_cont_event_trace(priv, base, 397 priv->event_log.next_entry, 398 capacity - priv->event_log.next_entry, 399 mode); 400 401 iwl_print_cont_event_trace(priv, base, 0, 402 next_entry, mode); 403 } else { 404 iwl_print_cont_event_trace(priv, base, 405 next_entry, capacity - next_entry, 406 mode); 407 408 iwl_print_cont_event_trace(priv, base, 0, 409 next_entry, mode); 410 } 411 } 412 priv->event_log.num_wraps = num_wraps; 413 priv->event_log.next_entry = next_entry; 414} 415 416/** 417 * iwl_bg_ucode_trace - Timer callback to log ucode event 418 * 419 * The timer is continually set to execute every 420 * UCODE_TRACE_PERIOD milliseconds after the last timer expired 421 * this function is to perform continuous uCode event logging operation 422 * if enabled 423 */ 424static void iwl_bg_ucode_trace(unsigned long data) 425{ 426 struct iwl_priv *priv = (struct iwl_priv *)data; 427 428 if (test_bit(STATUS_EXIT_PENDING, &priv->shrd->status)) 429 return; 430 431 if (priv->event_log.ucode_trace) { 432 iwl_continuous_event_trace(priv); 433 /* Reschedule the timer to occur in UCODE_TRACE_PERIOD */ 434 mod_timer(&priv->ucode_trace, 435 jiffies + msecs_to_jiffies(UCODE_TRACE_PERIOD)); 436 } 437} 438 439static void iwl_bg_tx_flush(struct work_struct *work) 440{ 441 struct iwl_priv *priv = 442 container_of(work, struct iwl_priv, tx_flush); 443 444 if (test_bit(STATUS_EXIT_PENDING, &priv->shrd->status)) 445 return; 446 447 /* do nothing if rf-kill is on */ 448 if (!iwl_is_ready_rf(priv->shrd)) 449 return; 450 451 IWL_DEBUG_INFO(priv, "device request: flush all tx frames\n"); 452 iwlagn_dev_txfifo_flush(priv, IWL_DROP_ALL); 453} 454 455static void iwl_init_context(struct iwl_priv *priv, u32 ucode_flags) 456{ 457 int i; 458 459 /* 460 * The default context is always valid, 461 * the PAN context depends on uCode. 462 */ 463 priv->shrd->valid_contexts = BIT(IWL_RXON_CTX_BSS); 464 if (ucode_flags & IWL_UCODE_TLV_FLAGS_PAN) 465 priv->shrd->valid_contexts |= BIT(IWL_RXON_CTX_PAN); 466 467 for (i = 0; i < NUM_IWL_RXON_CTX; i++) 468 priv->contexts[i].ctxid = i; 469 470 priv->contexts[IWL_RXON_CTX_BSS].always_active = true; 471 priv->contexts[IWL_RXON_CTX_BSS].is_active = true; 472 priv->contexts[IWL_RXON_CTX_BSS].rxon_cmd = REPLY_RXON; 473 priv->contexts[IWL_RXON_CTX_BSS].rxon_timing_cmd = REPLY_RXON_TIMING; 474 priv->contexts[IWL_RXON_CTX_BSS].rxon_assoc_cmd = REPLY_RXON_ASSOC; 475 priv->contexts[IWL_RXON_CTX_BSS].qos_cmd = REPLY_QOS_PARAM; 476 priv->contexts[IWL_RXON_CTX_BSS].ap_sta_id = IWL_AP_ID; 477 priv->contexts[IWL_RXON_CTX_BSS].wep_key_cmd = REPLY_WEPKEY; 478 priv->contexts[IWL_RXON_CTX_BSS].exclusive_interface_modes = 479 BIT(NL80211_IFTYPE_ADHOC); 480 priv->contexts[IWL_RXON_CTX_BSS].interface_modes = 481 BIT(NL80211_IFTYPE_STATION); 482 priv->contexts[IWL_RXON_CTX_BSS].ap_devtype = RXON_DEV_TYPE_AP; 483 priv->contexts[IWL_RXON_CTX_BSS].ibss_devtype = RXON_DEV_TYPE_IBSS; 484 priv->contexts[IWL_RXON_CTX_BSS].station_devtype = RXON_DEV_TYPE_ESS; 485 priv->contexts[IWL_RXON_CTX_BSS].unused_devtype = RXON_DEV_TYPE_ESS; 486 487 priv->contexts[IWL_RXON_CTX_PAN].rxon_cmd = REPLY_WIPAN_RXON; 488 priv->contexts[IWL_RXON_CTX_PAN].rxon_timing_cmd = 489 REPLY_WIPAN_RXON_TIMING; 490 priv->contexts[IWL_RXON_CTX_PAN].rxon_assoc_cmd = 491 REPLY_WIPAN_RXON_ASSOC; 492 priv->contexts[IWL_RXON_CTX_PAN].qos_cmd = REPLY_WIPAN_QOS_PARAM; 493 priv->contexts[IWL_RXON_CTX_PAN].ap_sta_id = IWL_AP_ID_PAN; 494 priv->contexts[IWL_RXON_CTX_PAN].wep_key_cmd = REPLY_WIPAN_WEPKEY; 495 priv->contexts[IWL_RXON_CTX_PAN].bcast_sta_id = IWLAGN_PAN_BCAST_ID; 496 priv->contexts[IWL_RXON_CTX_PAN].station_flags = STA_FLG_PAN_STATION; 497 priv->contexts[IWL_RXON_CTX_PAN].interface_modes = 498 BIT(NL80211_IFTYPE_STATION) | BIT(NL80211_IFTYPE_AP); 499 500 if (ucode_flags & IWL_UCODE_TLV_FLAGS_P2P) 501 priv->contexts[IWL_RXON_CTX_PAN].interface_modes |= 502 BIT(NL80211_IFTYPE_P2P_CLIENT) | 503 BIT(NL80211_IFTYPE_P2P_GO); 504 505 priv->contexts[IWL_RXON_CTX_PAN].ap_devtype = RXON_DEV_TYPE_CP; 506 priv->contexts[IWL_RXON_CTX_PAN].station_devtype = RXON_DEV_TYPE_2STA; 507 priv->contexts[IWL_RXON_CTX_PAN].unused_devtype = RXON_DEV_TYPE_P2P; 508 509 BUILD_BUG_ON(NUM_IWL_RXON_CTX != 2); 510} 511 512static void iwl_ucode_callback(const struct firmware *ucode_raw, void *context); 513 514#define UCODE_EXPERIMENTAL_INDEX 100 515#define UCODE_EXPERIMENTAL_TAG "exp" 516 517static int __must_check iwl_request_firmware(struct iwl_priv *priv, bool first) 518{ 519 const char *name_pre = cfg(priv)->fw_name_pre; 520 char tag[8]; 521 522 if (first) { 523#ifdef CONFIG_IWLWIFI_DEBUG_EXPERIMENTAL_UCODE 524 priv->fw_index = UCODE_EXPERIMENTAL_INDEX; 525 strcpy(tag, UCODE_EXPERIMENTAL_TAG); 526 } else if (priv->fw_index == UCODE_EXPERIMENTAL_INDEX) { 527#endif 528 priv->fw_index = cfg(priv)->ucode_api_max; 529 sprintf(tag, "%d", priv->fw_index); 530 } else { 531 priv->fw_index--; 532 sprintf(tag, "%d", priv->fw_index); 533 } 534 535 if (priv->fw_index < cfg(priv)->ucode_api_min) { 536 IWL_ERR(priv, "no suitable firmware found!\n"); 537 return -ENOENT; 538 } 539 540 sprintf(priv->firmware_name, "%s%s%s", name_pre, tag, ".ucode"); 541 542 IWL_DEBUG_INFO(priv, "attempting to load firmware %s'%s'\n", 543 (priv->fw_index == UCODE_EXPERIMENTAL_INDEX) 544 ? "EXPERIMENTAL " : "", 545 priv->firmware_name); 546 547 return request_firmware_nowait(THIS_MODULE, 1, priv->firmware_name, 548 bus(priv)->dev, 549 GFP_KERNEL, priv, iwl_ucode_callback); 550} 551 552struct iwlagn_firmware_pieces { 553 const void *inst, *data, *init, *init_data, *wowlan_inst, *wowlan_data; 554 size_t inst_size, data_size, init_size, init_data_size, 555 wowlan_inst_size, wowlan_data_size; 556 557 u32 build; 558 559 u32 init_evtlog_ptr, init_evtlog_size, init_errlog_ptr; 560 u32 inst_evtlog_ptr, inst_evtlog_size, inst_errlog_ptr; 561}; 562 563static int iwlagn_load_legacy_firmware(struct iwl_priv *priv, 564 const struct firmware *ucode_raw, 565 struct iwlagn_firmware_pieces *pieces) 566{ 567 struct iwl_ucode_header *ucode = (void *)ucode_raw->data; 568 u32 api_ver, hdr_size; 569 const u8 *src; 570 571 priv->ucode_ver = le32_to_cpu(ucode->ver); 572 api_ver = IWL_UCODE_API(priv->ucode_ver); 573 574 switch (api_ver) { 575 default: 576 hdr_size = 28; 577 if (ucode_raw->size < hdr_size) { 578 IWL_ERR(priv, "File size too small!\n"); 579 return -EINVAL; 580 } 581 pieces->build = le32_to_cpu(ucode->u.v2.build); 582 pieces->inst_size = le32_to_cpu(ucode->u.v2.inst_size); 583 pieces->data_size = le32_to_cpu(ucode->u.v2.data_size); 584 pieces->init_size = le32_to_cpu(ucode->u.v2.init_size); 585 pieces->init_data_size = le32_to_cpu(ucode->u.v2.init_data_size); 586 src = ucode->u.v2.data; 587 break; 588 case 0: 589 case 1: 590 case 2: 591 hdr_size = 24; 592 if (ucode_raw->size < hdr_size) { 593 IWL_ERR(priv, "File size too small!\n"); 594 return -EINVAL; 595 } 596 pieces->build = 0; 597 pieces->inst_size = le32_to_cpu(ucode->u.v1.inst_size); 598 pieces->data_size = le32_to_cpu(ucode->u.v1.data_size); 599 pieces->init_size = le32_to_cpu(ucode->u.v1.init_size); 600 pieces->init_data_size = le32_to_cpu(ucode->u.v1.init_data_size); 601 src = ucode->u.v1.data; 602 break; 603 } 604 605 /* Verify size of file vs. image size info in file's header */ 606 if (ucode_raw->size != hdr_size + pieces->inst_size + 607 pieces->data_size + pieces->init_size + 608 pieces->init_data_size) { 609 610 IWL_ERR(priv, 611 "uCode file size %d does not match expected size\n", 612 (int)ucode_raw->size); 613 return -EINVAL; 614 } 615 616 pieces->inst = src; 617 src += pieces->inst_size; 618 pieces->data = src; 619 src += pieces->data_size; 620 pieces->init = src; 621 src += pieces->init_size; 622 pieces->init_data = src; 623 src += pieces->init_data_size; 624 625 return 0; 626} 627 628static int iwlagn_load_firmware(struct iwl_priv *priv, 629 const struct firmware *ucode_raw, 630 struct iwlagn_firmware_pieces *pieces, 631 struct iwlagn_ucode_capabilities *capa) 632{ 633 struct iwl_tlv_ucode_header *ucode = (void *)ucode_raw->data; 634 struct iwl_ucode_tlv *tlv; 635 size_t len = ucode_raw->size; 636 const u8 *data; 637 int wanted_alternative = iwlagn_mod_params.wanted_ucode_alternative; 638 int tmp; 639 u64 alternatives; 640 u32 tlv_len; 641 enum iwl_ucode_tlv_type tlv_type; 642 const u8 *tlv_data; 643 644 if (len < sizeof(*ucode)) { 645 IWL_ERR(priv, "uCode has invalid length: %zd\n", len); 646 return -EINVAL; 647 } 648 649 if (ucode->magic != cpu_to_le32(IWL_TLV_UCODE_MAGIC)) { 650 IWL_ERR(priv, "invalid uCode magic: 0X%x\n", 651 le32_to_cpu(ucode->magic)); 652 return -EINVAL; 653 } 654 655 /* 656 * Check which alternatives are present, and "downgrade" 657 * when the chosen alternative is not present, warning 658 * the user when that happens. Some files may not have 659 * any alternatives, so don't warn in that case. 660 */ 661 alternatives = le64_to_cpu(ucode->alternatives); 662 tmp = wanted_alternative; 663 if (wanted_alternative > 63) 664 wanted_alternative = 63; 665 while (wanted_alternative && !(alternatives & BIT(wanted_alternative))) 666 wanted_alternative--; 667 if (wanted_alternative && wanted_alternative != tmp) 668 IWL_WARN(priv, 669 "uCode alternative %d not available, choosing %d\n", 670 tmp, wanted_alternative); 671 672 priv->ucode_ver = le32_to_cpu(ucode->ver); 673 pieces->build = le32_to_cpu(ucode->build); 674 data = ucode->data; 675 676 len -= sizeof(*ucode); 677 678 while (len >= sizeof(*tlv)) { 679 u16 tlv_alt; 680 681 len -= sizeof(*tlv); 682 tlv = (void *)data; 683 684 tlv_len = le32_to_cpu(tlv->length); 685 tlv_type = le16_to_cpu(tlv->type); 686 tlv_alt = le16_to_cpu(tlv->alternative); 687 tlv_data = tlv->data; 688 689 if (len < tlv_len) { 690 IWL_ERR(priv, "invalid TLV len: %zd/%u\n", 691 len, tlv_len); 692 return -EINVAL; 693 } 694 len -= ALIGN(tlv_len, 4); 695 data += sizeof(*tlv) + ALIGN(tlv_len, 4); 696 697 /* 698 * Alternative 0 is always valid. 699 * 700 * Skip alternative TLVs that are not selected. 701 */ 702 if (tlv_alt != 0 && tlv_alt != wanted_alternative) 703 continue; 704 705 switch (tlv_type) { 706 case IWL_UCODE_TLV_INST: 707 pieces->inst = tlv_data; 708 pieces->inst_size = tlv_len; 709 break; 710 case IWL_UCODE_TLV_DATA: 711 pieces->data = tlv_data; 712 pieces->data_size = tlv_len; 713 break; 714 case IWL_UCODE_TLV_INIT: 715 pieces->init = tlv_data; 716 pieces->init_size = tlv_len; 717 break; 718 case IWL_UCODE_TLV_INIT_DATA: 719 pieces->init_data = tlv_data; 720 pieces->init_data_size = tlv_len; 721 break; 722 case IWL_UCODE_TLV_BOOT: 723 IWL_ERR(priv, "Found unexpected BOOT ucode\n"); 724 break; 725 case IWL_UCODE_TLV_PROBE_MAX_LEN: 726 if (tlv_len != sizeof(u32)) 727 goto invalid_tlv_len; 728 capa->max_probe_length = 729 le32_to_cpup((__le32 *)tlv_data); 730 break; 731 case IWL_UCODE_TLV_PAN: 732 if (tlv_len) 733 goto invalid_tlv_len; 734 capa->flags |= IWL_UCODE_TLV_FLAGS_PAN; 735 break; 736 case IWL_UCODE_TLV_FLAGS: 737 /* must be at least one u32 */ 738 if (tlv_len < sizeof(u32)) 739 goto invalid_tlv_len; 740 /* and a proper number of u32s */ 741 if (tlv_len % sizeof(u32)) 742 goto invalid_tlv_len; 743 /* 744 * This driver only reads the first u32 as 745 * right now no more features are defined, 746 * if that changes then either the driver 747 * will not work with the new firmware, or 748 * it'll not take advantage of new features. 749 */ 750 capa->flags = le32_to_cpup((__le32 *)tlv_data); 751 break; 752 case IWL_UCODE_TLV_INIT_EVTLOG_PTR: 753 if (tlv_len != sizeof(u32)) 754 goto invalid_tlv_len; 755 pieces->init_evtlog_ptr = 756 le32_to_cpup((__le32 *)tlv_data); 757 break; 758 case IWL_UCODE_TLV_INIT_EVTLOG_SIZE: 759 if (tlv_len != sizeof(u32)) 760 goto invalid_tlv_len; 761 pieces->init_evtlog_size = 762 le32_to_cpup((__le32 *)tlv_data); 763 break; 764 case IWL_UCODE_TLV_INIT_ERRLOG_PTR: 765 if (tlv_len != sizeof(u32)) 766 goto invalid_tlv_len; 767 pieces->init_errlog_ptr = 768 le32_to_cpup((__le32 *)tlv_data); 769 break; 770 case IWL_UCODE_TLV_RUNT_EVTLOG_PTR: 771 if (tlv_len != sizeof(u32)) 772 goto invalid_tlv_len; 773 pieces->inst_evtlog_ptr = 774 le32_to_cpup((__le32 *)tlv_data); 775 break; 776 case IWL_UCODE_TLV_RUNT_EVTLOG_SIZE: 777 if (tlv_len != sizeof(u32)) 778 goto invalid_tlv_len; 779 pieces->inst_evtlog_size = 780 le32_to_cpup((__le32 *)tlv_data); 781 break; 782 case IWL_UCODE_TLV_RUNT_ERRLOG_PTR: 783 if (tlv_len != sizeof(u32)) 784 goto invalid_tlv_len; 785 pieces->inst_errlog_ptr = 786 le32_to_cpup((__le32 *)tlv_data); 787 break; 788 case IWL_UCODE_TLV_ENHANCE_SENS_TBL: 789 if (tlv_len) 790 goto invalid_tlv_len; 791 priv->enhance_sensitivity_table = true; 792 break; 793 case IWL_UCODE_TLV_WOWLAN_INST: 794 pieces->wowlan_inst = tlv_data; 795 pieces->wowlan_inst_size = tlv_len; 796 break; 797 case IWL_UCODE_TLV_WOWLAN_DATA: 798 pieces->wowlan_data = tlv_data; 799 pieces->wowlan_data_size = tlv_len; 800 break; 801 case IWL_UCODE_TLV_PHY_CALIBRATION_SIZE: 802 if (tlv_len != sizeof(u32)) 803 goto invalid_tlv_len; 804 capa->standard_phy_calibration_size = 805 le32_to_cpup((__le32 *)tlv_data); 806 break; 807 default: 808 IWL_DEBUG_INFO(priv, "unknown TLV: %d\n", tlv_type); 809 break; 810 } 811 } 812 813 if (len) { 814 IWL_ERR(priv, "invalid TLV after parsing: %zd\n", len); 815 iwl_print_hex_dump(priv, IWL_DL_FW, (u8 *)data, len); 816 return -EINVAL; 817 } 818 819 return 0; 820 821 invalid_tlv_len: 822 IWL_ERR(priv, "TLV %d has invalid size: %u\n", tlv_type, tlv_len); 823 iwl_print_hex_dump(priv, IWL_DL_FW, tlv_data, tlv_len); 824 825 return -EINVAL; 826} 827 828/** 829 * iwl_ucode_callback - callback when firmware was loaded 830 * 831 * If loaded successfully, copies the firmware into buffers 832 * for the card to fetch (via DMA). 833 */ 834static void iwl_ucode_callback(const struct firmware *ucode_raw, void *context) 835{ 836 struct iwl_priv *priv = context; 837 struct iwl_ucode_header *ucode; 838 int err; 839 struct iwlagn_firmware_pieces pieces; 840 const unsigned int api_max = cfg(priv)->ucode_api_max; 841 unsigned int api_ok = cfg(priv)->ucode_api_ok; 842 const unsigned int api_min = cfg(priv)->ucode_api_min; 843 u32 api_ver; 844 char buildstr[25]; 845 u32 build; 846 struct iwlagn_ucode_capabilities ucode_capa = { 847 .max_probe_length = 200, 848 .standard_phy_calibration_size = 849 IWL_DEFAULT_STANDARD_PHY_CALIBRATE_TBL_SIZE, 850 }; 851 852 if (!api_ok) 853 api_ok = api_max; 854 855 memset(&pieces, 0, sizeof(pieces)); 856 857 if (!ucode_raw) { 858 if (priv->fw_index <= api_ok) 859 IWL_ERR(priv, 860 "request for firmware file '%s' failed.\n", 861 priv->firmware_name); 862 goto try_again; 863 } 864 865 IWL_DEBUG_INFO(priv, "Loaded firmware file '%s' (%zd bytes).\n", 866 priv->firmware_name, ucode_raw->size); 867 868 /* Make sure that we got at least the API version number */ 869 if (ucode_raw->size < 4) { 870 IWL_ERR(priv, "File size way too small!\n"); 871 goto try_again; 872 } 873 874 /* Data from ucode file: header followed by uCode images */ 875 ucode = (struct iwl_ucode_header *)ucode_raw->data; 876 877 if (ucode->ver) 878 err = iwlagn_load_legacy_firmware(priv, ucode_raw, &pieces); 879 else 880 err = iwlagn_load_firmware(priv, ucode_raw, &pieces, 881 &ucode_capa); 882 883 if (err) 884 goto try_again; 885 886 api_ver = IWL_UCODE_API(priv->ucode_ver); 887 build = pieces.build; 888 889 /* 890 * api_ver should match the api version forming part of the 891 * firmware filename ... but we don't check for that and only rely 892 * on the API version read from firmware header from here on forward 893 */ 894 /* no api version check required for experimental uCode */ 895 if (priv->fw_index != UCODE_EXPERIMENTAL_INDEX) { 896 if (api_ver < api_min || api_ver > api_max) { 897 IWL_ERR(priv, 898 "Driver unable to support your firmware API. " 899 "Driver supports v%u, firmware is v%u.\n", 900 api_max, api_ver); 901 goto try_again; 902 } 903 904 if (api_ver < api_ok) { 905 if (api_ok != api_max) 906 IWL_ERR(priv, "Firmware has old API version, " 907 "expected v%u through v%u, got v%u.\n", 908 api_ok, api_max, api_ver); 909 else 910 IWL_ERR(priv, "Firmware has old API version, " 911 "expected v%u, got v%u.\n", 912 api_max, api_ver); 913 IWL_ERR(priv, "New firmware can be obtained from " 914 "http://www.intellinuxwireless.org/.\n"); 915 } 916 } 917 918 if (build) 919 sprintf(buildstr, " build %u%s", build, 920 (priv->fw_index == UCODE_EXPERIMENTAL_INDEX) 921 ? " (EXP)" : ""); 922 else 923 buildstr[0] = '\0'; 924 925 IWL_INFO(priv, "loaded firmware version %u.%u.%u.%u%s\n", 926 IWL_UCODE_MAJOR(priv->ucode_ver), 927 IWL_UCODE_MINOR(priv->ucode_ver), 928 IWL_UCODE_API(priv->ucode_ver), 929 IWL_UCODE_SERIAL(priv->ucode_ver), 930 buildstr); 931 932 snprintf(priv->hw->wiphy->fw_version, 933 sizeof(priv->hw->wiphy->fw_version), 934 "%u.%u.%u.%u%s", 935 IWL_UCODE_MAJOR(priv->ucode_ver), 936 IWL_UCODE_MINOR(priv->ucode_ver), 937 IWL_UCODE_API(priv->ucode_ver), 938 IWL_UCODE_SERIAL(priv->ucode_ver), 939 buildstr); 940 941 /* 942 * For any of the failures below (before allocating pci memory) 943 * we will try to load a version with a smaller API -- maybe the 944 * user just got a corrupted version of the latest API. 945 */ 946 947 IWL_DEBUG_INFO(priv, "f/w package hdr ucode version raw = 0x%x\n", 948 priv->ucode_ver); 949 IWL_DEBUG_INFO(priv, "f/w package hdr runtime inst size = %Zd\n", 950 pieces.inst_size); 951 IWL_DEBUG_INFO(priv, "f/w package hdr runtime data size = %Zd\n", 952 pieces.data_size); 953 IWL_DEBUG_INFO(priv, "f/w package hdr init inst size = %Zd\n", 954 pieces.init_size); 955 IWL_DEBUG_INFO(priv, "f/w package hdr init data size = %Zd\n", 956 pieces.init_data_size); 957 958 /* Verify that uCode images will fit in card's SRAM */ 959 if (pieces.inst_size > hw_params(priv).max_inst_size) { 960 IWL_ERR(priv, "uCode instr len %Zd too large to fit in\n", 961 pieces.inst_size); 962 goto try_again; 963 } 964 965 if (pieces.data_size > hw_params(priv).max_data_size) { 966 IWL_ERR(priv, "uCode data len %Zd too large to fit in\n", 967 pieces.data_size); 968 goto try_again; 969 } 970 971 if (pieces.init_size > hw_params(priv).max_inst_size) { 972 IWL_ERR(priv, "uCode init instr len %Zd too large to fit in\n", 973 pieces.init_size); 974 goto try_again; 975 } 976 977 if (pieces.init_data_size > hw_params(priv).max_data_size) { 978 IWL_ERR(priv, "uCode init data len %Zd too large to fit in\n", 979 pieces.init_data_size); 980 goto try_again; 981 } 982 983 /* Allocate ucode buffers for card's bus-master loading ... */ 984 985 /* Runtime instructions and 2 copies of data: 986 * 1) unmodified from disk 987 * 2) backup cache for save/restore during power-downs */ 988 if (iwl_alloc_fw_desc(bus(priv), &trans(priv)->ucode_rt.code, 989 pieces.inst, pieces.inst_size)) 990 goto err_pci_alloc; 991 if (iwl_alloc_fw_desc(bus(priv), &trans(priv)->ucode_rt.data, 992 pieces.data, pieces.data_size)) 993 goto err_pci_alloc; 994 995 /* Initialization instructions and data */ 996 if (pieces.init_size && pieces.init_data_size) { 997 if (iwl_alloc_fw_desc(bus(priv), &trans(priv)->ucode_init.code, 998 pieces.init, pieces.init_size)) 999 goto err_pci_alloc; 1000 if (iwl_alloc_fw_desc(bus(priv), &trans(priv)->ucode_init.data, 1001 pieces.init_data, pieces.init_data_size)) 1002 goto err_pci_alloc; 1003 } 1004 1005 /* WoWLAN instructions and data */ 1006 if (pieces.wowlan_inst_size && pieces.wowlan_data_size) { 1007 if (iwl_alloc_fw_desc(bus(priv), 1008 &trans(priv)->ucode_wowlan.code, 1009 pieces.wowlan_inst, 1010 pieces.wowlan_inst_size)) 1011 goto err_pci_alloc; 1012 if (iwl_alloc_fw_desc(bus(priv), 1013 &trans(priv)->ucode_wowlan.data, 1014 pieces.wowlan_data, 1015 pieces.wowlan_data_size)) 1016 goto err_pci_alloc; 1017 } 1018 1019 /* Now that we can no longer fail, copy information */ 1020 1021 /* 1022 * The (size - 16) / 12 formula is based on the information recorded 1023 * for each event, which is of mode 1 (including timestamp) for all 1024 * new microcodes that include this information. 1025 */ 1026 priv->init_evtlog_ptr = pieces.init_evtlog_ptr; 1027 if (pieces.init_evtlog_size) 1028 priv->init_evtlog_size = (pieces.init_evtlog_size - 16)/12; 1029 else 1030 priv->init_evtlog_size = 1031 cfg(priv)->base_params->max_event_log_size; 1032 priv->init_errlog_ptr = pieces.init_errlog_ptr; 1033 priv->inst_evtlog_ptr = pieces.inst_evtlog_ptr; 1034 if (pieces.inst_evtlog_size) 1035 priv->inst_evtlog_size = (pieces.inst_evtlog_size - 16)/12; 1036 else 1037 priv->inst_evtlog_size = 1038 cfg(priv)->base_params->max_event_log_size; 1039 priv->inst_errlog_ptr = pieces.inst_errlog_ptr; 1040#ifndef CONFIG_IWLWIFI_P2P 1041 ucode_capa.flags &= ~IWL_UCODE_TLV_FLAGS_PAN; 1042#endif 1043 1044 priv->new_scan_threshold_behaviour = 1045 !!(ucode_capa.flags & IWL_UCODE_TLV_FLAGS_NEWSCAN); 1046 1047 if (!(cfg(priv)->sku & EEPROM_SKU_CAP_IPAN_ENABLE)) 1048 ucode_capa.flags &= ~IWL_UCODE_TLV_FLAGS_PAN; 1049 1050 /* 1051 * if not PAN, then don't support P2P -- might be a uCode 1052 * packaging bug or due to the eeprom check above 1053 */ 1054 if (!(ucode_capa.flags & IWL_UCODE_TLV_FLAGS_PAN)) 1055 ucode_capa.flags &= ~IWL_UCODE_TLV_FLAGS_P2P; 1056 1057 if (ucode_capa.flags & IWL_UCODE_TLV_FLAGS_PAN) { 1058 priv->sta_key_max_num = STA_KEY_MAX_NUM_PAN; 1059 priv->shrd->cmd_queue = IWL_IPAN_CMD_QUEUE_NUM; 1060 } else { 1061 priv->sta_key_max_num = STA_KEY_MAX_NUM; 1062 priv->shrd->cmd_queue = IWL_DEFAULT_CMD_QUEUE_NUM; 1063 } 1064 /* 1065 * figure out the offset of chain noise reset and gain commands 1066 * base on the size of standard phy calibration commands table size 1067 */ 1068 if (ucode_capa.standard_phy_calibration_size > 1069 IWL_MAX_PHY_CALIBRATE_TBL_SIZE) 1070 ucode_capa.standard_phy_calibration_size = 1071 IWL_MAX_STANDARD_PHY_CALIBRATE_TBL_SIZE; 1072 1073 priv->phy_calib_chain_noise_reset_cmd = 1074 ucode_capa.standard_phy_calibration_size; 1075 priv->phy_calib_chain_noise_gain_cmd = 1076 ucode_capa.standard_phy_calibration_size + 1; 1077 1078 /* initialize all valid contexts */ 1079 iwl_init_context(priv, ucode_capa.flags); 1080 1081 /************************************************** 1082 * This is still part of probe() in a sense... 1083 * 1084 * 9. Setup and register with mac80211 and debugfs 1085 **************************************************/ 1086 err = iwlagn_mac_setup_register(priv, &ucode_capa); 1087 if (err) 1088 goto out_unbind; 1089 1090 err = iwl_dbgfs_register(priv, DRV_NAME); 1091 if (err) 1092 IWL_ERR(priv, "failed to create debugfs files. Ignoring error: %d\n", err); 1093 1094 /* We have our copies now, allow OS release its copies */ 1095 release_firmware(ucode_raw); 1096 complete(&priv->firmware_loading_complete); 1097 return; 1098 1099 try_again: 1100 /* try next, if any */ 1101 if (iwl_request_firmware(priv, false)) 1102 goto out_unbind; 1103 release_firmware(ucode_raw); 1104 return; 1105 1106 err_pci_alloc: 1107 IWL_ERR(priv, "failed to allocate pci memory\n"); 1108 iwl_dealloc_ucode(trans(priv)); 1109 out_unbind: 1110 complete(&priv->firmware_loading_complete); 1111 device_release_driver(bus(priv)->dev); 1112 release_firmware(ucode_raw); 1113} 1114 1115static void iwl_rf_kill_ct_config(struct iwl_priv *priv) 1116{ 1117 struct iwl_ct_kill_config cmd; 1118 struct iwl_ct_kill_throttling_config adv_cmd; 1119 unsigned long flags; 1120 int ret = 0; 1121 1122 spin_lock_irqsave(&priv->shrd->lock, flags); 1123 iwl_write32(bus(priv), CSR_UCODE_DRV_GP1_CLR, 1124 CSR_UCODE_DRV_GP1_REG_BIT_CT_KILL_EXIT); 1125 spin_unlock_irqrestore(&priv->shrd->lock, flags); 1126 priv->thermal_throttle.ct_kill_toggle = false; 1127 1128 if (cfg(priv)->base_params->support_ct_kill_exit) { 1129 adv_cmd.critical_temperature_enter = 1130 cpu_to_le32(hw_params(priv).ct_kill_threshold); 1131 adv_cmd.critical_temperature_exit = 1132 cpu_to_le32(hw_params(priv).ct_kill_exit_threshold); 1133 1134 ret = iwl_trans_send_cmd_pdu(trans(priv), 1135 REPLY_CT_KILL_CONFIG_CMD, 1136 CMD_SYNC, sizeof(adv_cmd), &adv_cmd); 1137 if (ret) 1138 IWL_ERR(priv, "REPLY_CT_KILL_CONFIG_CMD failed\n"); 1139 else 1140 IWL_DEBUG_INFO(priv, "REPLY_CT_KILL_CONFIG_CMD " 1141 "succeeded, critical temperature enter is %d," 1142 "exit is %d\n", 1143 hw_params(priv).ct_kill_threshold, 1144 hw_params(priv).ct_kill_exit_threshold); 1145 } else { 1146 cmd.critical_temperature_R = 1147 cpu_to_le32(hw_params(priv).ct_kill_threshold); 1148 1149 ret = iwl_trans_send_cmd_pdu(trans(priv), 1150 REPLY_CT_KILL_CONFIG_CMD, 1151 CMD_SYNC, sizeof(cmd), &cmd); 1152 if (ret) 1153 IWL_ERR(priv, "REPLY_CT_KILL_CONFIG_CMD failed\n"); 1154 else 1155 IWL_DEBUG_INFO(priv, "REPLY_CT_KILL_CONFIG_CMD " 1156 "succeeded, " 1157 "critical temperature is %d\n", 1158 hw_params(priv).ct_kill_threshold); 1159 } 1160} 1161 1162static int iwlagn_send_calib_cfg_rt(struct iwl_priv *priv, u32 cfg) 1163{ 1164 struct iwl_calib_cfg_cmd calib_cfg_cmd; 1165 struct iwl_host_cmd cmd = { 1166 .id = CALIBRATION_CFG_CMD, 1167 .len = { sizeof(struct iwl_calib_cfg_cmd), }, 1168 .data = { &calib_cfg_cmd, }, 1169 }; 1170 1171 memset(&calib_cfg_cmd, 0, sizeof(calib_cfg_cmd)); 1172 calib_cfg_cmd.ucd_calib_cfg.once.is_enable = IWL_CALIB_RT_CFG_ALL; 1173 calib_cfg_cmd.ucd_calib_cfg.once.start = cpu_to_le32(cfg); 1174 1175 return iwl_trans_send_cmd(trans(priv), &cmd); 1176} 1177 1178 1179static int iwlagn_send_tx_ant_config(struct iwl_priv *priv, u8 valid_tx_ant) 1180{ 1181 struct iwl_tx_ant_config_cmd tx_ant_cmd = { 1182 .valid = cpu_to_le32(valid_tx_ant), 1183 }; 1184 1185 if (IWL_UCODE_API(priv->ucode_ver) > 1) { 1186 IWL_DEBUG_HC(priv, "select valid tx ant: %u\n", valid_tx_ant); 1187 return iwl_trans_send_cmd_pdu(trans(priv), 1188 TX_ANT_CONFIGURATION_CMD, 1189 CMD_SYNC, 1190 sizeof(struct iwl_tx_ant_config_cmd), 1191 &tx_ant_cmd); 1192 } else { 1193 IWL_DEBUG_HC(priv, "TX_ANT_CONFIGURATION_CMD not supported\n"); 1194 return -EOPNOTSUPP; 1195 } 1196} 1197 1198/** 1199 * iwl_alive_start - called after REPLY_ALIVE notification received 1200 * from protocol/runtime uCode (initialization uCode's 1201 * Alive gets handled by iwl_init_alive_start()). 1202 */ 1203int iwl_alive_start(struct iwl_priv *priv) 1204{ 1205 int ret = 0; 1206 struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS]; 1207 1208 /*TODO: this should go to the transport layer */ 1209 iwl_reset_ict(trans(priv)); 1210 1211 IWL_DEBUG_INFO(priv, "Runtime Alive received.\n"); 1212 1213 /* After the ALIVE response, we can send host commands to the uCode */ 1214 set_bit(STATUS_ALIVE, &priv->shrd->status); 1215 1216 /* Enable watchdog to monitor the driver tx queues */ 1217 iwl_setup_watchdog(priv); 1218 1219 if (iwl_is_rfkill(priv->shrd)) 1220 return -ERFKILL; 1221 1222 /* download priority table before any calibration request */ 1223 if (cfg(priv)->bt_params && 1224 cfg(priv)->bt_params->advanced_bt_coexist) { 1225 /* Configure Bluetooth device coexistence support */ 1226 if (cfg(priv)->bt_params->bt_sco_disable) 1227 priv->bt_enable_pspoll = false; 1228 else 1229 priv->bt_enable_pspoll = true; 1230 1231 priv->bt_valid = IWLAGN_BT_ALL_VALID_MSK; 1232 priv->kill_ack_mask = IWLAGN_BT_KILL_ACK_MASK_DEFAULT; 1233 priv->kill_cts_mask = IWLAGN_BT_KILL_CTS_MASK_DEFAULT; 1234 iwlagn_send_advance_bt_config(priv); 1235 priv->bt_valid = IWLAGN_BT_VALID_ENABLE_FLAGS; 1236 priv->cur_rssi_ctx = NULL; 1237 1238 iwl_send_prio_tbl(trans(priv)); 1239 1240 /* FIXME: w/a to force change uCode BT state machine */ 1241 ret = iwl_send_bt_env(trans(priv), IWL_BT_COEX_ENV_OPEN, 1242 BT_COEX_PRIO_TBL_EVT_INIT_CALIB2); 1243 if (ret) 1244 return ret; 1245 ret = iwl_send_bt_env(trans(priv), IWL_BT_COEX_ENV_CLOSE, 1246 BT_COEX_PRIO_TBL_EVT_INIT_CALIB2); 1247 if (ret) 1248 return ret; 1249 } else { 1250 /* 1251 * default is 2-wire BT coexexistence support 1252 */ 1253 iwl_send_bt_config(priv); 1254 } 1255 1256 /* 1257 * Perform runtime calibrations, including DC calibration. 1258 */ 1259 iwlagn_send_calib_cfg_rt(priv, IWL_CALIB_CFG_DC_IDX); 1260 1261 ieee80211_wake_queues(priv->hw); 1262 1263 priv->active_rate = IWL_RATES_MASK; 1264 1265 /* Configure Tx antenna selection based on H/W config */ 1266 iwlagn_send_tx_ant_config(priv, cfg(priv)->valid_tx_ant); 1267 1268 if (iwl_is_associated_ctx(ctx) && !priv->shrd->wowlan) { 1269 struct iwl_rxon_cmd *active_rxon = 1270 (struct iwl_rxon_cmd *)&ctx->active; 1271 /* apply any changes in staging */ 1272 ctx->staging.filter_flags |= RXON_FILTER_ASSOC_MSK; 1273 active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK; 1274 } else { 1275 struct iwl_rxon_context *tmp; 1276 /* Initialize our rx_config data */ 1277 for_each_context(priv, tmp) 1278 iwl_connection_init_rx_config(priv, tmp); 1279 1280 iwlagn_set_rxon_chain(priv, ctx); 1281 } 1282 1283 if (!priv->shrd->wowlan) { 1284 /* WoWLAN ucode will not reply in the same way, skip it */ 1285 iwl_reset_run_time_calib(priv); 1286 } 1287 1288 set_bit(STATUS_READY, &priv->shrd->status); 1289 1290 /* Configure the adapter for unassociated operation */ 1291 ret = iwlagn_commit_rxon(priv, ctx); 1292 if (ret) 1293 return ret; 1294 1295 /* At this point, the NIC is initialized and operational */ 1296 iwl_rf_kill_ct_config(priv); 1297 1298 IWL_DEBUG_INFO(priv, "ALIVE processing complete.\n"); 1299 1300 return iwl_power_update_mode(priv, true); 1301} 1302 1303static void iwl_cancel_deferred_work(struct iwl_priv *priv); 1304 1305void __iwl_down(struct iwl_priv *priv) 1306{ 1307 int exit_pending; 1308 1309 IWL_DEBUG_INFO(priv, DRV_NAME " is going down\n"); 1310 1311 iwl_scan_cancel_timeout(priv, 200); 1312 1313 /* 1314 * If active, scanning won't cancel it, so say it expired. 1315 * No race since we hold the mutex here and a new one 1316 * can't come in at this time. 1317 */ 1318 ieee80211_remain_on_channel_expired(priv->hw); 1319 1320 exit_pending = 1321 test_and_set_bit(STATUS_EXIT_PENDING, &priv->shrd->status); 1322 1323 /* Stop TX queues watchdog. We need to have STATUS_EXIT_PENDING bit set 1324 * to prevent rearm timer */ 1325 del_timer_sync(&priv->watchdog); 1326 1327 iwl_clear_ucode_stations(priv, NULL); 1328 iwl_dealloc_bcast_stations(priv); 1329 iwl_clear_driver_stations(priv); 1330 1331 /* reset BT coex data */ 1332 priv->bt_status = 0; 1333 priv->cur_rssi_ctx = NULL; 1334 priv->bt_is_sco = 0; 1335 if (cfg(priv)->bt_params) 1336 priv->bt_traffic_load = 1337 cfg(priv)->bt_params->bt_init_traffic_load; 1338 else 1339 priv->bt_traffic_load = 0; 1340 priv->bt_full_concurrent = false; 1341 priv->bt_ci_compliance = 0; 1342 1343 /* Wipe out the EXIT_PENDING status bit if we are not actually 1344 * exiting the module */ 1345 if (!exit_pending) 1346 clear_bit(STATUS_EXIT_PENDING, &priv->shrd->status); 1347 1348 if (priv->mac80211_registered) 1349 ieee80211_stop_queues(priv->hw); 1350 1351 iwl_trans_stop_device(trans(priv)); 1352 1353 /* Clear out all status bits but a few that are stable across reset */ 1354 priv->shrd->status &= 1355 test_bit(STATUS_RF_KILL_HW, &priv->shrd->status) << 1356 STATUS_RF_KILL_HW | 1357 test_bit(STATUS_GEO_CONFIGURED, &priv->shrd->status) << 1358 STATUS_GEO_CONFIGURED | 1359 test_bit(STATUS_FW_ERROR, &priv->shrd->status) << 1360 STATUS_FW_ERROR | 1361 test_bit(STATUS_EXIT_PENDING, &priv->shrd->status) << 1362 STATUS_EXIT_PENDING; 1363 1364 dev_kfree_skb(priv->beacon_skb); 1365 priv->beacon_skb = NULL; 1366} 1367 1368void iwl_down(struct iwl_priv *priv) 1369{ 1370 mutex_lock(&priv->shrd->mutex); 1371 __iwl_down(priv); 1372 mutex_unlock(&priv->shrd->mutex); 1373 1374 iwl_cancel_deferred_work(priv); 1375} 1376 1377/***************************************************************************** 1378 * 1379 * Workqueue callbacks 1380 * 1381 *****************************************************************************/ 1382 1383static void iwl_bg_run_time_calib_work(struct work_struct *work) 1384{ 1385 struct iwl_priv *priv = container_of(work, struct iwl_priv, 1386 run_time_calib_work); 1387 1388 mutex_lock(&priv->shrd->mutex); 1389 1390 if (test_bit(STATUS_EXIT_PENDING, &priv->shrd->status) || 1391 test_bit(STATUS_SCANNING, &priv->shrd->status)) { 1392 mutex_unlock(&priv->shrd->mutex); 1393 return; 1394 } 1395 1396 if (priv->start_calib) { 1397 iwl_chain_noise_calibration(priv); 1398 iwl_sensitivity_calibration(priv); 1399 } 1400 1401 mutex_unlock(&priv->shrd->mutex); 1402} 1403 1404void iwlagn_prepare_restart(struct iwl_priv *priv) 1405{ 1406 struct iwl_rxon_context *ctx; 1407 bool bt_full_concurrent; 1408 u8 bt_ci_compliance; 1409 u8 bt_load; 1410 u8 bt_status; 1411 bool bt_is_sco; 1412 1413 lockdep_assert_held(&priv->shrd->mutex); 1414 1415 for_each_context(priv, ctx) 1416 ctx->vif = NULL; 1417 priv->is_open = 0; 1418 1419 /* 1420 * __iwl_down() will clear the BT status variables, 1421 * which is correct, but when we restart we really 1422 * want to keep them so restore them afterwards. 1423 * 1424 * The restart process will later pick them up and 1425 * re-configure the hw when we reconfigure the BT 1426 * command. 1427 */ 1428 bt_full_concurrent = priv->bt_full_concurrent; 1429 bt_ci_compliance = priv->bt_ci_compliance; 1430 bt_load = priv->bt_traffic_load; 1431 bt_status = priv->bt_status; 1432 bt_is_sco = priv->bt_is_sco; 1433 1434 __iwl_down(priv); 1435 1436 priv->bt_full_concurrent = bt_full_concurrent; 1437 priv->bt_ci_compliance = bt_ci_compliance; 1438 priv->bt_traffic_load = bt_load; 1439 priv->bt_status = bt_status; 1440 priv->bt_is_sco = bt_is_sco; 1441} 1442 1443static void iwl_bg_restart(struct work_struct *data) 1444{ 1445 struct iwl_priv *priv = container_of(data, struct iwl_priv, restart); 1446 1447 if (test_bit(STATUS_EXIT_PENDING, &priv->shrd->status)) 1448 return; 1449 1450 if (test_and_clear_bit(STATUS_FW_ERROR, &priv->shrd->status)) { 1451 mutex_lock(&priv->shrd->mutex); 1452 iwlagn_prepare_restart(priv); 1453 mutex_unlock(&priv->shrd->mutex); 1454 iwl_cancel_deferred_work(priv); 1455 ieee80211_restart_hw(priv->hw); 1456 } else { 1457 WARN_ON(1); 1458 } 1459} 1460 1461 1462 1463 1464void iwlagn_disable_roc(struct iwl_priv *priv) 1465{ 1466 struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_PAN]; 1467 1468 lockdep_assert_held(&priv->shrd->mutex); 1469 1470 if (!priv->hw_roc_setup) 1471 return; 1472 1473 ctx->staging.dev_type = RXON_DEV_TYPE_P2P; 1474 ctx->staging.filter_flags &= ~RXON_FILTER_ASSOC_MSK; 1475 1476 priv->hw_roc_channel = NULL; 1477 1478 memset(ctx->staging.node_addr, 0, ETH_ALEN); 1479 1480 iwlagn_commit_rxon(priv, ctx); 1481 1482 ctx->is_active = false; 1483 priv->hw_roc_setup = false; 1484} 1485 1486static void iwlagn_disable_roc_work(struct work_struct *work) 1487{ 1488 struct iwl_priv *priv = container_of(work, struct iwl_priv, 1489 hw_roc_disable_work.work); 1490 1491 mutex_lock(&priv->shrd->mutex); 1492 iwlagn_disable_roc(priv); 1493 mutex_unlock(&priv->shrd->mutex); 1494} 1495 1496/***************************************************************************** 1497 * 1498 * driver setup and teardown 1499 * 1500 *****************************************************************************/ 1501 1502static void iwl_setup_deferred_work(struct iwl_priv *priv) 1503{ 1504 priv->shrd->workqueue = create_singlethread_workqueue(DRV_NAME); 1505 1506 init_waitqueue_head(&priv->shrd->wait_command_queue); 1507 1508 INIT_WORK(&priv->restart, iwl_bg_restart); 1509 INIT_WORK(&priv->beacon_update, iwl_bg_beacon_update); 1510 INIT_WORK(&priv->run_time_calib_work, iwl_bg_run_time_calib_work); 1511 INIT_WORK(&priv->tx_flush, iwl_bg_tx_flush); 1512 INIT_WORK(&priv->bt_full_concurrency, iwl_bg_bt_full_concurrency); 1513 INIT_WORK(&priv->bt_runtime_config, iwl_bg_bt_runtime_config); 1514 INIT_DELAYED_WORK(&priv->hw_roc_disable_work, 1515 iwlagn_disable_roc_work); 1516 1517 iwl_setup_scan_deferred_work(priv); 1518 1519 if (cfg(priv)->lib->bt_setup_deferred_work) 1520 cfg(priv)->lib->bt_setup_deferred_work(priv); 1521 1522 init_timer(&priv->statistics_periodic); 1523 priv->statistics_periodic.data = (unsigned long)priv; 1524 priv->statistics_periodic.function = iwl_bg_statistics_periodic; 1525 1526 init_timer(&priv->ucode_trace); 1527 priv->ucode_trace.data = (unsigned long)priv; 1528 priv->ucode_trace.function = iwl_bg_ucode_trace; 1529 1530 init_timer(&priv->watchdog); 1531 priv->watchdog.data = (unsigned long)priv; 1532 priv->watchdog.function = iwl_bg_watchdog; 1533} 1534 1535static void iwl_cancel_deferred_work(struct iwl_priv *priv) 1536{ 1537 if (cfg(priv)->lib->cancel_deferred_work) 1538 cfg(priv)->lib->cancel_deferred_work(priv); 1539 1540 cancel_work_sync(&priv->run_time_calib_work); 1541 cancel_work_sync(&priv->beacon_update); 1542 1543 iwl_cancel_scan_deferred_work(priv); 1544 1545 cancel_work_sync(&priv->bt_full_concurrency); 1546 cancel_work_sync(&priv->bt_runtime_config); 1547 cancel_delayed_work_sync(&priv->hw_roc_disable_work); 1548 1549 del_timer_sync(&priv->statistics_periodic); 1550 del_timer_sync(&priv->ucode_trace); 1551} 1552 1553static void iwl_init_hw_rates(struct iwl_priv *priv, 1554 struct ieee80211_rate *rates) 1555{ 1556 int i; 1557 1558 for (i = 0; i < IWL_RATE_COUNT_LEGACY; i++) { 1559 rates[i].bitrate = iwl_rates[i].ieee * 5; 1560 rates[i].hw_value = i; /* Rate scaling will work on indexes */ 1561 rates[i].hw_value_short = i; 1562 rates[i].flags = 0; 1563 if ((i >= IWL_FIRST_CCK_RATE) && (i <= IWL_LAST_CCK_RATE)) { 1564 /* 1565 * If CCK != 1M then set short preamble rate flag. 1566 */ 1567 rates[i].flags |= 1568 (iwl_rates[i].plcp == IWL_RATE_1M_PLCP) ? 1569 0 : IEEE80211_RATE_SHORT_PREAMBLE; 1570 } 1571 } 1572} 1573 1574static int iwl_init_drv(struct iwl_priv *priv) 1575{ 1576 int ret; 1577 1578 spin_lock_init(&priv->shrd->sta_lock); 1579 1580 mutex_init(&priv->shrd->mutex); 1581 1582 INIT_LIST_HEAD(&trans(priv)->calib_results); 1583 1584 priv->ieee_channels = NULL; 1585 priv->ieee_rates = NULL; 1586 priv->band = IEEE80211_BAND_2GHZ; 1587 1588 priv->iw_mode = NL80211_IFTYPE_STATION; 1589 priv->current_ht_config.smps = IEEE80211_SMPS_STATIC; 1590 priv->missed_beacon_threshold = IWL_MISSED_BEACON_THRESHOLD_DEF; 1591 priv->agg_tids_count = 0; 1592 1593 /* initialize force reset */ 1594 priv->force_reset[IWL_RF_RESET].reset_duration = 1595 IWL_DELAY_NEXT_FORCE_RF_RESET; 1596 priv->force_reset[IWL_FW_RESET].reset_duration = 1597 IWL_DELAY_NEXT_FORCE_FW_RELOAD; 1598 1599 priv->rx_statistics_jiffies = jiffies; 1600 1601 /* Choose which receivers/antennas to use */ 1602 iwlagn_set_rxon_chain(priv, &priv->contexts[IWL_RXON_CTX_BSS]); 1603 1604 iwl_init_scan_params(priv); 1605 1606 /* init bt coex */ 1607 if (cfg(priv)->bt_params && 1608 cfg(priv)->bt_params->advanced_bt_coexist) { 1609 priv->kill_ack_mask = IWLAGN_BT_KILL_ACK_MASK_DEFAULT; 1610 priv->kill_cts_mask = IWLAGN_BT_KILL_CTS_MASK_DEFAULT; 1611 priv->bt_valid = IWLAGN_BT_ALL_VALID_MSK; 1612 priv->bt_on_thresh = BT_ON_THRESHOLD_DEF; 1613 priv->bt_duration = BT_DURATION_LIMIT_DEF; 1614 priv->dynamic_frag_thresh = BT_FRAG_THRESHOLD_DEF; 1615 } 1616 1617 ret = iwl_init_channel_map(priv); 1618 if (ret) { 1619 IWL_ERR(priv, "initializing regulatory failed: %d\n", ret); 1620 goto err; 1621 } 1622 1623 ret = iwl_init_geos(priv); 1624 if (ret) { 1625 IWL_ERR(priv, "initializing geos failed: %d\n", ret); 1626 goto err_free_channel_map; 1627 } 1628 iwl_init_hw_rates(priv, priv->ieee_rates); 1629 1630 return 0; 1631 1632err_free_channel_map: 1633 iwl_free_channel_map(priv); 1634err: 1635 return ret; 1636} 1637 1638static void iwl_uninit_drv(struct iwl_priv *priv) 1639{ 1640 iwl_free_geos(priv); 1641 iwl_free_channel_map(priv); 1642 if (priv->tx_cmd_pool) 1643 kmem_cache_destroy(priv->tx_cmd_pool); 1644 kfree(priv->scan_cmd); 1645 kfree(priv->beacon_cmd); 1646 kfree(rcu_dereference_raw(priv->noa_data)); 1647#ifdef CONFIG_IWLWIFI_DEBUGFS 1648 kfree(priv->wowlan_sram); 1649#endif 1650} 1651 1652 1653 1654static u32 iwl_hw_detect(struct iwl_priv *priv) 1655{ 1656 return iwl_read32(bus(priv), CSR_HW_REV); 1657} 1658 1659/* Size of one Rx buffer in host DRAM */ 1660#define IWL_RX_BUF_SIZE_4K (4 * 1024) 1661#define IWL_RX_BUF_SIZE_8K (8 * 1024) 1662 1663static int iwl_set_hw_params(struct iwl_priv *priv) 1664{ 1665 if (iwlagn_mod_params.amsdu_size_8K) 1666 hw_params(priv).rx_page_order = 1667 get_order(IWL_RX_BUF_SIZE_8K); 1668 else 1669 hw_params(priv).rx_page_order = 1670 get_order(IWL_RX_BUF_SIZE_4K); 1671 1672 if (iwlagn_mod_params.disable_11n & IWL_DISABLE_HT_ALL) 1673 cfg(priv)->sku &= ~EEPROM_SKU_CAP_11N_ENABLE; 1674 1675 hw_params(priv).num_ampdu_queues = 1676 cfg(priv)->base_params->num_of_ampdu_queues; 1677 hw_params(priv).shadow_reg_enable = 1678 cfg(priv)->base_params->shadow_reg_enable; 1679 hw_params(priv).sku = cfg(priv)->sku; 1680 hw_params(priv).wd_timeout = cfg(priv)->base_params->wd_timeout; 1681 1682 /* Device-specific setup */ 1683 return cfg(priv)->lib->set_hw_params(priv); 1684} 1685 1686 1687 1688static void iwl_debug_config(struct iwl_priv *priv) 1689{ 1690 dev_printk(KERN_INFO, bus(priv)->dev, "CONFIG_IWLWIFI_DEBUG " 1691#ifdef CONFIG_IWLWIFI_DEBUG 1692 "enabled\n"); 1693#else 1694 "disabled\n"); 1695#endif 1696 dev_printk(KERN_INFO, bus(priv)->dev, "CONFIG_IWLWIFI_DEBUGFS " 1697#ifdef CONFIG_IWLWIFI_DEBUGFS 1698 "enabled\n"); 1699#else 1700 "disabled\n"); 1701#endif 1702 dev_printk(KERN_INFO, bus(priv)->dev, "CONFIG_IWLWIFI_DEVICE_TRACING " 1703#ifdef CONFIG_IWLWIFI_DEVICE_TRACING 1704 "enabled\n"); 1705#else 1706 "disabled\n"); 1707#endif 1708 1709 dev_printk(KERN_INFO, bus(priv)->dev, "CONFIG_IWLWIFI_DEVICE_TESTMODE " 1710#ifdef CONFIG_IWLWIFI_DEVICE_TESTMODE 1711 "enabled\n"); 1712#else 1713 "disabled\n"); 1714#endif 1715 dev_printk(KERN_INFO, bus(priv)->dev, "CONFIG_IWLWIFI_P2P " 1716#ifdef CONFIG_IWLWIFI_P2P 1717 "enabled\n"); 1718#else 1719 "disabled\n"); 1720#endif 1721} 1722 1723int iwl_probe(struct iwl_bus *bus, const struct iwl_trans_ops *trans_ops, 1724 struct iwl_cfg *cfg) 1725{ 1726 int err = 0; 1727 struct iwl_priv *priv; 1728 struct ieee80211_hw *hw; 1729 u16 num_mac; 1730 u32 hw_rev; 1731 1732 /************************ 1733 * 1. Allocating HW data 1734 ************************/ 1735 hw = iwl_alloc_all(); 1736 if (!hw) { 1737 pr_err("%s: Cannot allocate network device\n", cfg->name); 1738 err = -ENOMEM; 1739 goto out; 1740 } 1741 1742 priv = hw->priv; 1743 priv->shrd = &priv->_shrd; 1744 bus->shrd = priv->shrd; 1745 priv->shrd->bus = bus; 1746 priv->shrd->priv = priv; 1747 1748 priv->shrd->trans = trans_ops->alloc(priv->shrd); 1749 if (priv->shrd->trans == NULL) { 1750 err = -ENOMEM; 1751 goto out_free_traffic_mem; 1752 } 1753 1754 /* At this point both hw and priv are allocated. */ 1755 1756 SET_IEEE80211_DEV(hw, bus(priv)->dev); 1757 1758 /* what debugging capabilities we have */ 1759 iwl_debug_config(priv); 1760 1761 IWL_DEBUG_INFO(priv, "*** LOAD DRIVER ***\n"); 1762 cfg(priv) = cfg; 1763 1764 /* is antenna coupling more than 35dB ? */ 1765 priv->bt_ant_couple_ok = 1766 (iwlagn_mod_params.ant_coupling > 1767 IWL_BT_ANTENNA_COUPLING_THRESHOLD) ? 1768 true : false; 1769 1770 /* enable/disable bt channel inhibition */ 1771 priv->bt_ch_announce = iwlagn_mod_params.bt_ch_announce; 1772 IWL_DEBUG_INFO(priv, "BT channel inhibition is %s\n", 1773 (priv->bt_ch_announce) ? "On" : "Off"); 1774 1775 if (iwl_alloc_traffic_mem(priv)) 1776 IWL_ERR(priv, "Not enough memory to generate traffic log\n"); 1777 1778 /* these spin locks will be used in apm_ops.init and EEPROM access 1779 * we should init now 1780 */ 1781 spin_lock_init(&bus(priv)->reg_lock); 1782 spin_lock_init(&priv->shrd->lock); 1783 1784 /* 1785 * stop and reset the on-board processor just in case it is in a 1786 * strange state ... like being left stranded by a primary kernel 1787 * and this is now the kdump kernel trying to start up 1788 */ 1789 iwl_write32(bus(priv), CSR_RESET, CSR_RESET_REG_FLAG_NEVO_RESET); 1790 1791 /*********************** 1792 * 3. Read REV register 1793 ***********************/ 1794 hw_rev = iwl_hw_detect(priv); 1795 IWL_INFO(priv, "Detected %s, REV=0x%X\n", 1796 cfg(priv)->name, hw_rev); 1797 1798 err = iwl_trans_request_irq(trans(priv)); 1799 if (err) 1800 goto out_free_trans; 1801 1802 if (iwl_trans_prepare_card_hw(trans(priv))) { 1803 err = -EIO; 1804 IWL_WARN(priv, "Failed, HW not ready\n"); 1805 goto out_free_trans; 1806 } 1807 1808 /***************** 1809 * 4. Read EEPROM 1810 *****************/ 1811 /* Read the EEPROM */ 1812 err = iwl_eeprom_init(priv, hw_rev); 1813 if (err) { 1814 IWL_ERR(priv, "Unable to init EEPROM\n"); 1815 goto out_free_trans; 1816 } 1817 err = iwl_eeprom_check_version(priv); 1818 if (err) 1819 goto out_free_eeprom; 1820 1821 err = iwl_eeprom_check_sku(priv); 1822 if (err) 1823 goto out_free_eeprom; 1824 1825 /* extract MAC Address */ 1826 iwl_eeprom_get_mac(priv->shrd, priv->addresses[0].addr); 1827 IWL_DEBUG_INFO(priv, "MAC address: %pM\n", priv->addresses[0].addr); 1828 priv->hw->wiphy->addresses = priv->addresses; 1829 priv->hw->wiphy->n_addresses = 1; 1830 num_mac = iwl_eeprom_query16(priv->shrd, EEPROM_NUM_MAC_ADDRESS); 1831 if (num_mac > 1) { 1832 memcpy(priv->addresses[1].addr, priv->addresses[0].addr, 1833 ETH_ALEN); 1834 priv->addresses[1].addr[5]++; 1835 priv->hw->wiphy->n_addresses++; 1836 } 1837 1838 /************************ 1839 * 5. Setup HW constants 1840 ************************/ 1841 if (iwl_set_hw_params(priv)) { 1842 err = -ENOENT; 1843 IWL_ERR(priv, "failed to set hw parameters\n"); 1844 goto out_free_eeprom; 1845 } 1846 1847 /******************* 1848 * 6. Setup priv 1849 *******************/ 1850 1851 err = iwl_init_drv(priv); 1852 if (err) 1853 goto out_free_eeprom; 1854 /* At this point both hw and priv are initialized. */ 1855 1856 /******************** 1857 * 7. Setup services 1858 ********************/ 1859 iwl_setup_deferred_work(priv); 1860 iwl_setup_rx_handlers(priv); 1861 iwl_testmode_init(priv); 1862 1863 /********************************************* 1864 * 8. Enable interrupts 1865 *********************************************/ 1866 1867 iwl_enable_rfkill_int(priv); 1868 1869 /* If platform's RF_KILL switch is NOT set to KILL */ 1870 if (iwl_read32(bus(priv), 1871 CSR_GP_CNTRL) & CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW) 1872 clear_bit(STATUS_RF_KILL_HW, &priv->shrd->status); 1873 else 1874 set_bit(STATUS_RF_KILL_HW, &priv->shrd->status); 1875 1876 wiphy_rfkill_set_hw_state(priv->hw->wiphy, 1877 test_bit(STATUS_RF_KILL_HW, &priv->shrd->status)); 1878 1879 iwl_power_initialize(priv); 1880 iwl_tt_initialize(priv); 1881 1882 init_completion(&priv->firmware_loading_complete); 1883 1884 err = iwl_request_firmware(priv, true); 1885 if (err) 1886 goto out_destroy_workqueue; 1887 1888 return 0; 1889 1890out_destroy_workqueue: 1891 destroy_workqueue(priv->shrd->workqueue); 1892 priv->shrd->workqueue = NULL; 1893 iwl_uninit_drv(priv); 1894out_free_eeprom: 1895 iwl_eeprom_free(priv->shrd); 1896out_free_trans: 1897 iwl_trans_free(trans(priv)); 1898out_free_traffic_mem: 1899 iwl_free_traffic_mem(priv); 1900 ieee80211_free_hw(priv->hw); 1901out: 1902 return err; 1903} 1904 1905void __devexit iwl_remove(struct iwl_priv * priv) 1906{ 1907 wait_for_completion(&priv->firmware_loading_complete); 1908 1909 IWL_DEBUG_INFO(priv, "*** UNLOAD DRIVER ***\n"); 1910 1911 iwl_dbgfs_unregister(priv); 1912 1913 /* ieee80211_unregister_hw call wil cause iwlagn_mac_stop to 1914 * to be called and iwl_down since we are removing the device 1915 * we need to set STATUS_EXIT_PENDING bit. 1916 */ 1917 set_bit(STATUS_EXIT_PENDING, &priv->shrd->status); 1918 1919 iwl_testmode_cleanup(priv); 1920 iwlagn_mac_unregister(priv); 1921 1922 iwl_tt_exit(priv); 1923 1924 /*This will stop the queues, move the device to low power state */ 1925 iwl_trans_stop_device(trans(priv)); 1926 1927 iwl_dealloc_ucode(trans(priv)); 1928 1929 iwl_eeprom_free(priv->shrd); 1930 1931 /*netif_stop_queue(dev); */ 1932 flush_workqueue(priv->shrd->workqueue); 1933 1934 /* ieee80211_unregister_hw calls iwlagn_mac_stop, which flushes 1935 * priv->shrd->workqueue... so we can't take down the workqueue 1936 * until now... */ 1937 destroy_workqueue(priv->shrd->workqueue); 1938 priv->shrd->workqueue = NULL; 1939 iwl_free_traffic_mem(priv); 1940 1941 iwl_trans_free(trans(priv)); 1942 1943 iwl_uninit_drv(priv); 1944 1945 dev_kfree_skb(priv->beacon_skb); 1946 1947 ieee80211_free_hw(priv->hw); 1948} 1949 1950 1951/***************************************************************************** 1952 * 1953 * driver and module entry point 1954 * 1955 *****************************************************************************/ 1956static int __init iwl_init(void) 1957{ 1958 1959 int ret; 1960 pr_info(DRV_DESCRIPTION ", " DRV_VERSION "\n"); 1961 pr_info(DRV_COPYRIGHT "\n"); 1962 1963 ret = iwlagn_rate_control_register(); 1964 if (ret) { 1965 pr_err("Unable to register rate control algorithm: %d\n", ret); 1966 return ret; 1967 } 1968 1969 ret = iwl_pci_register_driver(); 1970 1971 if (ret) 1972 goto error_register; 1973 return ret; 1974 1975error_register: 1976 iwlagn_rate_control_unregister(); 1977 return ret; 1978} 1979 1980static void __exit iwl_exit(void) 1981{ 1982 iwl_pci_unregister_driver(); 1983 iwlagn_rate_control_unregister(); 1984} 1985 1986module_exit(iwl_exit); 1987module_init(iwl_init); 1988 1989#ifdef CONFIG_IWLWIFI_DEBUG 1990module_param_named(debug, iwlagn_mod_params.debug_level, uint, 1991 S_IRUGO | S_IWUSR); 1992MODULE_PARM_DESC(debug, "debug output mask"); 1993#endif 1994 1995module_param_named(swcrypto, iwlagn_mod_params.sw_crypto, int, S_IRUGO); 1996MODULE_PARM_DESC(swcrypto, "using crypto in software (default 0 [hardware])"); 1997module_param_named(queues_num, iwlagn_mod_params.num_of_queues, int, S_IRUGO); 1998MODULE_PARM_DESC(queues_num, "number of hw queues."); 1999module_param_named(11n_disable, iwlagn_mod_params.disable_11n, uint, S_IRUGO); 2000MODULE_PARM_DESC(11n_disable, 2001 "disable 11n functionality, bitmap: 1: full, 2: agg TX, 4: agg RX"); 2002module_param_named(amsdu_size_8K, iwlagn_mod_params.amsdu_size_8K, 2003 int, S_IRUGO); 2004MODULE_PARM_DESC(amsdu_size_8K, "enable 8K amsdu size"); 2005module_param_named(fw_restart, iwlagn_mod_params.restart_fw, int, S_IRUGO); 2006MODULE_PARM_DESC(fw_restart, "restart firmware in case of error"); 2007 2008module_param_named(ucode_alternative, 2009 iwlagn_mod_params.wanted_ucode_alternative, 2010 int, S_IRUGO); 2011MODULE_PARM_DESC(ucode_alternative, 2012 "specify ucode alternative to use from ucode file"); 2013 2014module_param_named(antenna_coupling, iwlagn_mod_params.ant_coupling, 2015 int, S_IRUGO); 2016MODULE_PARM_DESC(antenna_coupling, 2017 "specify antenna coupling in dB (defualt: 0 dB)"); 2018 2019module_param_named(bt_ch_inhibition, iwlagn_mod_params.bt_ch_announce, 2020 bool, S_IRUGO); 2021MODULE_PARM_DESC(bt_ch_inhibition, 2022 "Enable BT channel inhibition (default: enable)"); 2023 2024module_param_named(plcp_check, iwlagn_mod_params.plcp_check, bool, S_IRUGO); 2025MODULE_PARM_DESC(plcp_check, "Check plcp health (default: 1 [enabled])"); 2026 2027module_param_named(ack_check, iwlagn_mod_params.ack_check, bool, S_IRUGO); 2028MODULE_PARM_DESC(ack_check, "Check ack health (default: 0 [disabled])"); 2029 2030module_param_named(wd_disable, iwlagn_mod_params.wd_disable, int, S_IRUGO); 2031MODULE_PARM_DESC(wd_disable, 2032 "Disable stuck queue watchdog timer 0=system default, " 2033 "1=disable, 2=enable (default: 0)"); 2034 2035/* 2036 * set bt_coex_active to true, uCode will do kill/defer 2037 * every time the priority line is asserted (BT is sending signals on the 2038 * priority line in the PCIx). 2039 * set bt_coex_active to false, uCode will ignore the BT activity and 2040 * perform the normal operation 2041 * 2042 * User might experience transmit issue on some platform due to WiFi/BT 2043 * co-exist problem. The possible behaviors are: 2044 * Able to scan and finding all the available AP 2045 * Not able to associate with any AP 2046 * On those platforms, WiFi communication can be restored by set 2047 * "bt_coex_active" module parameter to "false" 2048 * 2049 * default: bt_coex_active = true (BT_COEX_ENABLE) 2050 */ 2051module_param_named(bt_coex_active, iwlagn_mod_params.bt_coex_active, 2052 bool, S_IRUGO); 2053MODULE_PARM_DESC(bt_coex_active, "enable wifi/bt co-exist (default: enable)"); 2054 2055module_param_named(led_mode, iwlagn_mod_params.led_mode, int, S_IRUGO); 2056MODULE_PARM_DESC(led_mode, "0=system default, " 2057 "1=On(RF On)/Off(RF Off), 2=blinking (default: 0)"); 2058 2059module_param_named(power_save, iwlagn_mod_params.power_save, 2060 bool, S_IRUGO); 2061MODULE_PARM_DESC(power_save, 2062 "enable WiFi power management (default: disable)"); 2063 2064module_param_named(power_level, iwlagn_mod_params.power_level, 2065 int, S_IRUGO); 2066MODULE_PARM_DESC(power_level, 2067 "default power save level (range from 1 - 5, default: 1)"); 2068 2069module_param_named(auto_agg, iwlagn_mod_params.auto_agg, 2070 bool, S_IRUGO); 2071MODULE_PARM_DESC(auto_agg, 2072 "enable agg w/o check traffic load (default: enable)"); 2073 2074/* 2075 * For now, keep using power level 1 instead of automatically 2076 * adjusting ... 2077 */ 2078module_param_named(no_sleep_autoadjust, iwlagn_mod_params.no_sleep_autoadjust, 2079 bool, S_IRUGO); 2080MODULE_PARM_DESC(no_sleep_autoadjust, 2081 "don't automatically adjust sleep level " 2082 "according to maximum network latency (default: true)"); 2083